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


a805dd273ed00c07ed40c6e84df91ebf1b7f4417
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2516 #define SWIG_From_unsigned_SS_int SWIG_From_long
2517 /*@@*/
2518 #else
2519 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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
2601 void wxApp_CleanUp() {
2602 __wxPyCleanup();
2603 }
2604
2605
2606 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2607
2608
2609 SWIGINTERNSHORT int
2610 SWIG_AsCharPtr(PyObject *obj, char **val)
2611 {
2612 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2613 return 1;
2614 }
2615 if (val) {
2616 PyErr_Clear();
2617 SWIG_type_error("char *", obj);
2618 }
2619 return 0;
2620 }
2621
2622
2623 SWIGINTERN PyObject *
2624 SWIG_FromCharPtr(const char* cptr)
2625 {
2626 if (cptr) {
2627 size_t size = strlen(cptr);
2628 if (size > INT_MAX) {
2629 return SWIG_NewPointerObj((char*)(cptr),
2630 SWIG_TypeQuery("char *"), 0);
2631 } else {
2632 if (size != 0) {
2633 return PyString_FromStringAndSize(cptr, size);
2634 } else {
2635 return PyString_FromString(cptr);
2636 }
2637 }
2638 }
2639 Py_INCREF(Py_None);
2640 return Py_None;
2641 }
2642
2643
2644 #ifdef __WXMAC__
2645
2646 // A dummy class that raises an exception if used...
2647 class wxEventLoop
2648 {
2649 public:
2650 wxEventLoop() { wxPyRaiseNotImplemented(); }
2651 int Run() { return 0; }
2652 void Exit(int rc = 0) {}
2653 bool Pending() const { return false; }
2654 bool Dispatch() { return false; }
2655 bool IsRunning() const { return false; }
2656 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2657 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2658 };
2659
2660 #else
2661
2662 #include <wx/evtloop.h>
2663
2664 #endif
2665
2666
2667
2668 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2669 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2670 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2671 static PyObject *wxWindow_GetChildren(wxWindow *self){
2672 wxWindowList& list = self->GetChildren();
2673 return wxPy_ConvertList(&list);
2674 }
2675 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2676 #if wxUSE_HOTKEY
2677 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2678 #else
2679 return false;
2680 #endif
2681 }
2682 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2683
2684
2685
2686 return false;
2687
2688 }
2689 static long wxWindow_GetHandle(wxWindow *self){
2690 return wxPyGetWinHandle(self);
2691 }
2692 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2693 self->AssociateHandle((WXWidget)handle);
2694 }
2695
2696 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2697 return wxWindow::FindWindowById(id, parent);
2698 }
2699
2700 wxWindow* wxFindWindowByName( const wxString& name,
2701 const wxWindow *parent = NULL ) {
2702 return wxWindow::FindWindowByName(name, parent);
2703 }
2704
2705 wxWindow* wxFindWindowByLabel( const wxString& label,
2706 const wxWindow *parent = NULL ) {
2707 return wxWindow::FindWindowByLabel(label, parent);
2708 }
2709
2710
2711 #ifdef __WXMSW__
2712 #include <wx/msw/private.h> // to get wxGetWindowId
2713 #endif
2714
2715
2716 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2717 #ifdef __WXMSW__
2718 WXHWND hWnd = (WXHWND)_hWnd;
2719 long id = wxGetWindowId(hWnd);
2720 wxWindow* win = new wxWindow;
2721 parent->AddChild(win);
2722 win->SetEventHandler(win);
2723 win->SetHWND(hWnd);
2724 win->SetId(id);
2725 win->SubclassWin(hWnd);
2726 win->AdoptAttributesFromHWND();
2727 win->SetupColours();
2728 return win;
2729 #else
2730 wxPyRaiseNotImplemented();
2731 return NULL;
2732 #endif
2733 }
2734
2735
2736 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2737 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2738 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2739
2740 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2741
2742 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2743 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2744 wxMenuItemList& list = self->GetMenuItems();
2745 return wxPy_ConvertList(&list);
2746 }
2747 static const wxString wxPyControlNameStr(wxControlNameStr);
2748 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2749 if (clientData) {
2750 wxPyClientData* data = new wxPyClientData(clientData);
2751 return self->Append(item, data);
2752 } else
2753 return self->Append(item);
2754 }
2755 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2756 if (clientData) {
2757 wxPyClientData* data = new wxPyClientData(clientData);
2758 return self->Insert(item, pos, data);
2759 } else
2760 return self->Insert(item, pos);
2761 }
2762 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2763 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2764 if (data) {
2765 Py_INCREF(data->m_obj);
2766 return data->m_obj;
2767 } else {
2768 Py_INCREF(Py_None);
2769 return Py_None;
2770 }
2771 }
2772 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2773 wxPyClientData* data = new wxPyClientData(clientData);
2774 self->SetClientObject(n, data);
2775 }
2776
2777
2778 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2779 wxPyUserData* data = NULL;
2780 if ( userData ) {
2781 bool blocked = wxPyBeginBlockThreads();
2782 data = new wxPyUserData(userData);
2783 wxPyEndBlockThreads(blocked);
2784 }
2785 return new wxSizerItem(window, proportion, flag, border, data);
2786 }
2787 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2788 wxPyUserData* data = NULL;
2789 if ( userData ) {
2790 bool blocked = wxPyBeginBlockThreads();
2791 data = new wxPyUserData(userData);
2792 wxPyEndBlockThreads(blocked);
2793 }
2794 return new wxSizerItem(width, height, proportion, flag, border, data);
2795 }
2796 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2797 wxPyUserData* data = NULL;
2798 if ( userData ) {
2799 bool blocked = wxPyBeginBlockThreads();
2800 data = new wxPyUserData(userData);
2801 wxPyEndBlockThreads(blocked);
2802 }
2803 return new wxSizerItem(sizer, proportion, flag, border, data);
2804 }
2805
2806 #include <float.h>
2807 SWIGINTERN int
2808 SWIG_CheckDoubleInRange(double value, double min_value,
2809 double max_value, const char* errmsg)
2810 {
2811 if (value < min_value) {
2812 if (errmsg) {
2813 PyErr_Format(PyExc_OverflowError,
2814 "value %g is less than %s minimum %g",
2815 value, errmsg, min_value);
2816 }
2817 return 0;
2818 } else if (value > max_value) {
2819 if (errmsg) {
2820 PyErr_Format(PyExc_OverflowError,
2821 "value %g is greater than %s maximum %g",
2822 value, errmsg, max_value);
2823 }
2824 return 0;
2825 }
2826 return 1;
2827 }
2828
2829
2830 SWIGINTERN int
2831 SWIG_AsVal_float(PyObject *obj, float *val)
2832 {
2833 const char* errmsg = val ? "float" : (char*)0;
2834 double v;
2835 if (SWIG_AsVal_double(obj, &v)) {
2836 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2837 if (val) *val = (float)(v);
2838 return 1;
2839 } else {
2840 return 0;
2841 }
2842 } else {
2843 PyErr_Clear();
2844 }
2845 if (val) {
2846 SWIG_type_error(errmsg, obj);
2847 }
2848 return 0;
2849 }
2850
2851
2852 SWIGINTERNSHORT float
2853 SWIG_As_float(PyObject* obj)
2854 {
2855 float v;
2856 if (!SWIG_AsVal_float(obj, &v)) {
2857 /*
2858 this is needed to make valgrind/purify happier.
2859 */
2860 memset((void*)&v, 0, sizeof(float));
2861 }
2862 return v;
2863 }
2864
2865
2866 SWIGINTERNSHORT int
2867 SWIG_Check_float(PyObject* obj)
2868 {
2869 return SWIG_AsVal_float(obj, (float*)0);
2870 }
2871
2872
2873 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2874 #define SWIG_From_float PyFloat_FromDouble
2875 /*@@*/
2876
2877 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2878 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2879 if (data) {
2880 Py_INCREF(data->m_obj);
2881 return data->m_obj;
2882 } else {
2883 Py_INCREF(Py_None);
2884 return Py_None;
2885 }
2886 }
2887
2888 // Figure out the type of the sizer item
2889
2890 struct wxPySizerItemInfo {
2891 wxPySizerItemInfo()
2892 : window(NULL), sizer(NULL), gotSize(false),
2893 size(wxDefaultSize), gotPos(false), pos(-1)
2894 {}
2895
2896 wxWindow* window;
2897 wxSizer* sizer;
2898 bool gotSize;
2899 wxSize size;
2900 bool gotPos;
2901 int pos;
2902 };
2903
2904 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2905
2906 wxPySizerItemInfo info;
2907 wxSize size;
2908 wxSize* sizePtr = &size;
2909
2910 // Find out what the type of the item is
2911 // try wxWindow
2912 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2913 PyErr_Clear();
2914 info.window = NULL;
2915
2916 // try wxSizer
2917 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2918 PyErr_Clear();
2919 info.sizer = NULL;
2920
2921 // try wxSize or (w,h)
2922 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2923 info.size = *sizePtr;
2924 info.gotSize = true;
2925 }
2926
2927 // or a single int
2928 if (checkIdx && PyInt_Check(item)) {
2929 info.pos = PyInt_AsLong(item);
2930 info.gotPos = true;
2931 }
2932 }
2933 }
2934
2935 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2936 // no expected type, figure out what kind of error message to generate
2937 if ( !checkSize && !checkIdx )
2938 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2939 else if ( checkSize && !checkIdx )
2940 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2941 else if ( !checkSize && checkIdx)
2942 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2943 else
2944 // can this one happen?
2945 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2946 }
2947
2948 return info;
2949 }
2950
2951 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2952 if (!self->GetClientObject())
2953 self->SetClientObject(new wxPyOORClientData(_self));
2954 }
2955 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2956
2957 wxPyUserData* data = NULL;
2958 bool blocked = wxPyBeginBlockThreads();
2959 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2960 if ( userData && (info.window || info.sizer || info.gotSize) )
2961 data = new wxPyUserData(userData);
2962 wxPyEndBlockThreads(blocked);
2963
2964 // Now call the real Add method if a valid item type was found
2965 if ( info.window )
2966 return self->Add(info.window, proportion, flag, border, data);
2967 else if ( info.sizer )
2968 return self->Add(info.sizer, proportion, flag, border, data);
2969 else if (info.gotSize)
2970 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2971 proportion, flag, border, data);
2972 else
2973 return NULL;
2974 }
2975 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2976
2977 wxPyUserData* data = NULL;
2978 bool blocked = wxPyBeginBlockThreads();
2979 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2980 if ( userData && (info.window || info.sizer || info.gotSize) )
2981 data = new wxPyUserData(userData);
2982 wxPyEndBlockThreads(blocked);
2983
2984 // Now call the real Insert method if a valid item type was found
2985 if ( info.window )
2986 return self->Insert(before, info.window, proportion, flag, border, data);
2987 else if ( info.sizer )
2988 return self->Insert(before, info.sizer, proportion, flag, border, data);
2989 else if (info.gotSize)
2990 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
2991 proportion, flag, border, data);
2992 else
2993 return NULL;
2994 }
2995 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2996
2997 wxPyUserData* data = NULL;
2998 bool blocked = wxPyBeginBlockThreads();
2999 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3000 if ( userData && (info.window || info.sizer || info.gotSize) )
3001 data = new wxPyUserData(userData);
3002 wxPyEndBlockThreads(blocked);
3003
3004 // Now call the real Prepend method if a valid item type was found
3005 if ( info.window )
3006 return self->Prepend(info.window, proportion, flag, border, data);
3007 else if ( info.sizer )
3008 return self->Prepend(info.sizer, proportion, flag, border, data);
3009 else if (info.gotSize)
3010 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3011 proportion, flag, border, data);
3012 else
3013 return NULL;
3014 }
3015 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3016 bool blocked = wxPyBeginBlockThreads();
3017 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3018 wxPyEndBlockThreads(blocked);
3019 if ( info.window )
3020 return self->Remove(info.window);
3021 else if ( info.sizer )
3022 return self->Remove(info.sizer);
3023 else if ( info.gotPos )
3024 return self->Remove(info.pos);
3025 else
3026 return false;
3027 }
3028 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3029 bool blocked = wxPyBeginBlockThreads();
3030 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3031 wxPyEndBlockThreads(blocked);
3032 if ( info.window )
3033 return self->Detach(info.window);
3034 else if ( info.sizer )
3035 return self->Detach(info.sizer);
3036 else if ( info.gotPos )
3037 return self->Detach(info.pos);
3038 else
3039 return false;
3040 }
3041 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3042 bool blocked = wxPyBeginBlockThreads();
3043 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3044 wxPyEndBlockThreads(blocked);
3045 if ( info.window )
3046 return self->GetItem(info.window);
3047 else if ( info.sizer )
3048 return self->GetItem(info.sizer);
3049 else if ( info.gotPos )
3050 return self->GetItem(info.pos);
3051 else
3052 return NULL;
3053 }
3054 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3055 bool blocked = wxPyBeginBlockThreads();
3056 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3057 wxPyEndBlockThreads(blocked);
3058 if ( info.window )
3059 self->SetItemMinSize(info.window, size);
3060 else if ( info.sizer )
3061 self->SetItemMinSize(info.sizer, size);
3062 else if ( info.gotPos )
3063 self->SetItemMinSize(info.pos, size);
3064 }
3065 static PyObject *wxSizer_GetChildren(wxSizer *self){
3066 wxSizerItemList& list = self->GetChildren();
3067 return wxPy_ConvertList(&list);
3068 }
3069 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3070 bool blocked = wxPyBeginBlockThreads();
3071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3072 wxPyEndBlockThreads(blocked);
3073 if ( info.window )
3074 return self->Show(info.window, show, recursive);
3075 else if ( info.sizer )
3076 return self->Show(info.sizer, show, recursive);
3077 else if ( info.gotPos )
3078 return self->Show(info.pos, show);
3079 else
3080 return false;
3081 }
3082 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3083 bool blocked = wxPyBeginBlockThreads();
3084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3085 wxPyEndBlockThreads(blocked);
3086 if ( info.window )
3087 return self->IsShown(info.window);
3088 else if ( info.sizer )
3089 return self->IsShown(info.sizer);
3090 else if ( info.gotPos )
3091 return self->IsShown(info.pos);
3092 else
3093 return false;
3094 }
3095
3096 // See pyclasses.h
3097 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3098 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3099 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3100
3101
3102
3103
3104 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3105 {
3106 if (source == Py_None) {
3107 **obj = wxGBPosition(-1,-1);
3108 return true;
3109 }
3110 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3111 }
3112
3113 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3114 {
3115 if (source == Py_None) {
3116 **obj = wxGBSpan(-1,-1);
3117 return true;
3118 }
3119 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3120 }
3121
3122
3123 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3124 self->SetRow(row);
3125 self->SetCol(col);
3126 }
3127 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3128 bool blocked = wxPyBeginBlockThreads();
3129 PyObject* tup = PyTuple_New(2);
3130 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3131 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3132 wxPyEndBlockThreads(blocked);
3133 return tup;
3134 }
3135 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3136 self->SetRowspan(rowspan);
3137 self->SetColspan(colspan);
3138 }
3139 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3140 bool blocked = wxPyBeginBlockThreads();
3141 PyObject* tup = PyTuple_New(2);
3142 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3143 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3144 wxPyEndBlockThreads(blocked);
3145 return tup;
3146 }
3147 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3148 wxPyUserData* data = NULL;
3149 if ( userData ) {
3150 bool blocked = wxPyBeginBlockThreads();
3151 data = new wxPyUserData(userData);
3152 wxPyEndBlockThreads(blocked);
3153 }
3154 return new wxGBSizerItem(window, pos, span, flag, border, data);
3155 }
3156 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3157 wxPyUserData* data = NULL;
3158 if ( userData ) {
3159 bool blocked = wxPyBeginBlockThreads();
3160 data = new wxPyUserData(userData);
3161 wxPyEndBlockThreads(blocked);
3162 }
3163 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3164 }
3165 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3166 wxPyUserData* data = NULL;
3167 if ( userData ) {
3168 bool blocked = wxPyBeginBlockThreads();
3169 data = new wxPyUserData(userData);
3170 wxPyEndBlockThreads(blocked);
3171 }
3172 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3173 }
3174 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3175 int row, col;
3176 self->GetEndPos(row, col);
3177 return wxGBPosition(row, col);
3178 }
3179 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3180
3181 wxPyUserData* data = NULL;
3182 bool blocked = wxPyBeginBlockThreads();
3183 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3184 if ( userData && (info.window || info.sizer || info.gotSize) )
3185 data = new wxPyUserData(userData);
3186 wxPyEndBlockThreads(blocked);
3187
3188 // Now call the real Add method if a valid item type was found
3189 if ( info.window )
3190 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3191 else if ( info.sizer )
3192 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3193 else if (info.gotSize)
3194 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3195 pos, span, flag, border, data);
3196 return NULL;
3197 }
3198
3199
3200 #ifdef __cplusplus
3201 extern "C" {
3202 #endif
3203 static int _wrap_EmptyString_set(PyObject *) {
3204 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3205 return 1;
3206 }
3207
3208
3209 static PyObject *_wrap_EmptyString_get(void) {
3210 PyObject *pyobj;
3211
3212 {
3213 #if wxUSE_UNICODE
3214 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3215 #else
3216 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3217 #endif
3218 }
3219 return pyobj;
3220 }
3221
3222
3223 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3224 PyObject *resultobj;
3225 wxObject *arg1 = (wxObject *) 0 ;
3226 wxString result;
3227 PyObject * obj0 = 0 ;
3228 char *kwnames[] = {
3229 (char *) "self", NULL
3230 };
3231
3232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3234 if (SWIG_arg_fail(1)) SWIG_fail;
3235 {
3236 PyThreadState* __tstate = wxPyBeginAllowThreads();
3237 result = wxObject_GetClassName(arg1);
3238
3239 wxPyEndAllowThreads(__tstate);
3240 if (PyErr_Occurred()) SWIG_fail;
3241 }
3242 {
3243 #if wxUSE_UNICODE
3244 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3245 #else
3246 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3247 #endif
3248 }
3249 return resultobj;
3250 fail:
3251 return NULL;
3252 }
3253
3254
3255 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3256 PyObject *resultobj;
3257 wxObject *arg1 = (wxObject *) 0 ;
3258 PyObject * obj0 = 0 ;
3259 char *kwnames[] = {
3260 (char *) "self", NULL
3261 };
3262
3263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3265 if (SWIG_arg_fail(1)) SWIG_fail;
3266 {
3267 PyThreadState* __tstate = wxPyBeginAllowThreads();
3268 wxObject_Destroy(arg1);
3269
3270 wxPyEndAllowThreads(__tstate);
3271 if (PyErr_Occurred()) SWIG_fail;
3272 }
3273 Py_INCREF(Py_None); resultobj = Py_None;
3274 return resultobj;
3275 fail:
3276 return NULL;
3277 }
3278
3279
3280 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3281 PyObject *obj;
3282 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3283 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3284 Py_INCREF(obj);
3285 return Py_BuildValue((char *)"");
3286 }
3287 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3288 PyObject *resultobj;
3289 wxSize *arg1 = (wxSize *) 0 ;
3290 int arg2 ;
3291 PyObject * obj0 = 0 ;
3292 PyObject * obj1 = 0 ;
3293 char *kwnames[] = {
3294 (char *) "self",(char *) "x", NULL
3295 };
3296
3297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3299 if (SWIG_arg_fail(1)) SWIG_fail;
3300 {
3301 arg2 = (int)(SWIG_As_int(obj1));
3302 if (SWIG_arg_fail(2)) SWIG_fail;
3303 }
3304 if (arg1) (arg1)->x = arg2;
3305
3306 Py_INCREF(Py_None); resultobj = Py_None;
3307 return resultobj;
3308 fail:
3309 return NULL;
3310 }
3311
3312
3313 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3314 PyObject *resultobj;
3315 wxSize *arg1 = (wxSize *) 0 ;
3316 int result;
3317 PyObject * obj0 = 0 ;
3318 char *kwnames[] = {
3319 (char *) "self", NULL
3320 };
3321
3322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3324 if (SWIG_arg_fail(1)) SWIG_fail;
3325 result = (int) ((arg1)->x);
3326
3327 {
3328 resultobj = SWIG_From_int((int)(result));
3329 }
3330 return resultobj;
3331 fail:
3332 return NULL;
3333 }
3334
3335
3336 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3337 PyObject *resultobj;
3338 wxSize *arg1 = (wxSize *) 0 ;
3339 int arg2 ;
3340 PyObject * obj0 = 0 ;
3341 PyObject * obj1 = 0 ;
3342 char *kwnames[] = {
3343 (char *) "self",(char *) "y", NULL
3344 };
3345
3346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3348 if (SWIG_arg_fail(1)) SWIG_fail;
3349 {
3350 arg2 = (int)(SWIG_As_int(obj1));
3351 if (SWIG_arg_fail(2)) SWIG_fail;
3352 }
3353 if (arg1) (arg1)->y = arg2;
3354
3355 Py_INCREF(Py_None); resultobj = Py_None;
3356 return resultobj;
3357 fail:
3358 return NULL;
3359 }
3360
3361
3362 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3363 PyObject *resultobj;
3364 wxSize *arg1 = (wxSize *) 0 ;
3365 int result;
3366 PyObject * obj0 = 0 ;
3367 char *kwnames[] = {
3368 (char *) "self", NULL
3369 };
3370
3371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3373 if (SWIG_arg_fail(1)) SWIG_fail;
3374 result = (int) ((arg1)->y);
3375
3376 {
3377 resultobj = SWIG_From_int((int)(result));
3378 }
3379 return resultobj;
3380 fail:
3381 return NULL;
3382 }
3383
3384
3385 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3386 PyObject *resultobj;
3387 int arg1 = (int) 0 ;
3388 int arg2 = (int) 0 ;
3389 wxSize *result;
3390 PyObject * obj0 = 0 ;
3391 PyObject * obj1 = 0 ;
3392 char *kwnames[] = {
3393 (char *) "w",(char *) "h", NULL
3394 };
3395
3396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3397 if (obj0) {
3398 {
3399 arg1 = (int)(SWIG_As_int(obj0));
3400 if (SWIG_arg_fail(1)) SWIG_fail;
3401 }
3402 }
3403 if (obj1) {
3404 {
3405 arg2 = (int)(SWIG_As_int(obj1));
3406 if (SWIG_arg_fail(2)) SWIG_fail;
3407 }
3408 }
3409 {
3410 PyThreadState* __tstate = wxPyBeginAllowThreads();
3411 result = (wxSize *)new wxSize(arg1,arg2);
3412
3413 wxPyEndAllowThreads(__tstate);
3414 if (PyErr_Occurred()) SWIG_fail;
3415 }
3416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3417 return resultobj;
3418 fail:
3419 return NULL;
3420 }
3421
3422
3423 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3424 PyObject *resultobj;
3425 wxSize *arg1 = (wxSize *) 0 ;
3426 PyObject * obj0 = 0 ;
3427 char *kwnames[] = {
3428 (char *) "self", NULL
3429 };
3430
3431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3433 if (SWIG_arg_fail(1)) SWIG_fail;
3434 {
3435 PyThreadState* __tstate = wxPyBeginAllowThreads();
3436 delete arg1;
3437
3438 wxPyEndAllowThreads(__tstate);
3439 if (PyErr_Occurred()) SWIG_fail;
3440 }
3441 Py_INCREF(Py_None); resultobj = Py_None;
3442 return resultobj;
3443 fail:
3444 return NULL;
3445 }
3446
3447
3448 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3449 PyObject *resultobj;
3450 wxSize *arg1 = (wxSize *) 0 ;
3451 wxSize *arg2 = 0 ;
3452 bool result;
3453 wxSize temp2 ;
3454 PyObject * obj0 = 0 ;
3455 PyObject * obj1 = 0 ;
3456 char *kwnames[] = {
3457 (char *) "self",(char *) "sz", NULL
3458 };
3459
3460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3462 if (SWIG_arg_fail(1)) SWIG_fail;
3463 {
3464 arg2 = &temp2;
3465 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3466 }
3467 {
3468 PyThreadState* __tstate = wxPyBeginAllowThreads();
3469 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3470
3471 wxPyEndAllowThreads(__tstate);
3472 if (PyErr_Occurred()) SWIG_fail;
3473 }
3474 {
3475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3476 }
3477 return resultobj;
3478 fail:
3479 return NULL;
3480 }
3481
3482
3483 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3484 PyObject *resultobj;
3485 wxSize *arg1 = (wxSize *) 0 ;
3486 wxSize *arg2 = 0 ;
3487 bool result;
3488 wxSize temp2 ;
3489 PyObject * obj0 = 0 ;
3490 PyObject * obj1 = 0 ;
3491 char *kwnames[] = {
3492 (char *) "self",(char *) "sz", NULL
3493 };
3494
3495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3497 if (SWIG_arg_fail(1)) SWIG_fail;
3498 {
3499 arg2 = &temp2;
3500 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3501 }
3502 {
3503 PyThreadState* __tstate = wxPyBeginAllowThreads();
3504 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3505
3506 wxPyEndAllowThreads(__tstate);
3507 if (PyErr_Occurred()) SWIG_fail;
3508 }
3509 {
3510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3511 }
3512 return resultobj;
3513 fail:
3514 return NULL;
3515 }
3516
3517
3518 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3519 PyObject *resultobj;
3520 wxSize *arg1 = (wxSize *) 0 ;
3521 wxSize *arg2 = 0 ;
3522 wxSize result;
3523 wxSize temp2 ;
3524 PyObject * obj0 = 0 ;
3525 PyObject * obj1 = 0 ;
3526 char *kwnames[] = {
3527 (char *) "self",(char *) "sz", NULL
3528 };
3529
3530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3532 if (SWIG_arg_fail(1)) SWIG_fail;
3533 {
3534 arg2 = &temp2;
3535 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3536 }
3537 {
3538 PyThreadState* __tstate = wxPyBeginAllowThreads();
3539 result = (arg1)->operator +((wxSize const &)*arg2);
3540
3541 wxPyEndAllowThreads(__tstate);
3542 if (PyErr_Occurred()) SWIG_fail;
3543 }
3544 {
3545 wxSize * resultptr;
3546 resultptr = new wxSize((wxSize &)(result));
3547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3548 }
3549 return resultobj;
3550 fail:
3551 return NULL;
3552 }
3553
3554
3555 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3556 PyObject *resultobj;
3557 wxSize *arg1 = (wxSize *) 0 ;
3558 wxSize *arg2 = 0 ;
3559 wxSize result;
3560 wxSize temp2 ;
3561 PyObject * obj0 = 0 ;
3562 PyObject * obj1 = 0 ;
3563 char *kwnames[] = {
3564 (char *) "self",(char *) "sz", NULL
3565 };
3566
3567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3569 if (SWIG_arg_fail(1)) SWIG_fail;
3570 {
3571 arg2 = &temp2;
3572 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3573 }
3574 {
3575 PyThreadState* __tstate = wxPyBeginAllowThreads();
3576 result = (arg1)->operator -((wxSize const &)*arg2);
3577
3578 wxPyEndAllowThreads(__tstate);
3579 if (PyErr_Occurred()) SWIG_fail;
3580 }
3581 {
3582 wxSize * resultptr;
3583 resultptr = new wxSize((wxSize &)(result));
3584 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3585 }
3586 return resultobj;
3587 fail:
3588 return NULL;
3589 }
3590
3591
3592 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3593 PyObject *resultobj;
3594 wxSize *arg1 = (wxSize *) 0 ;
3595 wxSize *arg2 = 0 ;
3596 wxSize temp2 ;
3597 PyObject * obj0 = 0 ;
3598 PyObject * obj1 = 0 ;
3599 char *kwnames[] = {
3600 (char *) "self",(char *) "sz", NULL
3601 };
3602
3603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3605 if (SWIG_arg_fail(1)) SWIG_fail;
3606 {
3607 arg2 = &temp2;
3608 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3609 }
3610 {
3611 PyThreadState* __tstate = wxPyBeginAllowThreads();
3612 (arg1)->IncTo((wxSize const &)*arg2);
3613
3614 wxPyEndAllowThreads(__tstate);
3615 if (PyErr_Occurred()) SWIG_fail;
3616 }
3617 Py_INCREF(Py_None); resultobj = Py_None;
3618 return resultobj;
3619 fail:
3620 return NULL;
3621 }
3622
3623
3624 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3625 PyObject *resultobj;
3626 wxSize *arg1 = (wxSize *) 0 ;
3627 wxSize *arg2 = 0 ;
3628 wxSize temp2 ;
3629 PyObject * obj0 = 0 ;
3630 PyObject * obj1 = 0 ;
3631 char *kwnames[] = {
3632 (char *) "self",(char *) "sz", NULL
3633 };
3634
3635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3637 if (SWIG_arg_fail(1)) SWIG_fail;
3638 {
3639 arg2 = &temp2;
3640 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3641 }
3642 {
3643 PyThreadState* __tstate = wxPyBeginAllowThreads();
3644 (arg1)->DecTo((wxSize const &)*arg2);
3645
3646 wxPyEndAllowThreads(__tstate);
3647 if (PyErr_Occurred()) SWIG_fail;
3648 }
3649 Py_INCREF(Py_None); resultobj = Py_None;
3650 return resultobj;
3651 fail:
3652 return NULL;
3653 }
3654
3655
3656 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3657 PyObject *resultobj;
3658 wxSize *arg1 = (wxSize *) 0 ;
3659 int arg2 ;
3660 int arg3 ;
3661 PyObject * obj0 = 0 ;
3662 PyObject * obj1 = 0 ;
3663 PyObject * obj2 = 0 ;
3664 char *kwnames[] = {
3665 (char *) "self",(char *) "w",(char *) "h", NULL
3666 };
3667
3668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3670 if (SWIG_arg_fail(1)) SWIG_fail;
3671 {
3672 arg2 = (int)(SWIG_As_int(obj1));
3673 if (SWIG_arg_fail(2)) SWIG_fail;
3674 }
3675 {
3676 arg3 = (int)(SWIG_As_int(obj2));
3677 if (SWIG_arg_fail(3)) SWIG_fail;
3678 }
3679 {
3680 PyThreadState* __tstate = wxPyBeginAllowThreads();
3681 (arg1)->Set(arg2,arg3);
3682
3683 wxPyEndAllowThreads(__tstate);
3684 if (PyErr_Occurred()) SWIG_fail;
3685 }
3686 Py_INCREF(Py_None); resultobj = Py_None;
3687 return resultobj;
3688 fail:
3689 return NULL;
3690 }
3691
3692
3693 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3694 PyObject *resultobj;
3695 wxSize *arg1 = (wxSize *) 0 ;
3696 int arg2 ;
3697 PyObject * obj0 = 0 ;
3698 PyObject * obj1 = 0 ;
3699 char *kwnames[] = {
3700 (char *) "self",(char *) "w", NULL
3701 };
3702
3703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3705 if (SWIG_arg_fail(1)) SWIG_fail;
3706 {
3707 arg2 = (int)(SWIG_As_int(obj1));
3708 if (SWIG_arg_fail(2)) SWIG_fail;
3709 }
3710 {
3711 PyThreadState* __tstate = wxPyBeginAllowThreads();
3712 (arg1)->SetWidth(arg2);
3713
3714 wxPyEndAllowThreads(__tstate);
3715 if (PyErr_Occurred()) SWIG_fail;
3716 }
3717 Py_INCREF(Py_None); resultobj = Py_None;
3718 return resultobj;
3719 fail:
3720 return NULL;
3721 }
3722
3723
3724 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3725 PyObject *resultobj;
3726 wxSize *arg1 = (wxSize *) 0 ;
3727 int arg2 ;
3728 PyObject * obj0 = 0 ;
3729 PyObject * obj1 = 0 ;
3730 char *kwnames[] = {
3731 (char *) "self",(char *) "h", NULL
3732 };
3733
3734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3736 if (SWIG_arg_fail(1)) SWIG_fail;
3737 {
3738 arg2 = (int)(SWIG_As_int(obj1));
3739 if (SWIG_arg_fail(2)) SWIG_fail;
3740 }
3741 {
3742 PyThreadState* __tstate = wxPyBeginAllowThreads();
3743 (arg1)->SetHeight(arg2);
3744
3745 wxPyEndAllowThreads(__tstate);
3746 if (PyErr_Occurred()) SWIG_fail;
3747 }
3748 Py_INCREF(Py_None); resultobj = Py_None;
3749 return resultobj;
3750 fail:
3751 return NULL;
3752 }
3753
3754
3755 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3756 PyObject *resultobj;
3757 wxSize *arg1 = (wxSize *) 0 ;
3758 int result;
3759 PyObject * obj0 = 0 ;
3760 char *kwnames[] = {
3761 (char *) "self", NULL
3762 };
3763
3764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3766 if (SWIG_arg_fail(1)) SWIG_fail;
3767 {
3768 PyThreadState* __tstate = wxPyBeginAllowThreads();
3769 result = (int)((wxSize const *)arg1)->GetWidth();
3770
3771 wxPyEndAllowThreads(__tstate);
3772 if (PyErr_Occurred()) SWIG_fail;
3773 }
3774 {
3775 resultobj = SWIG_From_int((int)(result));
3776 }
3777 return resultobj;
3778 fail:
3779 return NULL;
3780 }
3781
3782
3783 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3784 PyObject *resultobj;
3785 wxSize *arg1 = (wxSize *) 0 ;
3786 int result;
3787 PyObject * obj0 = 0 ;
3788 char *kwnames[] = {
3789 (char *) "self", NULL
3790 };
3791
3792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3794 if (SWIG_arg_fail(1)) SWIG_fail;
3795 {
3796 PyThreadState* __tstate = wxPyBeginAllowThreads();
3797 result = (int)((wxSize const *)arg1)->GetHeight();
3798
3799 wxPyEndAllowThreads(__tstate);
3800 if (PyErr_Occurred()) SWIG_fail;
3801 }
3802 {
3803 resultobj = SWIG_From_int((int)(result));
3804 }
3805 return resultobj;
3806 fail:
3807 return NULL;
3808 }
3809
3810
3811 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3812 PyObject *resultobj;
3813 wxSize *arg1 = (wxSize *) 0 ;
3814 bool result;
3815 PyObject * obj0 = 0 ;
3816 char *kwnames[] = {
3817 (char *) "self", NULL
3818 };
3819
3820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3822 if (SWIG_arg_fail(1)) SWIG_fail;
3823 {
3824 PyThreadState* __tstate = wxPyBeginAllowThreads();
3825 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3826
3827 wxPyEndAllowThreads(__tstate);
3828 if (PyErr_Occurred()) SWIG_fail;
3829 }
3830 {
3831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3832 }
3833 return resultobj;
3834 fail:
3835 return NULL;
3836 }
3837
3838
3839 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3840 PyObject *resultobj;
3841 wxSize *arg1 = (wxSize *) 0 ;
3842 wxSize *arg2 = 0 ;
3843 wxSize temp2 ;
3844 PyObject * obj0 = 0 ;
3845 PyObject * obj1 = 0 ;
3846 char *kwnames[] = {
3847 (char *) "self",(char *) "size", NULL
3848 };
3849
3850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3852 if (SWIG_arg_fail(1)) SWIG_fail;
3853 {
3854 arg2 = &temp2;
3855 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3856 }
3857 {
3858 PyThreadState* __tstate = wxPyBeginAllowThreads();
3859 (arg1)->SetDefaults((wxSize const &)*arg2);
3860
3861 wxPyEndAllowThreads(__tstate);
3862 if (PyErr_Occurred()) SWIG_fail;
3863 }
3864 Py_INCREF(Py_None); resultobj = Py_None;
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj;
3873 wxSize *arg1 = (wxSize *) 0 ;
3874 PyObject *result;
3875 PyObject * obj0 = 0 ;
3876 char *kwnames[] = {
3877 (char *) "self", NULL
3878 };
3879
3880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3882 if (SWIG_arg_fail(1)) SWIG_fail;
3883 {
3884 PyThreadState* __tstate = wxPyBeginAllowThreads();
3885 result = (PyObject *)wxSize_Get(arg1);
3886
3887 wxPyEndAllowThreads(__tstate);
3888 if (PyErr_Occurred()) SWIG_fail;
3889 }
3890 resultobj = result;
3891 return resultobj;
3892 fail:
3893 return NULL;
3894 }
3895
3896
3897 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3898 PyObject *obj;
3899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3900 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3901 Py_INCREF(obj);
3902 return Py_BuildValue((char *)"");
3903 }
3904 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3905 PyObject *resultobj;
3906 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3907 double arg2 ;
3908 PyObject * obj0 = 0 ;
3909 PyObject * obj1 = 0 ;
3910 char *kwnames[] = {
3911 (char *) "self",(char *) "x", NULL
3912 };
3913
3914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3916 if (SWIG_arg_fail(1)) SWIG_fail;
3917 {
3918 arg2 = (double)(SWIG_As_double(obj1));
3919 if (SWIG_arg_fail(2)) SWIG_fail;
3920 }
3921 if (arg1) (arg1)->x = arg2;
3922
3923 Py_INCREF(Py_None); resultobj = Py_None;
3924 return resultobj;
3925 fail:
3926 return NULL;
3927 }
3928
3929
3930 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3931 PyObject *resultobj;
3932 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3933 double result;
3934 PyObject * obj0 = 0 ;
3935 char *kwnames[] = {
3936 (char *) "self", NULL
3937 };
3938
3939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3941 if (SWIG_arg_fail(1)) SWIG_fail;
3942 result = (double) ((arg1)->x);
3943
3944 {
3945 resultobj = SWIG_From_double((double)(result));
3946 }
3947 return resultobj;
3948 fail:
3949 return NULL;
3950 }
3951
3952
3953 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3954 PyObject *resultobj;
3955 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3956 double arg2 ;
3957 PyObject * obj0 = 0 ;
3958 PyObject * obj1 = 0 ;
3959 char *kwnames[] = {
3960 (char *) "self",(char *) "y", NULL
3961 };
3962
3963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3965 if (SWIG_arg_fail(1)) SWIG_fail;
3966 {
3967 arg2 = (double)(SWIG_As_double(obj1));
3968 if (SWIG_arg_fail(2)) SWIG_fail;
3969 }
3970 if (arg1) (arg1)->y = arg2;
3971
3972 Py_INCREF(Py_None); resultobj = Py_None;
3973 return resultobj;
3974 fail:
3975 return NULL;
3976 }
3977
3978
3979 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3980 PyObject *resultobj;
3981 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3982 double result;
3983 PyObject * obj0 = 0 ;
3984 char *kwnames[] = {
3985 (char *) "self", NULL
3986 };
3987
3988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
3989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3990 if (SWIG_arg_fail(1)) SWIG_fail;
3991 result = (double) ((arg1)->y);
3992
3993 {
3994 resultobj = SWIG_From_double((double)(result));
3995 }
3996 return resultobj;
3997 fail:
3998 return NULL;
3999 }
4000
4001
4002 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4003 PyObject *resultobj;
4004 double arg1 = (double) 0.0 ;
4005 double arg2 = (double) 0.0 ;
4006 wxRealPoint *result;
4007 PyObject * obj0 = 0 ;
4008 PyObject * obj1 = 0 ;
4009 char *kwnames[] = {
4010 (char *) "x",(char *) "y", NULL
4011 };
4012
4013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4014 if (obj0) {
4015 {
4016 arg1 = (double)(SWIG_As_double(obj0));
4017 if (SWIG_arg_fail(1)) SWIG_fail;
4018 }
4019 }
4020 if (obj1) {
4021 {
4022 arg2 = (double)(SWIG_As_double(obj1));
4023 if (SWIG_arg_fail(2)) SWIG_fail;
4024 }
4025 }
4026 {
4027 PyThreadState* __tstate = wxPyBeginAllowThreads();
4028 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4029
4030 wxPyEndAllowThreads(__tstate);
4031 if (PyErr_Occurred()) SWIG_fail;
4032 }
4033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4034 return resultobj;
4035 fail:
4036 return NULL;
4037 }
4038
4039
4040 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4041 PyObject *resultobj;
4042 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4043 PyObject * obj0 = 0 ;
4044 char *kwnames[] = {
4045 (char *) "self", NULL
4046 };
4047
4048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4050 if (SWIG_arg_fail(1)) SWIG_fail;
4051 {
4052 PyThreadState* __tstate = wxPyBeginAllowThreads();
4053 delete arg1;
4054
4055 wxPyEndAllowThreads(__tstate);
4056 if (PyErr_Occurred()) SWIG_fail;
4057 }
4058 Py_INCREF(Py_None); resultobj = Py_None;
4059 return resultobj;
4060 fail:
4061 return NULL;
4062 }
4063
4064
4065 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4066 PyObject *resultobj;
4067 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4068 wxRealPoint *arg2 = 0 ;
4069 bool result;
4070 wxRealPoint temp2 ;
4071 PyObject * obj0 = 0 ;
4072 PyObject * obj1 = 0 ;
4073 char *kwnames[] = {
4074 (char *) "self",(char *) "pt", NULL
4075 };
4076
4077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4079 if (SWIG_arg_fail(1)) SWIG_fail;
4080 {
4081 arg2 = &temp2;
4082 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4083 }
4084 {
4085 PyThreadState* __tstate = wxPyBeginAllowThreads();
4086 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4087
4088 wxPyEndAllowThreads(__tstate);
4089 if (PyErr_Occurred()) SWIG_fail;
4090 }
4091 {
4092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4093 }
4094 return resultobj;
4095 fail:
4096 return NULL;
4097 }
4098
4099
4100 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4101 PyObject *resultobj;
4102 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4103 wxRealPoint *arg2 = 0 ;
4104 bool result;
4105 wxRealPoint temp2 ;
4106 PyObject * obj0 = 0 ;
4107 PyObject * obj1 = 0 ;
4108 char *kwnames[] = {
4109 (char *) "self",(char *) "pt", NULL
4110 };
4111
4112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4114 if (SWIG_arg_fail(1)) SWIG_fail;
4115 {
4116 arg2 = &temp2;
4117 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4118 }
4119 {
4120 PyThreadState* __tstate = wxPyBeginAllowThreads();
4121 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4122
4123 wxPyEndAllowThreads(__tstate);
4124 if (PyErr_Occurred()) SWIG_fail;
4125 }
4126 {
4127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4128 }
4129 return resultobj;
4130 fail:
4131 return NULL;
4132 }
4133
4134
4135 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4136 PyObject *resultobj;
4137 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4138 wxRealPoint *arg2 = 0 ;
4139 wxRealPoint result;
4140 wxRealPoint temp2 ;
4141 PyObject * obj0 = 0 ;
4142 PyObject * obj1 = 0 ;
4143 char *kwnames[] = {
4144 (char *) "self",(char *) "pt", NULL
4145 };
4146
4147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4149 if (SWIG_arg_fail(1)) SWIG_fail;
4150 {
4151 arg2 = &temp2;
4152 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4153 }
4154 {
4155 PyThreadState* __tstate = wxPyBeginAllowThreads();
4156 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4157
4158 wxPyEndAllowThreads(__tstate);
4159 if (PyErr_Occurred()) SWIG_fail;
4160 }
4161 {
4162 wxRealPoint * resultptr;
4163 resultptr = new wxRealPoint((wxRealPoint &)(result));
4164 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4165 }
4166 return resultobj;
4167 fail:
4168 return NULL;
4169 }
4170
4171
4172 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4173 PyObject *resultobj;
4174 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4175 wxRealPoint *arg2 = 0 ;
4176 wxRealPoint result;
4177 wxRealPoint temp2 ;
4178 PyObject * obj0 = 0 ;
4179 PyObject * obj1 = 0 ;
4180 char *kwnames[] = {
4181 (char *) "self",(char *) "pt", NULL
4182 };
4183
4184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4186 if (SWIG_arg_fail(1)) SWIG_fail;
4187 {
4188 arg2 = &temp2;
4189 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4190 }
4191 {
4192 PyThreadState* __tstate = wxPyBeginAllowThreads();
4193 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4194
4195 wxPyEndAllowThreads(__tstate);
4196 if (PyErr_Occurred()) SWIG_fail;
4197 }
4198 {
4199 wxRealPoint * resultptr;
4200 resultptr = new wxRealPoint((wxRealPoint &)(result));
4201 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4202 }
4203 return resultobj;
4204 fail:
4205 return NULL;
4206 }
4207
4208
4209 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4210 PyObject *resultobj;
4211 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4212 double arg2 ;
4213 double arg3 ;
4214 PyObject * obj0 = 0 ;
4215 PyObject * obj1 = 0 ;
4216 PyObject * obj2 = 0 ;
4217 char *kwnames[] = {
4218 (char *) "self",(char *) "x",(char *) "y", NULL
4219 };
4220
4221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4223 if (SWIG_arg_fail(1)) SWIG_fail;
4224 {
4225 arg2 = (double)(SWIG_As_double(obj1));
4226 if (SWIG_arg_fail(2)) SWIG_fail;
4227 }
4228 {
4229 arg3 = (double)(SWIG_As_double(obj2));
4230 if (SWIG_arg_fail(3)) SWIG_fail;
4231 }
4232 {
4233 PyThreadState* __tstate = wxPyBeginAllowThreads();
4234 wxRealPoint_Set(arg1,arg2,arg3);
4235
4236 wxPyEndAllowThreads(__tstate);
4237 if (PyErr_Occurred()) SWIG_fail;
4238 }
4239 Py_INCREF(Py_None); resultobj = Py_None;
4240 return resultobj;
4241 fail:
4242 return NULL;
4243 }
4244
4245
4246 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4247 PyObject *resultobj;
4248 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4249 PyObject *result;
4250 PyObject * obj0 = 0 ;
4251 char *kwnames[] = {
4252 (char *) "self", NULL
4253 };
4254
4255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4257 if (SWIG_arg_fail(1)) SWIG_fail;
4258 {
4259 PyThreadState* __tstate = wxPyBeginAllowThreads();
4260 result = (PyObject *)wxRealPoint_Get(arg1);
4261
4262 wxPyEndAllowThreads(__tstate);
4263 if (PyErr_Occurred()) SWIG_fail;
4264 }
4265 resultobj = result;
4266 return resultobj;
4267 fail:
4268 return NULL;
4269 }
4270
4271
4272 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4273 PyObject *obj;
4274 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4275 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4276 Py_INCREF(obj);
4277 return Py_BuildValue((char *)"");
4278 }
4279 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4280 PyObject *resultobj;
4281 wxPoint *arg1 = (wxPoint *) 0 ;
4282 int arg2 ;
4283 PyObject * obj0 = 0 ;
4284 PyObject * obj1 = 0 ;
4285 char *kwnames[] = {
4286 (char *) "self",(char *) "x", NULL
4287 };
4288
4289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4291 if (SWIG_arg_fail(1)) SWIG_fail;
4292 {
4293 arg2 = (int)(SWIG_As_int(obj1));
4294 if (SWIG_arg_fail(2)) SWIG_fail;
4295 }
4296 if (arg1) (arg1)->x = arg2;
4297
4298 Py_INCREF(Py_None); resultobj = Py_None;
4299 return resultobj;
4300 fail:
4301 return NULL;
4302 }
4303
4304
4305 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4306 PyObject *resultobj;
4307 wxPoint *arg1 = (wxPoint *) 0 ;
4308 int result;
4309 PyObject * obj0 = 0 ;
4310 char *kwnames[] = {
4311 (char *) "self", NULL
4312 };
4313
4314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4316 if (SWIG_arg_fail(1)) SWIG_fail;
4317 result = (int) ((arg1)->x);
4318
4319 {
4320 resultobj = SWIG_From_int((int)(result));
4321 }
4322 return resultobj;
4323 fail:
4324 return NULL;
4325 }
4326
4327
4328 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4329 PyObject *resultobj;
4330 wxPoint *arg1 = (wxPoint *) 0 ;
4331 int arg2 ;
4332 PyObject * obj0 = 0 ;
4333 PyObject * obj1 = 0 ;
4334 char *kwnames[] = {
4335 (char *) "self",(char *) "y", NULL
4336 };
4337
4338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4340 if (SWIG_arg_fail(1)) SWIG_fail;
4341 {
4342 arg2 = (int)(SWIG_As_int(obj1));
4343 if (SWIG_arg_fail(2)) SWIG_fail;
4344 }
4345 if (arg1) (arg1)->y = arg2;
4346
4347 Py_INCREF(Py_None); resultobj = Py_None;
4348 return resultobj;
4349 fail:
4350 return NULL;
4351 }
4352
4353
4354 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4355 PyObject *resultobj;
4356 wxPoint *arg1 = (wxPoint *) 0 ;
4357 int result;
4358 PyObject * obj0 = 0 ;
4359 char *kwnames[] = {
4360 (char *) "self", NULL
4361 };
4362
4363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4365 if (SWIG_arg_fail(1)) SWIG_fail;
4366 result = (int) ((arg1)->y);
4367
4368 {
4369 resultobj = SWIG_From_int((int)(result));
4370 }
4371 return resultobj;
4372 fail:
4373 return NULL;
4374 }
4375
4376
4377 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4378 PyObject *resultobj;
4379 int arg1 = (int) 0 ;
4380 int arg2 = (int) 0 ;
4381 wxPoint *result;
4382 PyObject * obj0 = 0 ;
4383 PyObject * obj1 = 0 ;
4384 char *kwnames[] = {
4385 (char *) "x",(char *) "y", NULL
4386 };
4387
4388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4389 if (obj0) {
4390 {
4391 arg1 = (int)(SWIG_As_int(obj0));
4392 if (SWIG_arg_fail(1)) SWIG_fail;
4393 }
4394 }
4395 if (obj1) {
4396 {
4397 arg2 = (int)(SWIG_As_int(obj1));
4398 if (SWIG_arg_fail(2)) SWIG_fail;
4399 }
4400 }
4401 {
4402 PyThreadState* __tstate = wxPyBeginAllowThreads();
4403 result = (wxPoint *)new wxPoint(arg1,arg2);
4404
4405 wxPyEndAllowThreads(__tstate);
4406 if (PyErr_Occurred()) SWIG_fail;
4407 }
4408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4409 return resultobj;
4410 fail:
4411 return NULL;
4412 }
4413
4414
4415 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4416 PyObject *resultobj;
4417 wxPoint *arg1 = (wxPoint *) 0 ;
4418 PyObject * obj0 = 0 ;
4419 char *kwnames[] = {
4420 (char *) "self", NULL
4421 };
4422
4423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4425 if (SWIG_arg_fail(1)) SWIG_fail;
4426 {
4427 PyThreadState* __tstate = wxPyBeginAllowThreads();
4428 delete arg1;
4429
4430 wxPyEndAllowThreads(__tstate);
4431 if (PyErr_Occurred()) SWIG_fail;
4432 }
4433 Py_INCREF(Py_None); resultobj = Py_None;
4434 return resultobj;
4435 fail:
4436 return NULL;
4437 }
4438
4439
4440 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4441 PyObject *resultobj;
4442 wxPoint *arg1 = (wxPoint *) 0 ;
4443 wxPoint *arg2 = 0 ;
4444 bool result;
4445 wxPoint temp2 ;
4446 PyObject * obj0 = 0 ;
4447 PyObject * obj1 = 0 ;
4448 char *kwnames[] = {
4449 (char *) "self",(char *) "pt", NULL
4450 };
4451
4452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4454 if (SWIG_arg_fail(1)) SWIG_fail;
4455 {
4456 arg2 = &temp2;
4457 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4458 }
4459 {
4460 PyThreadState* __tstate = wxPyBeginAllowThreads();
4461 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4462
4463 wxPyEndAllowThreads(__tstate);
4464 if (PyErr_Occurred()) SWIG_fail;
4465 }
4466 {
4467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4468 }
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4476 PyObject *resultobj;
4477 wxPoint *arg1 = (wxPoint *) 0 ;
4478 wxPoint *arg2 = 0 ;
4479 bool result;
4480 wxPoint temp2 ;
4481 PyObject * obj0 = 0 ;
4482 PyObject * obj1 = 0 ;
4483 char *kwnames[] = {
4484 (char *) "self",(char *) "pt", NULL
4485 };
4486
4487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4489 if (SWIG_arg_fail(1)) SWIG_fail;
4490 {
4491 arg2 = &temp2;
4492 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4493 }
4494 {
4495 PyThreadState* __tstate = wxPyBeginAllowThreads();
4496 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4497
4498 wxPyEndAllowThreads(__tstate);
4499 if (PyErr_Occurred()) SWIG_fail;
4500 }
4501 {
4502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4503 }
4504 return resultobj;
4505 fail:
4506 return NULL;
4507 }
4508
4509
4510 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4511 PyObject *resultobj;
4512 wxPoint *arg1 = (wxPoint *) 0 ;
4513 wxPoint *arg2 = 0 ;
4514 wxPoint result;
4515 wxPoint temp2 ;
4516 PyObject * obj0 = 0 ;
4517 PyObject * obj1 = 0 ;
4518 char *kwnames[] = {
4519 (char *) "self",(char *) "pt", NULL
4520 };
4521
4522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4524 if (SWIG_arg_fail(1)) SWIG_fail;
4525 {
4526 arg2 = &temp2;
4527 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4528 }
4529 {
4530 PyThreadState* __tstate = wxPyBeginAllowThreads();
4531 result = (arg1)->operator +((wxPoint const &)*arg2);
4532
4533 wxPyEndAllowThreads(__tstate);
4534 if (PyErr_Occurred()) SWIG_fail;
4535 }
4536 {
4537 wxPoint * resultptr;
4538 resultptr = new wxPoint((wxPoint &)(result));
4539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4540 }
4541 return resultobj;
4542 fail:
4543 return NULL;
4544 }
4545
4546
4547 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4548 PyObject *resultobj;
4549 wxPoint *arg1 = (wxPoint *) 0 ;
4550 wxPoint *arg2 = 0 ;
4551 wxPoint result;
4552 wxPoint temp2 ;
4553 PyObject * obj0 = 0 ;
4554 PyObject * obj1 = 0 ;
4555 char *kwnames[] = {
4556 (char *) "self",(char *) "pt", NULL
4557 };
4558
4559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4561 if (SWIG_arg_fail(1)) SWIG_fail;
4562 {
4563 arg2 = &temp2;
4564 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4565 }
4566 {
4567 PyThreadState* __tstate = wxPyBeginAllowThreads();
4568 result = (arg1)->operator -((wxPoint const &)*arg2);
4569
4570 wxPyEndAllowThreads(__tstate);
4571 if (PyErr_Occurred()) SWIG_fail;
4572 }
4573 {
4574 wxPoint * resultptr;
4575 resultptr = new wxPoint((wxPoint &)(result));
4576 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4577 }
4578 return resultobj;
4579 fail:
4580 return NULL;
4581 }
4582
4583
4584 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4585 PyObject *resultobj;
4586 wxPoint *arg1 = (wxPoint *) 0 ;
4587 wxPoint *arg2 = 0 ;
4588 wxPoint *result;
4589 wxPoint temp2 ;
4590 PyObject * obj0 = 0 ;
4591 PyObject * obj1 = 0 ;
4592 char *kwnames[] = {
4593 (char *) "self",(char *) "pt", NULL
4594 };
4595
4596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4598 if (SWIG_arg_fail(1)) SWIG_fail;
4599 {
4600 arg2 = &temp2;
4601 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4602 }
4603 {
4604 PyThreadState* __tstate = wxPyBeginAllowThreads();
4605 {
4606 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4607 result = (wxPoint *) &_result_ref;
4608 }
4609
4610 wxPyEndAllowThreads(__tstate);
4611 if (PyErr_Occurred()) SWIG_fail;
4612 }
4613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4614 return resultobj;
4615 fail:
4616 return NULL;
4617 }
4618
4619
4620 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4621 PyObject *resultobj;
4622 wxPoint *arg1 = (wxPoint *) 0 ;
4623 wxPoint *arg2 = 0 ;
4624 wxPoint *result;
4625 wxPoint temp2 ;
4626 PyObject * obj0 = 0 ;
4627 PyObject * obj1 = 0 ;
4628 char *kwnames[] = {
4629 (char *) "self",(char *) "pt", NULL
4630 };
4631
4632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4634 if (SWIG_arg_fail(1)) SWIG_fail;
4635 {
4636 arg2 = &temp2;
4637 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4638 }
4639 {
4640 PyThreadState* __tstate = wxPyBeginAllowThreads();
4641 {
4642 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4643 result = (wxPoint *) &_result_ref;
4644 }
4645
4646 wxPyEndAllowThreads(__tstate);
4647 if (PyErr_Occurred()) SWIG_fail;
4648 }
4649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4650 return resultobj;
4651 fail:
4652 return NULL;
4653 }
4654
4655
4656 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4657 PyObject *resultobj;
4658 wxPoint *arg1 = (wxPoint *) 0 ;
4659 long arg2 ;
4660 long arg3 ;
4661 PyObject * obj0 = 0 ;
4662 PyObject * obj1 = 0 ;
4663 PyObject * obj2 = 0 ;
4664 char *kwnames[] = {
4665 (char *) "self",(char *) "x",(char *) "y", NULL
4666 };
4667
4668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4670 if (SWIG_arg_fail(1)) SWIG_fail;
4671 {
4672 arg2 = (long)(SWIG_As_long(obj1));
4673 if (SWIG_arg_fail(2)) SWIG_fail;
4674 }
4675 {
4676 arg3 = (long)(SWIG_As_long(obj2));
4677 if (SWIG_arg_fail(3)) SWIG_fail;
4678 }
4679 {
4680 PyThreadState* __tstate = wxPyBeginAllowThreads();
4681 wxPoint_Set(arg1,arg2,arg3);
4682
4683 wxPyEndAllowThreads(__tstate);
4684 if (PyErr_Occurred()) SWIG_fail;
4685 }
4686 Py_INCREF(Py_None); resultobj = Py_None;
4687 return resultobj;
4688 fail:
4689 return NULL;
4690 }
4691
4692
4693 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4694 PyObject *resultobj;
4695 wxPoint *arg1 = (wxPoint *) 0 ;
4696 PyObject *result;
4697 PyObject * obj0 = 0 ;
4698 char *kwnames[] = {
4699 (char *) "self", NULL
4700 };
4701
4702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4704 if (SWIG_arg_fail(1)) SWIG_fail;
4705 {
4706 PyThreadState* __tstate = wxPyBeginAllowThreads();
4707 result = (PyObject *)wxPoint_Get(arg1);
4708
4709 wxPyEndAllowThreads(__tstate);
4710 if (PyErr_Occurred()) SWIG_fail;
4711 }
4712 resultobj = result;
4713 return resultobj;
4714 fail:
4715 return NULL;
4716 }
4717
4718
4719 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4720 PyObject *obj;
4721 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4722 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4723 Py_INCREF(obj);
4724 return Py_BuildValue((char *)"");
4725 }
4726 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4727 PyObject *resultobj;
4728 int arg1 = (int) 0 ;
4729 int arg2 = (int) 0 ;
4730 int arg3 = (int) 0 ;
4731 int arg4 = (int) 0 ;
4732 wxRect *result;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 PyObject * obj2 = 0 ;
4736 PyObject * obj3 = 0 ;
4737 char *kwnames[] = {
4738 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4739 };
4740
4741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4742 if (obj0) {
4743 {
4744 arg1 = (int)(SWIG_As_int(obj0));
4745 if (SWIG_arg_fail(1)) SWIG_fail;
4746 }
4747 }
4748 if (obj1) {
4749 {
4750 arg2 = (int)(SWIG_As_int(obj1));
4751 if (SWIG_arg_fail(2)) SWIG_fail;
4752 }
4753 }
4754 if (obj2) {
4755 {
4756 arg3 = (int)(SWIG_As_int(obj2));
4757 if (SWIG_arg_fail(3)) SWIG_fail;
4758 }
4759 }
4760 if (obj3) {
4761 {
4762 arg4 = (int)(SWIG_As_int(obj3));
4763 if (SWIG_arg_fail(4)) SWIG_fail;
4764 }
4765 }
4766 {
4767 PyThreadState* __tstate = wxPyBeginAllowThreads();
4768 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4769
4770 wxPyEndAllowThreads(__tstate);
4771 if (PyErr_Occurred()) SWIG_fail;
4772 }
4773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4774 return resultobj;
4775 fail:
4776 return NULL;
4777 }
4778
4779
4780 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4781 PyObject *resultobj;
4782 wxPoint *arg1 = 0 ;
4783 wxPoint *arg2 = 0 ;
4784 wxRect *result;
4785 wxPoint temp1 ;
4786 wxPoint temp2 ;
4787 PyObject * obj0 = 0 ;
4788 PyObject * obj1 = 0 ;
4789 char *kwnames[] = {
4790 (char *) "topLeft",(char *) "bottomRight", NULL
4791 };
4792
4793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4794 {
4795 arg1 = &temp1;
4796 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4797 }
4798 {
4799 arg2 = &temp2;
4800 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4801 }
4802 {
4803 PyThreadState* __tstate = wxPyBeginAllowThreads();
4804 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4805
4806 wxPyEndAllowThreads(__tstate);
4807 if (PyErr_Occurred()) SWIG_fail;
4808 }
4809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4810 return resultobj;
4811 fail:
4812 return NULL;
4813 }
4814
4815
4816 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4817 PyObject *resultobj;
4818 wxPoint *arg1 = 0 ;
4819 wxSize *arg2 = 0 ;
4820 wxRect *result;
4821 wxPoint temp1 ;
4822 wxSize temp2 ;
4823 PyObject * obj0 = 0 ;
4824 PyObject * obj1 = 0 ;
4825 char *kwnames[] = {
4826 (char *) "pos",(char *) "size", NULL
4827 };
4828
4829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4830 {
4831 arg1 = &temp1;
4832 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4833 }
4834 {
4835 arg2 = &temp2;
4836 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4837 }
4838 {
4839 PyThreadState* __tstate = wxPyBeginAllowThreads();
4840 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4841
4842 wxPyEndAllowThreads(__tstate);
4843 if (PyErr_Occurred()) SWIG_fail;
4844 }
4845 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4846 return resultobj;
4847 fail:
4848 return NULL;
4849 }
4850
4851
4852 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4853 PyObject *resultobj;
4854 wxSize *arg1 = 0 ;
4855 wxRect *result;
4856 wxSize temp1 ;
4857 PyObject * obj0 = 0 ;
4858 char *kwnames[] = {
4859 (char *) "size", NULL
4860 };
4861
4862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4863 {
4864 arg1 = &temp1;
4865 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4866 }
4867 {
4868 PyThreadState* __tstate = wxPyBeginAllowThreads();
4869 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4870
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj;
4883 wxRect *arg1 = (wxRect *) 0 ;
4884 PyObject * obj0 = 0 ;
4885 char *kwnames[] = {
4886 (char *) "self", NULL
4887 };
4888
4889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4891 if (SWIG_arg_fail(1)) SWIG_fail;
4892 {
4893 PyThreadState* __tstate = wxPyBeginAllowThreads();
4894 delete arg1;
4895
4896 wxPyEndAllowThreads(__tstate);
4897 if (PyErr_Occurred()) SWIG_fail;
4898 }
4899 Py_INCREF(Py_None); resultobj = Py_None;
4900 return resultobj;
4901 fail:
4902 return NULL;
4903 }
4904
4905
4906 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4907 PyObject *resultobj;
4908 wxRect *arg1 = (wxRect *) 0 ;
4909 int result;
4910 PyObject * obj0 = 0 ;
4911 char *kwnames[] = {
4912 (char *) "self", NULL
4913 };
4914
4915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4917 if (SWIG_arg_fail(1)) SWIG_fail;
4918 {
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 result = (int)((wxRect const *)arg1)->GetX();
4921
4922 wxPyEndAllowThreads(__tstate);
4923 if (PyErr_Occurred()) SWIG_fail;
4924 }
4925 {
4926 resultobj = SWIG_From_int((int)(result));
4927 }
4928 return resultobj;
4929 fail:
4930 return NULL;
4931 }
4932
4933
4934 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4935 PyObject *resultobj;
4936 wxRect *arg1 = (wxRect *) 0 ;
4937 int arg2 ;
4938 PyObject * obj0 = 0 ;
4939 PyObject * obj1 = 0 ;
4940 char *kwnames[] = {
4941 (char *) "self",(char *) "x", NULL
4942 };
4943
4944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4946 if (SWIG_arg_fail(1)) SWIG_fail;
4947 {
4948 arg2 = (int)(SWIG_As_int(obj1));
4949 if (SWIG_arg_fail(2)) SWIG_fail;
4950 }
4951 {
4952 PyThreadState* __tstate = wxPyBeginAllowThreads();
4953 (arg1)->SetX(arg2);
4954
4955 wxPyEndAllowThreads(__tstate);
4956 if (PyErr_Occurred()) SWIG_fail;
4957 }
4958 Py_INCREF(Py_None); resultobj = Py_None;
4959 return resultobj;
4960 fail:
4961 return NULL;
4962 }
4963
4964
4965 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4966 PyObject *resultobj;
4967 wxRect *arg1 = (wxRect *) 0 ;
4968 int result;
4969 PyObject * obj0 = 0 ;
4970 char *kwnames[] = {
4971 (char *) "self", NULL
4972 };
4973
4974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4976 if (SWIG_arg_fail(1)) SWIG_fail;
4977 {
4978 PyThreadState* __tstate = wxPyBeginAllowThreads();
4979 result = (int)(arg1)->GetY();
4980
4981 wxPyEndAllowThreads(__tstate);
4982 if (PyErr_Occurred()) SWIG_fail;
4983 }
4984 {
4985 resultobj = SWIG_From_int((int)(result));
4986 }
4987 return resultobj;
4988 fail:
4989 return NULL;
4990 }
4991
4992
4993 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
4994 PyObject *resultobj;
4995 wxRect *arg1 = (wxRect *) 0 ;
4996 int arg2 ;
4997 PyObject * obj0 = 0 ;
4998 PyObject * obj1 = 0 ;
4999 char *kwnames[] = {
5000 (char *) "self",(char *) "y", NULL
5001 };
5002
5003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5005 if (SWIG_arg_fail(1)) SWIG_fail;
5006 {
5007 arg2 = (int)(SWIG_As_int(obj1));
5008 if (SWIG_arg_fail(2)) SWIG_fail;
5009 }
5010 {
5011 PyThreadState* __tstate = wxPyBeginAllowThreads();
5012 (arg1)->SetY(arg2);
5013
5014 wxPyEndAllowThreads(__tstate);
5015 if (PyErr_Occurred()) SWIG_fail;
5016 }
5017 Py_INCREF(Py_None); resultobj = Py_None;
5018 return resultobj;
5019 fail:
5020 return NULL;
5021 }
5022
5023
5024 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5025 PyObject *resultobj;
5026 wxRect *arg1 = (wxRect *) 0 ;
5027 int result;
5028 PyObject * obj0 = 0 ;
5029 char *kwnames[] = {
5030 (char *) "self", NULL
5031 };
5032
5033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5035 if (SWIG_arg_fail(1)) SWIG_fail;
5036 {
5037 PyThreadState* __tstate = wxPyBeginAllowThreads();
5038 result = (int)((wxRect const *)arg1)->GetWidth();
5039
5040 wxPyEndAllowThreads(__tstate);
5041 if (PyErr_Occurred()) SWIG_fail;
5042 }
5043 {
5044 resultobj = SWIG_From_int((int)(result));
5045 }
5046 return resultobj;
5047 fail:
5048 return NULL;
5049 }
5050
5051
5052 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5053 PyObject *resultobj;
5054 wxRect *arg1 = (wxRect *) 0 ;
5055 int arg2 ;
5056 PyObject * obj0 = 0 ;
5057 PyObject * obj1 = 0 ;
5058 char *kwnames[] = {
5059 (char *) "self",(char *) "w", NULL
5060 };
5061
5062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5064 if (SWIG_arg_fail(1)) SWIG_fail;
5065 {
5066 arg2 = (int)(SWIG_As_int(obj1));
5067 if (SWIG_arg_fail(2)) SWIG_fail;
5068 }
5069 {
5070 PyThreadState* __tstate = wxPyBeginAllowThreads();
5071 (arg1)->SetWidth(arg2);
5072
5073 wxPyEndAllowThreads(__tstate);
5074 if (PyErr_Occurred()) SWIG_fail;
5075 }
5076 Py_INCREF(Py_None); resultobj = Py_None;
5077 return resultobj;
5078 fail:
5079 return NULL;
5080 }
5081
5082
5083 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5084 PyObject *resultobj;
5085 wxRect *arg1 = (wxRect *) 0 ;
5086 int result;
5087 PyObject * obj0 = 0 ;
5088 char *kwnames[] = {
5089 (char *) "self", NULL
5090 };
5091
5092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5094 if (SWIG_arg_fail(1)) SWIG_fail;
5095 {
5096 PyThreadState* __tstate = wxPyBeginAllowThreads();
5097 result = (int)((wxRect const *)arg1)->GetHeight();
5098
5099 wxPyEndAllowThreads(__tstate);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 {
5103 resultobj = SWIG_From_int((int)(result));
5104 }
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5112 PyObject *resultobj;
5113 wxRect *arg1 = (wxRect *) 0 ;
5114 int arg2 ;
5115 PyObject * obj0 = 0 ;
5116 PyObject * obj1 = 0 ;
5117 char *kwnames[] = {
5118 (char *) "self",(char *) "h", NULL
5119 };
5120
5121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5123 if (SWIG_arg_fail(1)) SWIG_fail;
5124 {
5125 arg2 = (int)(SWIG_As_int(obj1));
5126 if (SWIG_arg_fail(2)) SWIG_fail;
5127 }
5128 {
5129 PyThreadState* __tstate = wxPyBeginAllowThreads();
5130 (arg1)->SetHeight(arg2);
5131
5132 wxPyEndAllowThreads(__tstate);
5133 if (PyErr_Occurred()) SWIG_fail;
5134 }
5135 Py_INCREF(Py_None); resultobj = Py_None;
5136 return resultobj;
5137 fail:
5138 return NULL;
5139 }
5140
5141
5142 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5143 PyObject *resultobj;
5144 wxRect *arg1 = (wxRect *) 0 ;
5145 wxPoint result;
5146 PyObject * obj0 = 0 ;
5147 char *kwnames[] = {
5148 (char *) "self", NULL
5149 };
5150
5151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5153 if (SWIG_arg_fail(1)) SWIG_fail;
5154 {
5155 PyThreadState* __tstate = wxPyBeginAllowThreads();
5156 result = ((wxRect const *)arg1)->GetPosition();
5157
5158 wxPyEndAllowThreads(__tstate);
5159 if (PyErr_Occurred()) SWIG_fail;
5160 }
5161 {
5162 wxPoint * resultptr;
5163 resultptr = new wxPoint((wxPoint &)(result));
5164 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5165 }
5166 return resultobj;
5167 fail:
5168 return NULL;
5169 }
5170
5171
5172 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5173 PyObject *resultobj;
5174 wxRect *arg1 = (wxRect *) 0 ;
5175 wxPoint *arg2 = 0 ;
5176 wxPoint temp2 ;
5177 PyObject * obj0 = 0 ;
5178 PyObject * obj1 = 0 ;
5179 char *kwnames[] = {
5180 (char *) "self",(char *) "p", NULL
5181 };
5182
5183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5185 if (SWIG_arg_fail(1)) SWIG_fail;
5186 {
5187 arg2 = &temp2;
5188 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5189 }
5190 {
5191 PyThreadState* __tstate = wxPyBeginAllowThreads();
5192 (arg1)->SetPosition((wxPoint const &)*arg2);
5193
5194 wxPyEndAllowThreads(__tstate);
5195 if (PyErr_Occurred()) SWIG_fail;
5196 }
5197 Py_INCREF(Py_None); resultobj = Py_None;
5198 return resultobj;
5199 fail:
5200 return NULL;
5201 }
5202
5203
5204 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5205 PyObject *resultobj;
5206 wxRect *arg1 = (wxRect *) 0 ;
5207 wxSize result;
5208 PyObject * obj0 = 0 ;
5209 char *kwnames[] = {
5210 (char *) "self", NULL
5211 };
5212
5213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5215 if (SWIG_arg_fail(1)) SWIG_fail;
5216 {
5217 PyThreadState* __tstate = wxPyBeginAllowThreads();
5218 result = ((wxRect const *)arg1)->GetSize();
5219
5220 wxPyEndAllowThreads(__tstate);
5221 if (PyErr_Occurred()) SWIG_fail;
5222 }
5223 {
5224 wxSize * resultptr;
5225 resultptr = new wxSize((wxSize &)(result));
5226 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5227 }
5228 return resultobj;
5229 fail:
5230 return NULL;
5231 }
5232
5233
5234 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5235 PyObject *resultobj;
5236 wxRect *arg1 = (wxRect *) 0 ;
5237 wxSize *arg2 = 0 ;
5238 wxSize temp2 ;
5239 PyObject * obj0 = 0 ;
5240 PyObject * obj1 = 0 ;
5241 char *kwnames[] = {
5242 (char *) "self",(char *) "s", NULL
5243 };
5244
5245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5247 if (SWIG_arg_fail(1)) SWIG_fail;
5248 {
5249 arg2 = &temp2;
5250 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5251 }
5252 {
5253 PyThreadState* __tstate = wxPyBeginAllowThreads();
5254 (arg1)->SetSize((wxSize const &)*arg2);
5255
5256 wxPyEndAllowThreads(__tstate);
5257 if (PyErr_Occurred()) SWIG_fail;
5258 }
5259 Py_INCREF(Py_None); resultobj = Py_None;
5260 return resultobj;
5261 fail:
5262 return NULL;
5263 }
5264
5265
5266 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5267 PyObject *resultobj;
5268 wxRect *arg1 = (wxRect *) 0 ;
5269 wxPoint result;
5270 PyObject * obj0 = 0 ;
5271 char *kwnames[] = {
5272 (char *) "self", NULL
5273 };
5274
5275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5277 if (SWIG_arg_fail(1)) SWIG_fail;
5278 {
5279 PyThreadState* __tstate = wxPyBeginAllowThreads();
5280 result = ((wxRect const *)arg1)->GetTopLeft();
5281
5282 wxPyEndAllowThreads(__tstate);
5283 if (PyErr_Occurred()) SWIG_fail;
5284 }
5285 {
5286 wxPoint * resultptr;
5287 resultptr = new wxPoint((wxPoint &)(result));
5288 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5289 }
5290 return resultobj;
5291 fail:
5292 return NULL;
5293 }
5294
5295
5296 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5297 PyObject *resultobj;
5298 wxRect *arg1 = (wxRect *) 0 ;
5299 wxPoint *arg2 = 0 ;
5300 wxPoint temp2 ;
5301 PyObject * obj0 = 0 ;
5302 PyObject * obj1 = 0 ;
5303 char *kwnames[] = {
5304 (char *) "self",(char *) "p", NULL
5305 };
5306
5307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5309 if (SWIG_arg_fail(1)) SWIG_fail;
5310 {
5311 arg2 = &temp2;
5312 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5313 }
5314 {
5315 PyThreadState* __tstate = wxPyBeginAllowThreads();
5316 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5317
5318 wxPyEndAllowThreads(__tstate);
5319 if (PyErr_Occurred()) SWIG_fail;
5320 }
5321 Py_INCREF(Py_None); resultobj = Py_None;
5322 return resultobj;
5323 fail:
5324 return NULL;
5325 }
5326
5327
5328 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5329 PyObject *resultobj;
5330 wxRect *arg1 = (wxRect *) 0 ;
5331 wxPoint result;
5332 PyObject * obj0 = 0 ;
5333 char *kwnames[] = {
5334 (char *) "self", NULL
5335 };
5336
5337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5339 if (SWIG_arg_fail(1)) SWIG_fail;
5340 {
5341 PyThreadState* __tstate = wxPyBeginAllowThreads();
5342 result = ((wxRect const *)arg1)->GetBottomRight();
5343
5344 wxPyEndAllowThreads(__tstate);
5345 if (PyErr_Occurred()) SWIG_fail;
5346 }
5347 {
5348 wxPoint * resultptr;
5349 resultptr = new wxPoint((wxPoint &)(result));
5350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5351 }
5352 return resultobj;
5353 fail:
5354 return NULL;
5355 }
5356
5357
5358 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5359 PyObject *resultobj;
5360 wxRect *arg1 = (wxRect *) 0 ;
5361 wxPoint *arg2 = 0 ;
5362 wxPoint temp2 ;
5363 PyObject * obj0 = 0 ;
5364 PyObject * obj1 = 0 ;
5365 char *kwnames[] = {
5366 (char *) "self",(char *) "p", NULL
5367 };
5368
5369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5371 if (SWIG_arg_fail(1)) SWIG_fail;
5372 {
5373 arg2 = &temp2;
5374 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5375 }
5376 {
5377 PyThreadState* __tstate = wxPyBeginAllowThreads();
5378 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5379
5380 wxPyEndAllowThreads(__tstate);
5381 if (PyErr_Occurred()) SWIG_fail;
5382 }
5383 Py_INCREF(Py_None); resultobj = Py_None;
5384 return resultobj;
5385 fail:
5386 return NULL;
5387 }
5388
5389
5390 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5391 PyObject *resultobj;
5392 wxRect *arg1 = (wxRect *) 0 ;
5393 int result;
5394 PyObject * obj0 = 0 ;
5395 char *kwnames[] = {
5396 (char *) "self", NULL
5397 };
5398
5399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5401 if (SWIG_arg_fail(1)) SWIG_fail;
5402 {
5403 PyThreadState* __tstate = wxPyBeginAllowThreads();
5404 result = (int)((wxRect const *)arg1)->GetLeft();
5405
5406 wxPyEndAllowThreads(__tstate);
5407 if (PyErr_Occurred()) SWIG_fail;
5408 }
5409 {
5410 resultobj = SWIG_From_int((int)(result));
5411 }
5412 return resultobj;
5413 fail:
5414 return NULL;
5415 }
5416
5417
5418 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5419 PyObject *resultobj;
5420 wxRect *arg1 = (wxRect *) 0 ;
5421 int result;
5422 PyObject * obj0 = 0 ;
5423 char *kwnames[] = {
5424 (char *) "self", NULL
5425 };
5426
5427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5429 if (SWIG_arg_fail(1)) SWIG_fail;
5430 {
5431 PyThreadState* __tstate = wxPyBeginAllowThreads();
5432 result = (int)((wxRect const *)arg1)->GetTop();
5433
5434 wxPyEndAllowThreads(__tstate);
5435 if (PyErr_Occurred()) SWIG_fail;
5436 }
5437 {
5438 resultobj = SWIG_From_int((int)(result));
5439 }
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5447 PyObject *resultobj;
5448 wxRect *arg1 = (wxRect *) 0 ;
5449 int result;
5450 PyObject * obj0 = 0 ;
5451 char *kwnames[] = {
5452 (char *) "self", NULL
5453 };
5454
5455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5457 if (SWIG_arg_fail(1)) SWIG_fail;
5458 {
5459 PyThreadState* __tstate = wxPyBeginAllowThreads();
5460 result = (int)((wxRect const *)arg1)->GetBottom();
5461
5462 wxPyEndAllowThreads(__tstate);
5463 if (PyErr_Occurred()) SWIG_fail;
5464 }
5465 {
5466 resultobj = SWIG_From_int((int)(result));
5467 }
5468 return resultobj;
5469 fail:
5470 return NULL;
5471 }
5472
5473
5474 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5475 PyObject *resultobj;
5476 wxRect *arg1 = (wxRect *) 0 ;
5477 int result;
5478 PyObject * obj0 = 0 ;
5479 char *kwnames[] = {
5480 (char *) "self", NULL
5481 };
5482
5483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5485 if (SWIG_arg_fail(1)) SWIG_fail;
5486 {
5487 PyThreadState* __tstate = wxPyBeginAllowThreads();
5488 result = (int)((wxRect const *)arg1)->GetRight();
5489
5490 wxPyEndAllowThreads(__tstate);
5491 if (PyErr_Occurred()) SWIG_fail;
5492 }
5493 {
5494 resultobj = SWIG_From_int((int)(result));
5495 }
5496 return resultobj;
5497 fail:
5498 return NULL;
5499 }
5500
5501
5502 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5503 PyObject *resultobj;
5504 wxRect *arg1 = (wxRect *) 0 ;
5505 int arg2 ;
5506 PyObject * obj0 = 0 ;
5507 PyObject * obj1 = 0 ;
5508 char *kwnames[] = {
5509 (char *) "self",(char *) "left", NULL
5510 };
5511
5512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5514 if (SWIG_arg_fail(1)) SWIG_fail;
5515 {
5516 arg2 = (int)(SWIG_As_int(obj1));
5517 if (SWIG_arg_fail(2)) SWIG_fail;
5518 }
5519 {
5520 PyThreadState* __tstate = wxPyBeginAllowThreads();
5521 (arg1)->SetLeft(arg2);
5522
5523 wxPyEndAllowThreads(__tstate);
5524 if (PyErr_Occurred()) SWIG_fail;
5525 }
5526 Py_INCREF(Py_None); resultobj = Py_None;
5527 return resultobj;
5528 fail:
5529 return NULL;
5530 }
5531
5532
5533 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5534 PyObject *resultobj;
5535 wxRect *arg1 = (wxRect *) 0 ;
5536 int arg2 ;
5537 PyObject * obj0 = 0 ;
5538 PyObject * obj1 = 0 ;
5539 char *kwnames[] = {
5540 (char *) "self",(char *) "right", NULL
5541 };
5542
5543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5545 if (SWIG_arg_fail(1)) SWIG_fail;
5546 {
5547 arg2 = (int)(SWIG_As_int(obj1));
5548 if (SWIG_arg_fail(2)) SWIG_fail;
5549 }
5550 {
5551 PyThreadState* __tstate = wxPyBeginAllowThreads();
5552 (arg1)->SetRight(arg2);
5553
5554 wxPyEndAllowThreads(__tstate);
5555 if (PyErr_Occurred()) SWIG_fail;
5556 }
5557 Py_INCREF(Py_None); resultobj = Py_None;
5558 return resultobj;
5559 fail:
5560 return NULL;
5561 }
5562
5563
5564 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5565 PyObject *resultobj;
5566 wxRect *arg1 = (wxRect *) 0 ;
5567 int arg2 ;
5568 PyObject * obj0 = 0 ;
5569 PyObject * obj1 = 0 ;
5570 char *kwnames[] = {
5571 (char *) "self",(char *) "top", NULL
5572 };
5573
5574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5576 if (SWIG_arg_fail(1)) SWIG_fail;
5577 {
5578 arg2 = (int)(SWIG_As_int(obj1));
5579 if (SWIG_arg_fail(2)) SWIG_fail;
5580 }
5581 {
5582 PyThreadState* __tstate = wxPyBeginAllowThreads();
5583 (arg1)->SetTop(arg2);
5584
5585 wxPyEndAllowThreads(__tstate);
5586 if (PyErr_Occurred()) SWIG_fail;
5587 }
5588 Py_INCREF(Py_None); resultobj = Py_None;
5589 return resultobj;
5590 fail:
5591 return NULL;
5592 }
5593
5594
5595 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5596 PyObject *resultobj;
5597 wxRect *arg1 = (wxRect *) 0 ;
5598 int arg2 ;
5599 PyObject * obj0 = 0 ;
5600 PyObject * obj1 = 0 ;
5601 char *kwnames[] = {
5602 (char *) "self",(char *) "bottom", NULL
5603 };
5604
5605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5607 if (SWIG_arg_fail(1)) SWIG_fail;
5608 {
5609 arg2 = (int)(SWIG_As_int(obj1));
5610 if (SWIG_arg_fail(2)) SWIG_fail;
5611 }
5612 {
5613 PyThreadState* __tstate = wxPyBeginAllowThreads();
5614 (arg1)->SetBottom(arg2);
5615
5616 wxPyEndAllowThreads(__tstate);
5617 if (PyErr_Occurred()) SWIG_fail;
5618 }
5619 Py_INCREF(Py_None); resultobj = Py_None;
5620 return resultobj;
5621 fail:
5622 return NULL;
5623 }
5624
5625
5626 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5627 PyObject *resultobj;
5628 wxRect *arg1 = (wxRect *) 0 ;
5629 int arg2 ;
5630 int arg3 ;
5631 wxRect *result;
5632 PyObject * obj0 = 0 ;
5633 PyObject * obj1 = 0 ;
5634 PyObject * obj2 = 0 ;
5635 char *kwnames[] = {
5636 (char *) "self",(char *) "dx",(char *) "dy", NULL
5637 };
5638
5639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5641 if (SWIG_arg_fail(1)) SWIG_fail;
5642 {
5643 arg2 = (int)(SWIG_As_int(obj1));
5644 if (SWIG_arg_fail(2)) SWIG_fail;
5645 }
5646 {
5647 arg3 = (int)(SWIG_As_int(obj2));
5648 if (SWIG_arg_fail(3)) SWIG_fail;
5649 }
5650 {
5651 PyThreadState* __tstate = wxPyBeginAllowThreads();
5652 {
5653 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5654 result = (wxRect *) &_result_ref;
5655 }
5656
5657 wxPyEndAllowThreads(__tstate);
5658 if (PyErr_Occurred()) SWIG_fail;
5659 }
5660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5661 return resultobj;
5662 fail:
5663 return NULL;
5664 }
5665
5666
5667 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5668 PyObject *resultobj;
5669 wxRect *arg1 = (wxRect *) 0 ;
5670 int arg2 ;
5671 int arg3 ;
5672 wxRect *result;
5673 PyObject * obj0 = 0 ;
5674 PyObject * obj1 = 0 ;
5675 PyObject * obj2 = 0 ;
5676 char *kwnames[] = {
5677 (char *) "self",(char *) "dx",(char *) "dy", NULL
5678 };
5679
5680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5682 if (SWIG_arg_fail(1)) SWIG_fail;
5683 {
5684 arg2 = (int)(SWIG_As_int(obj1));
5685 if (SWIG_arg_fail(2)) SWIG_fail;
5686 }
5687 {
5688 arg3 = (int)(SWIG_As_int(obj2));
5689 if (SWIG_arg_fail(3)) SWIG_fail;
5690 }
5691 {
5692 PyThreadState* __tstate = wxPyBeginAllowThreads();
5693 {
5694 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5695 result = (wxRect *) &_result_ref;
5696 }
5697
5698 wxPyEndAllowThreads(__tstate);
5699 if (PyErr_Occurred()) SWIG_fail;
5700 }
5701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5702 return resultobj;
5703 fail:
5704 return NULL;
5705 }
5706
5707
5708 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5709 PyObject *resultobj;
5710 wxRect *arg1 = (wxRect *) 0 ;
5711 int arg2 ;
5712 int arg3 ;
5713 PyObject * obj0 = 0 ;
5714 PyObject * obj1 = 0 ;
5715 PyObject * obj2 = 0 ;
5716 char *kwnames[] = {
5717 (char *) "self",(char *) "dx",(char *) "dy", NULL
5718 };
5719
5720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5722 if (SWIG_arg_fail(1)) SWIG_fail;
5723 {
5724 arg2 = (int)(SWIG_As_int(obj1));
5725 if (SWIG_arg_fail(2)) SWIG_fail;
5726 }
5727 {
5728 arg3 = (int)(SWIG_As_int(obj2));
5729 if (SWIG_arg_fail(3)) SWIG_fail;
5730 }
5731 {
5732 PyThreadState* __tstate = wxPyBeginAllowThreads();
5733 (arg1)->Offset(arg2,arg3);
5734
5735 wxPyEndAllowThreads(__tstate);
5736 if (PyErr_Occurred()) SWIG_fail;
5737 }
5738 Py_INCREF(Py_None); resultobj = Py_None;
5739 return resultobj;
5740 fail:
5741 return NULL;
5742 }
5743
5744
5745 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5746 PyObject *resultobj;
5747 wxRect *arg1 = (wxRect *) 0 ;
5748 wxPoint *arg2 = 0 ;
5749 wxPoint temp2 ;
5750 PyObject * obj0 = 0 ;
5751 PyObject * obj1 = 0 ;
5752 char *kwnames[] = {
5753 (char *) "self",(char *) "pt", NULL
5754 };
5755
5756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5758 if (SWIG_arg_fail(1)) SWIG_fail;
5759 {
5760 arg2 = &temp2;
5761 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5762 }
5763 {
5764 PyThreadState* __tstate = wxPyBeginAllowThreads();
5765 (arg1)->Offset((wxPoint const &)*arg2);
5766
5767 wxPyEndAllowThreads(__tstate);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 Py_INCREF(Py_None); resultobj = Py_None;
5771 return resultobj;
5772 fail:
5773 return NULL;
5774 }
5775
5776
5777 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5778 PyObject *resultobj;
5779 wxRect *arg1 = (wxRect *) 0 ;
5780 wxRect *arg2 = 0 ;
5781 wxRect result;
5782 wxRect temp2 ;
5783 PyObject * obj0 = 0 ;
5784 PyObject * obj1 = 0 ;
5785 char *kwnames[] = {
5786 (char *) "self",(char *) "rect", NULL
5787 };
5788
5789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5791 if (SWIG_arg_fail(1)) SWIG_fail;
5792 {
5793 arg2 = &temp2;
5794 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5795 }
5796 {
5797 PyThreadState* __tstate = wxPyBeginAllowThreads();
5798 result = (arg1)->Intersect((wxRect const &)*arg2);
5799
5800 wxPyEndAllowThreads(__tstate);
5801 if (PyErr_Occurred()) SWIG_fail;
5802 }
5803 {
5804 wxRect * resultptr;
5805 resultptr = new wxRect((wxRect &)(result));
5806 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5807 }
5808 return resultobj;
5809 fail:
5810 return NULL;
5811 }
5812
5813
5814 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5815 PyObject *resultobj;
5816 wxRect *arg1 = (wxRect *) 0 ;
5817 wxRect *arg2 = 0 ;
5818 wxRect result;
5819 wxRect temp2 ;
5820 PyObject * obj0 = 0 ;
5821 PyObject * obj1 = 0 ;
5822 char *kwnames[] = {
5823 (char *) "self",(char *) "rect", NULL
5824 };
5825
5826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5828 if (SWIG_arg_fail(1)) SWIG_fail;
5829 {
5830 arg2 = &temp2;
5831 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5832 }
5833 {
5834 PyThreadState* __tstate = wxPyBeginAllowThreads();
5835 result = (arg1)->Union((wxRect const &)*arg2);
5836
5837 wxPyEndAllowThreads(__tstate);
5838 if (PyErr_Occurred()) SWIG_fail;
5839 }
5840 {
5841 wxRect * resultptr;
5842 resultptr = new wxRect((wxRect &)(result));
5843 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5844 }
5845 return resultobj;
5846 fail:
5847 return NULL;
5848 }
5849
5850
5851 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5852 PyObject *resultobj;
5853 wxRect *arg1 = (wxRect *) 0 ;
5854 wxRect *arg2 = 0 ;
5855 wxRect result;
5856 wxRect temp2 ;
5857 PyObject * obj0 = 0 ;
5858 PyObject * obj1 = 0 ;
5859 char *kwnames[] = {
5860 (char *) "self",(char *) "rect", NULL
5861 };
5862
5863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5865 if (SWIG_arg_fail(1)) SWIG_fail;
5866 {
5867 arg2 = &temp2;
5868 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5869 }
5870 {
5871 PyThreadState* __tstate = wxPyBeginAllowThreads();
5872 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5873
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 {
5878 wxRect * resultptr;
5879 resultptr = new wxRect((wxRect &)(result));
5880 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5881 }
5882 return resultobj;
5883 fail:
5884 return NULL;
5885 }
5886
5887
5888 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5889 PyObject *resultobj;
5890 wxRect *arg1 = (wxRect *) 0 ;
5891 wxRect *arg2 = 0 ;
5892 wxRect *result;
5893 wxRect temp2 ;
5894 PyObject * obj0 = 0 ;
5895 PyObject * obj1 = 0 ;
5896 char *kwnames[] = {
5897 (char *) "self",(char *) "rect", NULL
5898 };
5899
5900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5902 if (SWIG_arg_fail(1)) SWIG_fail;
5903 {
5904 arg2 = &temp2;
5905 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5906 }
5907 {
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 {
5910 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5911 result = (wxRect *) &_result_ref;
5912 }
5913
5914 wxPyEndAllowThreads(__tstate);
5915 if (PyErr_Occurred()) SWIG_fail;
5916 }
5917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5918 return resultobj;
5919 fail:
5920 return NULL;
5921 }
5922
5923
5924 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5925 PyObject *resultobj;
5926 wxRect *arg1 = (wxRect *) 0 ;
5927 wxRect *arg2 = 0 ;
5928 bool result;
5929 wxRect temp2 ;
5930 PyObject * obj0 = 0 ;
5931 PyObject * obj1 = 0 ;
5932 char *kwnames[] = {
5933 (char *) "self",(char *) "rect", NULL
5934 };
5935
5936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5938 if (SWIG_arg_fail(1)) SWIG_fail;
5939 {
5940 arg2 = &temp2;
5941 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5942 }
5943 {
5944 PyThreadState* __tstate = wxPyBeginAllowThreads();
5945 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5946
5947 wxPyEndAllowThreads(__tstate);
5948 if (PyErr_Occurred()) SWIG_fail;
5949 }
5950 {
5951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5952 }
5953 return resultobj;
5954 fail:
5955 return NULL;
5956 }
5957
5958
5959 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5960 PyObject *resultobj;
5961 wxRect *arg1 = (wxRect *) 0 ;
5962 wxRect *arg2 = 0 ;
5963 bool result;
5964 wxRect temp2 ;
5965 PyObject * obj0 = 0 ;
5966 PyObject * obj1 = 0 ;
5967 char *kwnames[] = {
5968 (char *) "self",(char *) "rect", NULL
5969 };
5970
5971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5973 if (SWIG_arg_fail(1)) SWIG_fail;
5974 {
5975 arg2 = &temp2;
5976 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5977 }
5978 {
5979 PyThreadState* __tstate = wxPyBeginAllowThreads();
5980 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5981
5982 wxPyEndAllowThreads(__tstate);
5983 if (PyErr_Occurred()) SWIG_fail;
5984 }
5985 {
5986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5987 }
5988 return resultobj;
5989 fail:
5990 return NULL;
5991 }
5992
5993
5994 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj;
5996 wxRect *arg1 = (wxRect *) 0 ;
5997 int arg2 ;
5998 int arg3 ;
5999 bool result;
6000 PyObject * obj0 = 0 ;
6001 PyObject * obj1 = 0 ;
6002 PyObject * obj2 = 0 ;
6003 char *kwnames[] = {
6004 (char *) "self",(char *) "x",(char *) "y", NULL
6005 };
6006
6007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6009 if (SWIG_arg_fail(1)) SWIG_fail;
6010 {
6011 arg2 = (int)(SWIG_As_int(obj1));
6012 if (SWIG_arg_fail(2)) SWIG_fail;
6013 }
6014 {
6015 arg3 = (int)(SWIG_As_int(obj2));
6016 if (SWIG_arg_fail(3)) SWIG_fail;
6017 }
6018 {
6019 PyThreadState* __tstate = wxPyBeginAllowThreads();
6020 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6021
6022 wxPyEndAllowThreads(__tstate);
6023 if (PyErr_Occurred()) SWIG_fail;
6024 }
6025 {
6026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6027 }
6028 return resultobj;
6029 fail:
6030 return NULL;
6031 }
6032
6033
6034 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6035 PyObject *resultobj;
6036 wxRect *arg1 = (wxRect *) 0 ;
6037 wxPoint *arg2 = 0 ;
6038 bool result;
6039 wxPoint temp2 ;
6040 PyObject * obj0 = 0 ;
6041 PyObject * obj1 = 0 ;
6042 char *kwnames[] = {
6043 (char *) "self",(char *) "pt", NULL
6044 };
6045
6046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6048 if (SWIG_arg_fail(1)) SWIG_fail;
6049 {
6050 arg2 = &temp2;
6051 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6052 }
6053 {
6054 PyThreadState* __tstate = wxPyBeginAllowThreads();
6055 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6056
6057 wxPyEndAllowThreads(__tstate);
6058 if (PyErr_Occurred()) SWIG_fail;
6059 }
6060 {
6061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6062 }
6063 return resultobj;
6064 fail:
6065 return NULL;
6066 }
6067
6068
6069 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6070 PyObject *resultobj;
6071 wxRect *arg1 = (wxRect *) 0 ;
6072 wxRect *arg2 = 0 ;
6073 bool result;
6074 wxRect temp2 ;
6075 PyObject * obj0 = 0 ;
6076 PyObject * obj1 = 0 ;
6077 char *kwnames[] = {
6078 (char *) "self",(char *) "rect", NULL
6079 };
6080
6081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6083 if (SWIG_arg_fail(1)) SWIG_fail;
6084 {
6085 arg2 = &temp2;
6086 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6087 }
6088 {
6089 PyThreadState* __tstate = wxPyBeginAllowThreads();
6090 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6091
6092 wxPyEndAllowThreads(__tstate);
6093 if (PyErr_Occurred()) SWIG_fail;
6094 }
6095 {
6096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6097 }
6098 return resultobj;
6099 fail:
6100 return NULL;
6101 }
6102
6103
6104 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6105 PyObject *resultobj;
6106 wxRect *arg1 = (wxRect *) 0 ;
6107 int arg2 ;
6108 PyObject * obj0 = 0 ;
6109 PyObject * obj1 = 0 ;
6110 char *kwnames[] = {
6111 (char *) "self",(char *) "x", NULL
6112 };
6113
6114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6116 if (SWIG_arg_fail(1)) SWIG_fail;
6117 {
6118 arg2 = (int)(SWIG_As_int(obj1));
6119 if (SWIG_arg_fail(2)) SWIG_fail;
6120 }
6121 if (arg1) (arg1)->x = arg2;
6122
6123 Py_INCREF(Py_None); resultobj = Py_None;
6124 return resultobj;
6125 fail:
6126 return NULL;
6127 }
6128
6129
6130 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6131 PyObject *resultobj;
6132 wxRect *arg1 = (wxRect *) 0 ;
6133 int result;
6134 PyObject * obj0 = 0 ;
6135 char *kwnames[] = {
6136 (char *) "self", NULL
6137 };
6138
6139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6141 if (SWIG_arg_fail(1)) SWIG_fail;
6142 result = (int) ((arg1)->x);
6143
6144 {
6145 resultobj = SWIG_From_int((int)(result));
6146 }
6147 return resultobj;
6148 fail:
6149 return NULL;
6150 }
6151
6152
6153 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6154 PyObject *resultobj;
6155 wxRect *arg1 = (wxRect *) 0 ;
6156 int arg2 ;
6157 PyObject * obj0 = 0 ;
6158 PyObject * obj1 = 0 ;
6159 char *kwnames[] = {
6160 (char *) "self",(char *) "y", NULL
6161 };
6162
6163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6165 if (SWIG_arg_fail(1)) SWIG_fail;
6166 {
6167 arg2 = (int)(SWIG_As_int(obj1));
6168 if (SWIG_arg_fail(2)) SWIG_fail;
6169 }
6170 if (arg1) (arg1)->y = arg2;
6171
6172 Py_INCREF(Py_None); resultobj = Py_None;
6173 return resultobj;
6174 fail:
6175 return NULL;
6176 }
6177
6178
6179 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6180 PyObject *resultobj;
6181 wxRect *arg1 = (wxRect *) 0 ;
6182 int result;
6183 PyObject * obj0 = 0 ;
6184 char *kwnames[] = {
6185 (char *) "self", NULL
6186 };
6187
6188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6190 if (SWIG_arg_fail(1)) SWIG_fail;
6191 result = (int) ((arg1)->y);
6192
6193 {
6194 resultobj = SWIG_From_int((int)(result));
6195 }
6196 return resultobj;
6197 fail:
6198 return NULL;
6199 }
6200
6201
6202 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6203 PyObject *resultobj;
6204 wxRect *arg1 = (wxRect *) 0 ;
6205 int arg2 ;
6206 PyObject * obj0 = 0 ;
6207 PyObject * obj1 = 0 ;
6208 char *kwnames[] = {
6209 (char *) "self",(char *) "width", NULL
6210 };
6211
6212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6214 if (SWIG_arg_fail(1)) SWIG_fail;
6215 {
6216 arg2 = (int)(SWIG_As_int(obj1));
6217 if (SWIG_arg_fail(2)) SWIG_fail;
6218 }
6219 if (arg1) (arg1)->width = arg2;
6220
6221 Py_INCREF(Py_None); resultobj = Py_None;
6222 return resultobj;
6223 fail:
6224 return NULL;
6225 }
6226
6227
6228 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6229 PyObject *resultobj;
6230 wxRect *arg1 = (wxRect *) 0 ;
6231 int result;
6232 PyObject * obj0 = 0 ;
6233 char *kwnames[] = {
6234 (char *) "self", NULL
6235 };
6236
6237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6239 if (SWIG_arg_fail(1)) SWIG_fail;
6240 result = (int) ((arg1)->width);
6241
6242 {
6243 resultobj = SWIG_From_int((int)(result));
6244 }
6245 return resultobj;
6246 fail:
6247 return NULL;
6248 }
6249
6250
6251 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6252 PyObject *resultobj;
6253 wxRect *arg1 = (wxRect *) 0 ;
6254 int arg2 ;
6255 PyObject * obj0 = 0 ;
6256 PyObject * obj1 = 0 ;
6257 char *kwnames[] = {
6258 (char *) "self",(char *) "height", NULL
6259 };
6260
6261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6263 if (SWIG_arg_fail(1)) SWIG_fail;
6264 {
6265 arg2 = (int)(SWIG_As_int(obj1));
6266 if (SWIG_arg_fail(2)) SWIG_fail;
6267 }
6268 if (arg1) (arg1)->height = arg2;
6269
6270 Py_INCREF(Py_None); resultobj = Py_None;
6271 return resultobj;
6272 fail:
6273 return NULL;
6274 }
6275
6276
6277 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6278 PyObject *resultobj;
6279 wxRect *arg1 = (wxRect *) 0 ;
6280 int result;
6281 PyObject * obj0 = 0 ;
6282 char *kwnames[] = {
6283 (char *) "self", NULL
6284 };
6285
6286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6288 if (SWIG_arg_fail(1)) SWIG_fail;
6289 result = (int) ((arg1)->height);
6290
6291 {
6292 resultobj = SWIG_From_int((int)(result));
6293 }
6294 return resultobj;
6295 fail:
6296 return NULL;
6297 }
6298
6299
6300 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6301 PyObject *resultobj;
6302 wxRect *arg1 = (wxRect *) 0 ;
6303 int arg2 = (int) 0 ;
6304 int arg3 = (int) 0 ;
6305 int arg4 = (int) 0 ;
6306 int arg5 = (int) 0 ;
6307 PyObject * obj0 = 0 ;
6308 PyObject * obj1 = 0 ;
6309 PyObject * obj2 = 0 ;
6310 PyObject * obj3 = 0 ;
6311 PyObject * obj4 = 0 ;
6312 char *kwnames[] = {
6313 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6314 };
6315
6316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6318 if (SWIG_arg_fail(1)) SWIG_fail;
6319 if (obj1) {
6320 {
6321 arg2 = (int)(SWIG_As_int(obj1));
6322 if (SWIG_arg_fail(2)) SWIG_fail;
6323 }
6324 }
6325 if (obj2) {
6326 {
6327 arg3 = (int)(SWIG_As_int(obj2));
6328 if (SWIG_arg_fail(3)) SWIG_fail;
6329 }
6330 }
6331 if (obj3) {
6332 {
6333 arg4 = (int)(SWIG_As_int(obj3));
6334 if (SWIG_arg_fail(4)) SWIG_fail;
6335 }
6336 }
6337 if (obj4) {
6338 {
6339 arg5 = (int)(SWIG_As_int(obj4));
6340 if (SWIG_arg_fail(5)) SWIG_fail;
6341 }
6342 }
6343 {
6344 PyThreadState* __tstate = wxPyBeginAllowThreads();
6345 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6346
6347 wxPyEndAllowThreads(__tstate);
6348 if (PyErr_Occurred()) SWIG_fail;
6349 }
6350 Py_INCREF(Py_None); resultobj = Py_None;
6351 return resultobj;
6352 fail:
6353 return NULL;
6354 }
6355
6356
6357 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6358 PyObject *resultobj;
6359 wxRect *arg1 = (wxRect *) 0 ;
6360 PyObject *result;
6361 PyObject * obj0 = 0 ;
6362 char *kwnames[] = {
6363 (char *) "self", NULL
6364 };
6365
6366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6368 if (SWIG_arg_fail(1)) SWIG_fail;
6369 {
6370 PyThreadState* __tstate = wxPyBeginAllowThreads();
6371 result = (PyObject *)wxRect_Get(arg1);
6372
6373 wxPyEndAllowThreads(__tstate);
6374 if (PyErr_Occurred()) SWIG_fail;
6375 }
6376 resultobj = result;
6377 return resultobj;
6378 fail:
6379 return NULL;
6380 }
6381
6382
6383 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6384 PyObject *obj;
6385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6386 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6387 Py_INCREF(obj);
6388 return Py_BuildValue((char *)"");
6389 }
6390 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6391 PyObject *resultobj;
6392 wxRect *arg1 = (wxRect *) 0 ;
6393 wxRect *arg2 = (wxRect *) 0 ;
6394 PyObject *result;
6395 PyObject * obj0 = 0 ;
6396 PyObject * obj1 = 0 ;
6397 char *kwnames[] = {
6398 (char *) "r1",(char *) "r2", NULL
6399 };
6400
6401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6403 if (SWIG_arg_fail(1)) SWIG_fail;
6404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6405 if (SWIG_arg_fail(2)) SWIG_fail;
6406 {
6407 if (!wxPyCheckForApp()) SWIG_fail;
6408 PyThreadState* __tstate = wxPyBeginAllowThreads();
6409 result = (PyObject *)wxIntersectRect(arg1,arg2);
6410
6411 wxPyEndAllowThreads(__tstate);
6412 if (PyErr_Occurred()) SWIG_fail;
6413 }
6414 resultobj = result;
6415 return resultobj;
6416 fail:
6417 return NULL;
6418 }
6419
6420
6421 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6422 PyObject *resultobj;
6423 double arg1 = (double) 0.0 ;
6424 double arg2 = (double) 0.0 ;
6425 wxPoint2D *result;
6426 PyObject * obj0 = 0 ;
6427 PyObject * obj1 = 0 ;
6428 char *kwnames[] = {
6429 (char *) "x",(char *) "y", NULL
6430 };
6431
6432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6433 if (obj0) {
6434 {
6435 arg1 = (double)(SWIG_As_double(obj0));
6436 if (SWIG_arg_fail(1)) SWIG_fail;
6437 }
6438 }
6439 if (obj1) {
6440 {
6441 arg2 = (double)(SWIG_As_double(obj1));
6442 if (SWIG_arg_fail(2)) SWIG_fail;
6443 }
6444 }
6445 {
6446 PyThreadState* __tstate = wxPyBeginAllowThreads();
6447 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6448
6449 wxPyEndAllowThreads(__tstate);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6460 PyObject *resultobj;
6461 wxPoint2D *arg1 = 0 ;
6462 wxPoint2D *result;
6463 wxPoint2D temp1 ;
6464 PyObject * obj0 = 0 ;
6465 char *kwnames[] = {
6466 (char *) "pt", NULL
6467 };
6468
6469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6470 {
6471 arg1 = &temp1;
6472 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6473 }
6474 {
6475 PyThreadState* __tstate = wxPyBeginAllowThreads();
6476 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6477
6478 wxPyEndAllowThreads(__tstate);
6479 if (PyErr_Occurred()) SWIG_fail;
6480 }
6481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj;
6490 wxPoint *arg1 = 0 ;
6491 wxPoint2D *result;
6492 wxPoint temp1 ;
6493 PyObject * obj0 = 0 ;
6494 char *kwnames[] = {
6495 (char *) "pt", NULL
6496 };
6497
6498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6499 {
6500 arg1 = &temp1;
6501 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6502 }
6503 {
6504 PyThreadState* __tstate = wxPyBeginAllowThreads();
6505 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6506
6507 wxPyEndAllowThreads(__tstate);
6508 if (PyErr_Occurred()) SWIG_fail;
6509 }
6510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6511 return resultobj;
6512 fail:
6513 return NULL;
6514 }
6515
6516
6517 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6518 PyObject *resultobj;
6519 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6520 int *arg2 = (int *) 0 ;
6521 int *arg3 = (int *) 0 ;
6522 int temp2 ;
6523 int res2 = 0 ;
6524 int temp3 ;
6525 int res3 = 0 ;
6526 PyObject * obj0 = 0 ;
6527 char *kwnames[] = {
6528 (char *) "self", NULL
6529 };
6530
6531 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6532 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6535 if (SWIG_arg_fail(1)) SWIG_fail;
6536 {
6537 PyThreadState* __tstate = wxPyBeginAllowThreads();
6538 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6539
6540 wxPyEndAllowThreads(__tstate);
6541 if (PyErr_Occurred()) SWIG_fail;
6542 }
6543 Py_INCREF(Py_None); resultobj = Py_None;
6544 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6545 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6546 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6547 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6548 return resultobj;
6549 fail:
6550 return NULL;
6551 }
6552
6553
6554 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6555 PyObject *resultobj;
6556 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6557 int *arg2 = (int *) 0 ;
6558 int *arg3 = (int *) 0 ;
6559 int temp2 ;
6560 int res2 = 0 ;
6561 int temp3 ;
6562 int res3 = 0 ;
6563 PyObject * obj0 = 0 ;
6564 char *kwnames[] = {
6565 (char *) "self", NULL
6566 };
6567
6568 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6569 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6572 if (SWIG_arg_fail(1)) SWIG_fail;
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6576
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 Py_INCREF(Py_None); resultobj = Py_None;
6581 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6582 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6583 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6584 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6585 return resultobj;
6586 fail:
6587 return NULL;
6588 }
6589
6590
6591 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6592 PyObject *resultobj;
6593 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6594 double result;
6595 PyObject * obj0 = 0 ;
6596 char *kwnames[] = {
6597 (char *) "self", NULL
6598 };
6599
6600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6602 if (SWIG_arg_fail(1)) SWIG_fail;
6603 {
6604 PyThreadState* __tstate = wxPyBeginAllowThreads();
6605 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6606
6607 wxPyEndAllowThreads(__tstate);
6608 if (PyErr_Occurred()) SWIG_fail;
6609 }
6610 {
6611 resultobj = SWIG_From_double((double)(result));
6612 }
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6620 PyObject *resultobj;
6621 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6622 double result;
6623 PyObject * obj0 = 0 ;
6624 char *kwnames[] = {
6625 (char *) "self", NULL
6626 };
6627
6628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6630 if (SWIG_arg_fail(1)) SWIG_fail;
6631 {
6632 PyThreadState* __tstate = wxPyBeginAllowThreads();
6633 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6634
6635 wxPyEndAllowThreads(__tstate);
6636 if (PyErr_Occurred()) SWIG_fail;
6637 }
6638 {
6639 resultobj = SWIG_From_double((double)(result));
6640 }
6641 return resultobj;
6642 fail:
6643 return NULL;
6644 }
6645
6646
6647 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6648 PyObject *resultobj;
6649 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6650 double arg2 ;
6651 PyObject * obj0 = 0 ;
6652 PyObject * obj1 = 0 ;
6653 char *kwnames[] = {
6654 (char *) "self",(char *) "length", NULL
6655 };
6656
6657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6659 if (SWIG_arg_fail(1)) SWIG_fail;
6660 {
6661 arg2 = (double)(SWIG_As_double(obj1));
6662 if (SWIG_arg_fail(2)) SWIG_fail;
6663 }
6664 {
6665 PyThreadState* __tstate = wxPyBeginAllowThreads();
6666 (arg1)->SetVectorLength(arg2);
6667
6668 wxPyEndAllowThreads(__tstate);
6669 if (PyErr_Occurred()) SWIG_fail;
6670 }
6671 Py_INCREF(Py_None); resultobj = Py_None;
6672 return resultobj;
6673 fail:
6674 return NULL;
6675 }
6676
6677
6678 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6679 PyObject *resultobj;
6680 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6681 double arg2 ;
6682 PyObject * obj0 = 0 ;
6683 PyObject * obj1 = 0 ;
6684 char *kwnames[] = {
6685 (char *) "self",(char *) "degrees", NULL
6686 };
6687
6688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6690 if (SWIG_arg_fail(1)) SWIG_fail;
6691 {
6692 arg2 = (double)(SWIG_As_double(obj1));
6693 if (SWIG_arg_fail(2)) SWIG_fail;
6694 }
6695 {
6696 PyThreadState* __tstate = wxPyBeginAllowThreads();
6697 (arg1)->SetVectorAngle(arg2);
6698
6699 wxPyEndAllowThreads(__tstate);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 Py_INCREF(Py_None); resultobj = Py_None;
6703 return resultobj;
6704 fail:
6705 return NULL;
6706 }
6707
6708
6709 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6710 PyObject *resultobj;
6711 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6712 wxPoint2D *arg2 = 0 ;
6713 double result;
6714 wxPoint2D temp2 ;
6715 PyObject * obj0 = 0 ;
6716 PyObject * obj1 = 0 ;
6717 char *kwnames[] = {
6718 (char *) "self",(char *) "pt", NULL
6719 };
6720
6721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6723 if (SWIG_arg_fail(1)) SWIG_fail;
6724 {
6725 arg2 = &temp2;
6726 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6727 }
6728 {
6729 PyThreadState* __tstate = wxPyBeginAllowThreads();
6730 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6731
6732 wxPyEndAllowThreads(__tstate);
6733 if (PyErr_Occurred()) SWIG_fail;
6734 }
6735 {
6736 resultobj = SWIG_From_double((double)(result));
6737 }
6738 return resultobj;
6739 fail:
6740 return NULL;
6741 }
6742
6743
6744 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6745 PyObject *resultobj;
6746 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6747 wxPoint2D *arg2 = 0 ;
6748 double result;
6749 wxPoint2D temp2 ;
6750 PyObject * obj0 = 0 ;
6751 PyObject * obj1 = 0 ;
6752 char *kwnames[] = {
6753 (char *) "self",(char *) "pt", NULL
6754 };
6755
6756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6758 if (SWIG_arg_fail(1)) SWIG_fail;
6759 {
6760 arg2 = &temp2;
6761 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6762 }
6763 {
6764 PyThreadState* __tstate = wxPyBeginAllowThreads();
6765 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6766
6767 wxPyEndAllowThreads(__tstate);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 {
6771 resultobj = SWIG_From_double((double)(result));
6772 }
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6780 PyObject *resultobj;
6781 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6782 wxPoint2D *arg2 = 0 ;
6783 double result;
6784 wxPoint2D temp2 ;
6785 PyObject * obj0 = 0 ;
6786 PyObject * obj1 = 0 ;
6787 char *kwnames[] = {
6788 (char *) "self",(char *) "vec", NULL
6789 };
6790
6791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6793 if (SWIG_arg_fail(1)) SWIG_fail;
6794 {
6795 arg2 = &temp2;
6796 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6797 }
6798 {
6799 PyThreadState* __tstate = wxPyBeginAllowThreads();
6800 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6801
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 {
6806 resultobj = SWIG_From_double((double)(result));
6807 }
6808 return resultobj;
6809 fail:
6810 return NULL;
6811 }
6812
6813
6814 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6815 PyObject *resultobj;
6816 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6817 wxPoint2D *arg2 = 0 ;
6818 double result;
6819 wxPoint2D temp2 ;
6820 PyObject * obj0 = 0 ;
6821 PyObject * obj1 = 0 ;
6822 char *kwnames[] = {
6823 (char *) "self",(char *) "vec", NULL
6824 };
6825
6826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6828 if (SWIG_arg_fail(1)) SWIG_fail;
6829 {
6830 arg2 = &temp2;
6831 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6832 }
6833 {
6834 PyThreadState* __tstate = wxPyBeginAllowThreads();
6835 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6836
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 {
6841 resultobj = SWIG_From_double((double)(result));
6842 }
6843 return resultobj;
6844 fail:
6845 return NULL;
6846 }
6847
6848
6849 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6850 PyObject *resultobj;
6851 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6852 wxPoint2D result;
6853 PyObject * obj0 = 0 ;
6854 char *kwnames[] = {
6855 (char *) "self", NULL
6856 };
6857
6858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6860 if (SWIG_arg_fail(1)) SWIG_fail;
6861 {
6862 PyThreadState* __tstate = wxPyBeginAllowThreads();
6863 result = (arg1)->operator -();
6864
6865 wxPyEndAllowThreads(__tstate);
6866 if (PyErr_Occurred()) SWIG_fail;
6867 }
6868 {
6869 wxPoint2D * resultptr;
6870 resultptr = new wxPoint2D((wxPoint2D &)(result));
6871 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6872 }
6873 return resultobj;
6874 fail:
6875 return NULL;
6876 }
6877
6878
6879 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6880 PyObject *resultobj;
6881 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6882 wxPoint2D *arg2 = 0 ;
6883 wxPoint2D *result;
6884 wxPoint2D temp2 ;
6885 PyObject * obj0 = 0 ;
6886 PyObject * obj1 = 0 ;
6887 char *kwnames[] = {
6888 (char *) "self",(char *) "pt", NULL
6889 };
6890
6891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6893 if (SWIG_arg_fail(1)) SWIG_fail;
6894 {
6895 arg2 = &temp2;
6896 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6897 }
6898 {
6899 PyThreadState* __tstate = wxPyBeginAllowThreads();
6900 {
6901 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6902 result = (wxPoint2D *) &_result_ref;
6903 }
6904
6905 wxPyEndAllowThreads(__tstate);
6906 if (PyErr_Occurred()) SWIG_fail;
6907 }
6908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6909 return resultobj;
6910 fail:
6911 return NULL;
6912 }
6913
6914
6915 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6916 PyObject *resultobj;
6917 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6918 wxPoint2D *arg2 = 0 ;
6919 wxPoint2D *result;
6920 wxPoint2D temp2 ;
6921 PyObject * obj0 = 0 ;
6922 PyObject * obj1 = 0 ;
6923 char *kwnames[] = {
6924 (char *) "self",(char *) "pt", NULL
6925 };
6926
6927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6929 if (SWIG_arg_fail(1)) SWIG_fail;
6930 {
6931 arg2 = &temp2;
6932 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6933 }
6934 {
6935 PyThreadState* __tstate = wxPyBeginAllowThreads();
6936 {
6937 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6938 result = (wxPoint2D *) &_result_ref;
6939 }
6940
6941 wxPyEndAllowThreads(__tstate);
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6945 return resultobj;
6946 fail:
6947 return NULL;
6948 }
6949
6950
6951 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6952 PyObject *resultobj;
6953 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6954 wxPoint2D *arg2 = 0 ;
6955 wxPoint2D *result;
6956 wxPoint2D temp2 ;
6957 PyObject * obj0 = 0 ;
6958 PyObject * obj1 = 0 ;
6959 char *kwnames[] = {
6960 (char *) "self",(char *) "pt", NULL
6961 };
6962
6963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6965 if (SWIG_arg_fail(1)) SWIG_fail;
6966 {
6967 arg2 = &temp2;
6968 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6969 }
6970 {
6971 PyThreadState* __tstate = wxPyBeginAllowThreads();
6972 {
6973 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6974 result = (wxPoint2D *) &_result_ref;
6975 }
6976
6977 wxPyEndAllowThreads(__tstate);
6978 if (PyErr_Occurred()) SWIG_fail;
6979 }
6980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6981 return resultobj;
6982 fail:
6983 return NULL;
6984 }
6985
6986
6987 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
6988 PyObject *resultobj;
6989 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6990 wxPoint2D *arg2 = 0 ;
6991 wxPoint2D *result;
6992 wxPoint2D temp2 ;
6993 PyObject * obj0 = 0 ;
6994 PyObject * obj1 = 0 ;
6995 char *kwnames[] = {
6996 (char *) "self",(char *) "pt", NULL
6997 };
6998
6999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7001 if (SWIG_arg_fail(1)) SWIG_fail;
7002 {
7003 arg2 = &temp2;
7004 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7005 }
7006 {
7007 PyThreadState* __tstate = wxPyBeginAllowThreads();
7008 {
7009 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7010 result = (wxPoint2D *) &_result_ref;
7011 }
7012
7013 wxPyEndAllowThreads(__tstate);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7017 return resultobj;
7018 fail:
7019 return NULL;
7020 }
7021
7022
7023 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7024 PyObject *resultobj;
7025 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7026 wxPoint2D *arg2 = 0 ;
7027 bool result;
7028 wxPoint2D temp2 ;
7029 PyObject * obj0 = 0 ;
7030 PyObject * obj1 = 0 ;
7031 char *kwnames[] = {
7032 (char *) "self",(char *) "pt", NULL
7033 };
7034
7035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7037 if (SWIG_arg_fail(1)) SWIG_fail;
7038 {
7039 arg2 = &temp2;
7040 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7041 }
7042 {
7043 PyThreadState* __tstate = wxPyBeginAllowThreads();
7044 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7045
7046 wxPyEndAllowThreads(__tstate);
7047 if (PyErr_Occurred()) SWIG_fail;
7048 }
7049 {
7050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7051 }
7052 return resultobj;
7053 fail:
7054 return NULL;
7055 }
7056
7057
7058 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7059 PyObject *resultobj;
7060 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7061 wxPoint2D *arg2 = 0 ;
7062 bool result;
7063 wxPoint2D temp2 ;
7064 PyObject * obj0 = 0 ;
7065 PyObject * obj1 = 0 ;
7066 char *kwnames[] = {
7067 (char *) "self",(char *) "pt", NULL
7068 };
7069
7070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7072 if (SWIG_arg_fail(1)) SWIG_fail;
7073 {
7074 arg2 = &temp2;
7075 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7076 }
7077 {
7078 PyThreadState* __tstate = wxPyBeginAllowThreads();
7079 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7080
7081 wxPyEndAllowThreads(__tstate);
7082 if (PyErr_Occurred()) SWIG_fail;
7083 }
7084 {
7085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7086 }
7087 return resultobj;
7088 fail:
7089 return NULL;
7090 }
7091
7092
7093 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7094 PyObject *resultobj;
7095 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7096 double arg2 ;
7097 PyObject * obj0 = 0 ;
7098 PyObject * obj1 = 0 ;
7099 char *kwnames[] = {
7100 (char *) "self",(char *) "m_x", NULL
7101 };
7102
7103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7105 if (SWIG_arg_fail(1)) SWIG_fail;
7106 {
7107 arg2 = (double)(SWIG_As_double(obj1));
7108 if (SWIG_arg_fail(2)) SWIG_fail;
7109 }
7110 if (arg1) (arg1)->m_x = arg2;
7111
7112 Py_INCREF(Py_None); resultobj = Py_None;
7113 return resultobj;
7114 fail:
7115 return NULL;
7116 }
7117
7118
7119 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7120 PyObject *resultobj;
7121 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7122 double result;
7123 PyObject * obj0 = 0 ;
7124 char *kwnames[] = {
7125 (char *) "self", NULL
7126 };
7127
7128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7130 if (SWIG_arg_fail(1)) SWIG_fail;
7131 result = (double) ((arg1)->m_x);
7132
7133 {
7134 resultobj = SWIG_From_double((double)(result));
7135 }
7136 return resultobj;
7137 fail:
7138 return NULL;
7139 }
7140
7141
7142 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7143 PyObject *resultobj;
7144 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7145 double arg2 ;
7146 PyObject * obj0 = 0 ;
7147 PyObject * obj1 = 0 ;
7148 char *kwnames[] = {
7149 (char *) "self",(char *) "m_y", NULL
7150 };
7151
7152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7154 if (SWIG_arg_fail(1)) SWIG_fail;
7155 {
7156 arg2 = (double)(SWIG_As_double(obj1));
7157 if (SWIG_arg_fail(2)) SWIG_fail;
7158 }
7159 if (arg1) (arg1)->m_y = arg2;
7160
7161 Py_INCREF(Py_None); resultobj = Py_None;
7162 return resultobj;
7163 fail:
7164 return NULL;
7165 }
7166
7167
7168 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7169 PyObject *resultobj;
7170 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7171 double result;
7172 PyObject * obj0 = 0 ;
7173 char *kwnames[] = {
7174 (char *) "self", NULL
7175 };
7176
7177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7179 if (SWIG_arg_fail(1)) SWIG_fail;
7180 result = (double) ((arg1)->m_y);
7181
7182 {
7183 resultobj = SWIG_From_double((double)(result));
7184 }
7185 return resultobj;
7186 fail:
7187 return NULL;
7188 }
7189
7190
7191 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7192 PyObject *resultobj;
7193 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7194 double arg2 = (double) 0 ;
7195 double arg3 = (double) 0 ;
7196 PyObject * obj0 = 0 ;
7197 PyObject * obj1 = 0 ;
7198 PyObject * obj2 = 0 ;
7199 char *kwnames[] = {
7200 (char *) "self",(char *) "x",(char *) "y", NULL
7201 };
7202
7203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7205 if (SWIG_arg_fail(1)) SWIG_fail;
7206 if (obj1) {
7207 {
7208 arg2 = (double)(SWIG_As_double(obj1));
7209 if (SWIG_arg_fail(2)) SWIG_fail;
7210 }
7211 }
7212 if (obj2) {
7213 {
7214 arg3 = (double)(SWIG_As_double(obj2));
7215 if (SWIG_arg_fail(3)) SWIG_fail;
7216 }
7217 }
7218 {
7219 PyThreadState* __tstate = wxPyBeginAllowThreads();
7220 wxPoint2D_Set(arg1,arg2,arg3);
7221
7222 wxPyEndAllowThreads(__tstate);
7223 if (PyErr_Occurred()) SWIG_fail;
7224 }
7225 Py_INCREF(Py_None); resultobj = Py_None;
7226 return resultobj;
7227 fail:
7228 return NULL;
7229 }
7230
7231
7232 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7233 PyObject *resultobj;
7234 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7235 PyObject *result;
7236 PyObject * obj0 = 0 ;
7237 char *kwnames[] = {
7238 (char *) "self", NULL
7239 };
7240
7241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7243 if (SWIG_arg_fail(1)) SWIG_fail;
7244 {
7245 PyThreadState* __tstate = wxPyBeginAllowThreads();
7246 result = (PyObject *)wxPoint2D_Get(arg1);
7247
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 resultobj = result;
7252 return resultobj;
7253 fail:
7254 return NULL;
7255 }
7256
7257
7258 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7259 PyObject *obj;
7260 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7261 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7262 Py_INCREF(obj);
7263 return Py_BuildValue((char *)"");
7264 }
7265 static int _wrap_DefaultPosition_set(PyObject *) {
7266 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7267 return 1;
7268 }
7269
7270
7271 static PyObject *_wrap_DefaultPosition_get(void) {
7272 PyObject *pyobj;
7273
7274 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7275 return pyobj;
7276 }
7277
7278
7279 static int _wrap_DefaultSize_set(PyObject *) {
7280 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7281 return 1;
7282 }
7283
7284
7285 static PyObject *_wrap_DefaultSize_get(void) {
7286 PyObject *pyobj;
7287
7288 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7289 return pyobj;
7290 }
7291
7292
7293 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7294 PyObject *resultobj;
7295 PyObject *arg1 = (PyObject *) 0 ;
7296 wxPyInputStream *result;
7297 PyObject * obj0 = 0 ;
7298 char *kwnames[] = {
7299 (char *) "p", NULL
7300 };
7301
7302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7303 arg1 = obj0;
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7307
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7319 PyObject *resultobj;
7320 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7321 PyObject * obj0 = 0 ;
7322 char *kwnames[] = {
7323 (char *) "self", NULL
7324 };
7325
7326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7328 if (SWIG_arg_fail(1)) SWIG_fail;
7329 {
7330 PyThreadState* __tstate = wxPyBeginAllowThreads();
7331 delete arg1;
7332
7333 wxPyEndAllowThreads(__tstate);
7334 if (PyErr_Occurred()) SWIG_fail;
7335 }
7336 Py_INCREF(Py_None); resultobj = Py_None;
7337 return resultobj;
7338 fail:
7339 return NULL;
7340 }
7341
7342
7343 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7344 PyObject *resultobj;
7345 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7346 PyObject * obj0 = 0 ;
7347 char *kwnames[] = {
7348 (char *) "self", NULL
7349 };
7350
7351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7353 if (SWIG_arg_fail(1)) SWIG_fail;
7354 {
7355 PyThreadState* __tstate = wxPyBeginAllowThreads();
7356 (arg1)->close();
7357
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 Py_INCREF(Py_None); resultobj = Py_None;
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7369 PyObject *resultobj;
7370 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7371 PyObject * obj0 = 0 ;
7372 char *kwnames[] = {
7373 (char *) "self", NULL
7374 };
7375
7376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7378 if (SWIG_arg_fail(1)) SWIG_fail;
7379 {
7380 PyThreadState* __tstate = wxPyBeginAllowThreads();
7381 (arg1)->flush();
7382
7383 wxPyEndAllowThreads(__tstate);
7384 if (PyErr_Occurred()) SWIG_fail;
7385 }
7386 Py_INCREF(Py_None); resultobj = Py_None;
7387 return resultobj;
7388 fail:
7389 return NULL;
7390 }
7391
7392
7393 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7394 PyObject *resultobj;
7395 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7396 bool result;
7397 PyObject * obj0 = 0 ;
7398 char *kwnames[] = {
7399 (char *) "self", NULL
7400 };
7401
7402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7404 if (SWIG_arg_fail(1)) SWIG_fail;
7405 {
7406 PyThreadState* __tstate = wxPyBeginAllowThreads();
7407 result = (bool)(arg1)->eof();
7408
7409 wxPyEndAllowThreads(__tstate);
7410 if (PyErr_Occurred()) SWIG_fail;
7411 }
7412 {
7413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7414 }
7415 return resultobj;
7416 fail:
7417 return NULL;
7418 }
7419
7420
7421 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7422 PyObject *resultobj;
7423 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7424 int arg2 = (int) -1 ;
7425 PyObject *result;
7426 PyObject * obj0 = 0 ;
7427 PyObject * obj1 = 0 ;
7428 char *kwnames[] = {
7429 (char *) "self",(char *) "size", NULL
7430 };
7431
7432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7434 if (SWIG_arg_fail(1)) SWIG_fail;
7435 if (obj1) {
7436 {
7437 arg2 = (int)(SWIG_As_int(obj1));
7438 if (SWIG_arg_fail(2)) SWIG_fail;
7439 }
7440 }
7441 {
7442 PyThreadState* __tstate = wxPyBeginAllowThreads();
7443 result = (PyObject *)(arg1)->read(arg2);
7444
7445 wxPyEndAllowThreads(__tstate);
7446 if (PyErr_Occurred()) SWIG_fail;
7447 }
7448 resultobj = result;
7449 return resultobj;
7450 fail:
7451 return NULL;
7452 }
7453
7454
7455 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7456 PyObject *resultobj;
7457 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7458 int arg2 = (int) -1 ;
7459 PyObject *result;
7460 PyObject * obj0 = 0 ;
7461 PyObject * obj1 = 0 ;
7462 char *kwnames[] = {
7463 (char *) "self",(char *) "size", NULL
7464 };
7465
7466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7468 if (SWIG_arg_fail(1)) SWIG_fail;
7469 if (obj1) {
7470 {
7471 arg2 = (int)(SWIG_As_int(obj1));
7472 if (SWIG_arg_fail(2)) SWIG_fail;
7473 }
7474 }
7475 {
7476 PyThreadState* __tstate = wxPyBeginAllowThreads();
7477 result = (PyObject *)(arg1)->readline(arg2);
7478
7479 wxPyEndAllowThreads(__tstate);
7480 if (PyErr_Occurred()) SWIG_fail;
7481 }
7482 resultobj = result;
7483 return resultobj;
7484 fail:
7485 return NULL;
7486 }
7487
7488
7489 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7490 PyObject *resultobj;
7491 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7492 int arg2 = (int) -1 ;
7493 PyObject *result;
7494 PyObject * obj0 = 0 ;
7495 PyObject * obj1 = 0 ;
7496 char *kwnames[] = {
7497 (char *) "self",(char *) "sizehint", NULL
7498 };
7499
7500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7502 if (SWIG_arg_fail(1)) SWIG_fail;
7503 if (obj1) {
7504 {
7505 arg2 = (int)(SWIG_As_int(obj1));
7506 if (SWIG_arg_fail(2)) SWIG_fail;
7507 }
7508 }
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (PyObject *)(arg1)->readlines(arg2);
7512
7513 wxPyEndAllowThreads(__tstate);
7514 if (PyErr_Occurred()) SWIG_fail;
7515 }
7516 resultobj = result;
7517 return resultobj;
7518 fail:
7519 return NULL;
7520 }
7521
7522
7523 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7524 PyObject *resultobj;
7525 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7526 int arg2 ;
7527 int arg3 = (int) 0 ;
7528 PyObject * obj0 = 0 ;
7529 PyObject * obj1 = 0 ;
7530 PyObject * obj2 = 0 ;
7531 char *kwnames[] = {
7532 (char *) "self",(char *) "offset",(char *) "whence", NULL
7533 };
7534
7535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7537 if (SWIG_arg_fail(1)) SWIG_fail;
7538 {
7539 arg2 = (int)(SWIG_As_int(obj1));
7540 if (SWIG_arg_fail(2)) SWIG_fail;
7541 }
7542 if (obj2) {
7543 {
7544 arg3 = (int)(SWIG_As_int(obj2));
7545 if (SWIG_arg_fail(3)) SWIG_fail;
7546 }
7547 }
7548 {
7549 PyThreadState* __tstate = wxPyBeginAllowThreads();
7550 (arg1)->seek(arg2,arg3);
7551
7552 wxPyEndAllowThreads(__tstate);
7553 if (PyErr_Occurred()) SWIG_fail;
7554 }
7555 Py_INCREF(Py_None); resultobj = Py_None;
7556 return resultobj;
7557 fail:
7558 return NULL;
7559 }
7560
7561
7562 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7563 PyObject *resultobj;
7564 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7565 int result;
7566 PyObject * obj0 = 0 ;
7567 char *kwnames[] = {
7568 (char *) "self", NULL
7569 };
7570
7571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7573 if (SWIG_arg_fail(1)) SWIG_fail;
7574 {
7575 PyThreadState* __tstate = wxPyBeginAllowThreads();
7576 result = (int)(arg1)->tell();
7577
7578 wxPyEndAllowThreads(__tstate);
7579 if (PyErr_Occurred()) SWIG_fail;
7580 }
7581 {
7582 resultobj = SWIG_From_int((int)(result));
7583 }
7584 return resultobj;
7585 fail:
7586 return NULL;
7587 }
7588
7589
7590 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7591 PyObject *resultobj;
7592 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7593 char result;
7594 PyObject * obj0 = 0 ;
7595 char *kwnames[] = {
7596 (char *) "self", NULL
7597 };
7598
7599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7601 if (SWIG_arg_fail(1)) SWIG_fail;
7602 {
7603 PyThreadState* __tstate = wxPyBeginAllowThreads();
7604 result = (char)(arg1)->Peek();
7605
7606 wxPyEndAllowThreads(__tstate);
7607 if (PyErr_Occurred()) SWIG_fail;
7608 }
7609 {
7610 resultobj = SWIG_From_char((char)(result));
7611 }
7612 return resultobj;
7613 fail:
7614 return NULL;
7615 }
7616
7617
7618 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7619 PyObject *resultobj;
7620 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7621 char result;
7622 PyObject * obj0 = 0 ;
7623 char *kwnames[] = {
7624 (char *) "self", NULL
7625 };
7626
7627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7629 if (SWIG_arg_fail(1)) SWIG_fail;
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 result = (char)(arg1)->GetC();
7633
7634 wxPyEndAllowThreads(__tstate);
7635 if (PyErr_Occurred()) SWIG_fail;
7636 }
7637 {
7638 resultobj = SWIG_From_char((char)(result));
7639 }
7640 return resultobj;
7641 fail:
7642 return NULL;
7643 }
7644
7645
7646 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7647 PyObject *resultobj;
7648 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7649 size_t result;
7650 PyObject * obj0 = 0 ;
7651 char *kwnames[] = {
7652 (char *) "self", NULL
7653 };
7654
7655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7657 if (SWIG_arg_fail(1)) SWIG_fail;
7658 {
7659 PyThreadState* __tstate = wxPyBeginAllowThreads();
7660 result = (size_t)(arg1)->LastRead();
7661
7662 wxPyEndAllowThreads(__tstate);
7663 if (PyErr_Occurred()) SWIG_fail;
7664 }
7665 {
7666 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7667 }
7668 return resultobj;
7669 fail:
7670 return NULL;
7671 }
7672
7673
7674 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7675 PyObject *resultobj;
7676 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7677 bool result;
7678 PyObject * obj0 = 0 ;
7679 char *kwnames[] = {
7680 (char *) "self", NULL
7681 };
7682
7683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7685 if (SWIG_arg_fail(1)) SWIG_fail;
7686 {
7687 PyThreadState* __tstate = wxPyBeginAllowThreads();
7688 result = (bool)(arg1)->CanRead();
7689
7690 wxPyEndAllowThreads(__tstate);
7691 if (PyErr_Occurred()) SWIG_fail;
7692 }
7693 {
7694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7695 }
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7703 PyObject *resultobj;
7704 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7705 bool result;
7706 PyObject * obj0 = 0 ;
7707 char *kwnames[] = {
7708 (char *) "self", NULL
7709 };
7710
7711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7713 if (SWIG_arg_fail(1)) SWIG_fail;
7714 {
7715 PyThreadState* __tstate = wxPyBeginAllowThreads();
7716 result = (bool)(arg1)->Eof();
7717
7718 wxPyEndAllowThreads(__tstate);
7719 if (PyErr_Occurred()) SWIG_fail;
7720 }
7721 {
7722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7723 }
7724 return resultobj;
7725 fail:
7726 return NULL;
7727 }
7728
7729
7730 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7731 PyObject *resultobj;
7732 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7733 char arg2 ;
7734 bool result;
7735 PyObject * obj0 = 0 ;
7736 PyObject * obj1 = 0 ;
7737 char *kwnames[] = {
7738 (char *) "self",(char *) "c", NULL
7739 };
7740
7741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7743 if (SWIG_arg_fail(1)) SWIG_fail;
7744 {
7745 arg2 = (char)(SWIG_As_char(obj1));
7746 if (SWIG_arg_fail(2)) SWIG_fail;
7747 }
7748 {
7749 PyThreadState* __tstate = wxPyBeginAllowThreads();
7750 result = (bool)(arg1)->Ungetch(arg2);
7751
7752 wxPyEndAllowThreads(__tstate);
7753 if (PyErr_Occurred()) SWIG_fail;
7754 }
7755 {
7756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7757 }
7758 return resultobj;
7759 fail:
7760 return NULL;
7761 }
7762
7763
7764 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7765 PyObject *resultobj;
7766 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7767 long arg2 ;
7768 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7769 long result;
7770 PyObject * obj0 = 0 ;
7771 PyObject * obj1 = 0 ;
7772 PyObject * obj2 = 0 ;
7773 char *kwnames[] = {
7774 (char *) "self",(char *) "pos",(char *) "mode", NULL
7775 };
7776
7777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7779 if (SWIG_arg_fail(1)) SWIG_fail;
7780 {
7781 arg2 = (long)(SWIG_As_long(obj1));
7782 if (SWIG_arg_fail(2)) SWIG_fail;
7783 }
7784 if (obj2) {
7785 {
7786 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7787 if (SWIG_arg_fail(3)) SWIG_fail;
7788 }
7789 }
7790 {
7791 PyThreadState* __tstate = wxPyBeginAllowThreads();
7792 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7793
7794 wxPyEndAllowThreads(__tstate);
7795 if (PyErr_Occurred()) SWIG_fail;
7796 }
7797 {
7798 resultobj = SWIG_From_long((long)(result));
7799 }
7800 return resultobj;
7801 fail:
7802 return NULL;
7803 }
7804
7805
7806 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7807 PyObject *resultobj;
7808 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7809 long result;
7810 PyObject * obj0 = 0 ;
7811 char *kwnames[] = {
7812 (char *) "self", NULL
7813 };
7814
7815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7817 if (SWIG_arg_fail(1)) SWIG_fail;
7818 {
7819 PyThreadState* __tstate = wxPyBeginAllowThreads();
7820 result = (long)(arg1)->TellI();
7821
7822 wxPyEndAllowThreads(__tstate);
7823 if (PyErr_Occurred()) SWIG_fail;
7824 }
7825 {
7826 resultobj = SWIG_From_long((long)(result));
7827 }
7828 return resultobj;
7829 fail:
7830 return NULL;
7831 }
7832
7833
7834 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7835 PyObject *obj;
7836 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7837 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7838 Py_INCREF(obj);
7839 return Py_BuildValue((char *)"");
7840 }
7841 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7842 PyObject *resultobj;
7843 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7844 PyObject *arg2 = (PyObject *) 0 ;
7845 PyObject * obj0 = 0 ;
7846 PyObject * obj1 = 0 ;
7847 char *kwnames[] = {
7848 (char *) "self",(char *) "obj", NULL
7849 };
7850
7851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7853 if (SWIG_arg_fail(1)) SWIG_fail;
7854 arg2 = obj1;
7855 {
7856 PyThreadState* __tstate = wxPyBeginAllowThreads();
7857 wxOutputStream_write(arg1,arg2);
7858
7859 wxPyEndAllowThreads(__tstate);
7860 if (PyErr_Occurred()) SWIG_fail;
7861 }
7862 Py_INCREF(Py_None); resultobj = Py_None;
7863 return resultobj;
7864 fail:
7865 return NULL;
7866 }
7867
7868
7869 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7870 PyObject *obj;
7871 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7872 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7873 Py_INCREF(obj);
7874 return Py_BuildValue((char *)"");
7875 }
7876 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7877 PyObject *resultobj;
7878 wxInputStream *arg1 = (wxInputStream *) 0 ;
7879 wxString *arg2 = 0 ;
7880 wxString *arg3 = 0 ;
7881 wxString *arg4 = 0 ;
7882 wxDateTime arg5 ;
7883 wxFSFile *result;
7884 wxPyInputStream *temp1 ;
7885 bool created1 ;
7886 bool temp2 = false ;
7887 bool temp3 = false ;
7888 bool temp4 = false ;
7889 PyObject * obj0 = 0 ;
7890 PyObject * obj1 = 0 ;
7891 PyObject * obj2 = 0 ;
7892 PyObject * obj3 = 0 ;
7893 PyObject * obj4 = 0 ;
7894 char *kwnames[] = {
7895 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7896 };
7897
7898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7899 {
7900 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7901 arg1 = temp1->m_wxis;
7902 created1 = false;
7903 } else {
7904 PyErr_Clear(); // clear the failure of the wxPyConvert above
7905 arg1 = wxPyCBInputStream_create(obj0, false);
7906 if (arg1 == NULL) {
7907 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7908 SWIG_fail;
7909 }
7910 created1 = true;
7911 }
7912 }
7913 {
7914 arg2 = wxString_in_helper(obj1);
7915 if (arg2 == NULL) SWIG_fail;
7916 temp2 = true;
7917 }
7918 {
7919 arg3 = wxString_in_helper(obj2);
7920 if (arg3 == NULL) SWIG_fail;
7921 temp3 = true;
7922 }
7923 {
7924 arg4 = wxString_in_helper(obj3);
7925 if (arg4 == NULL) SWIG_fail;
7926 temp4 = true;
7927 }
7928 {
7929 wxDateTime * argp;
7930 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7931 if (SWIG_arg_fail(5)) SWIG_fail;
7932 if (argp == NULL) {
7933 SWIG_null_ref("wxDateTime");
7934 }
7935 if (SWIG_arg_fail(5)) SWIG_fail;
7936 arg5 = *argp;
7937 }
7938 {
7939 PyThreadState* __tstate = wxPyBeginAllowThreads();
7940 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7941
7942 wxPyEndAllowThreads(__tstate);
7943 if (PyErr_Occurred()) SWIG_fail;
7944 }
7945 {
7946 resultobj = wxPyMake_wxObject(result, 1);
7947 }
7948 {
7949 if (created1)
7950 delete arg1;
7951 }
7952 {
7953 if (temp2)
7954 delete arg2;
7955 }
7956 {
7957 if (temp3)
7958 delete arg3;
7959 }
7960 {
7961 if (temp4)
7962 delete arg4;
7963 }
7964 return resultobj;
7965 fail:
7966 {
7967 if (created1)
7968 delete arg1;
7969 }
7970 {
7971 if (temp2)
7972 delete arg2;
7973 }
7974 {
7975 if (temp3)
7976 delete arg3;
7977 }
7978 {
7979 if (temp4)
7980 delete arg4;
7981 }
7982 return NULL;
7983 }
7984
7985
7986 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7987 PyObject *resultobj;
7988 wxFSFile *arg1 = (wxFSFile *) 0 ;
7989 PyObject * obj0 = 0 ;
7990 char *kwnames[] = {
7991 (char *) "self", NULL
7992 };
7993
7994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
7995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
7996 if (SWIG_arg_fail(1)) SWIG_fail;
7997 {
7998 PyThreadState* __tstate = wxPyBeginAllowThreads();
7999 delete arg1;
8000
8001 wxPyEndAllowThreads(__tstate);
8002 if (PyErr_Occurred()) SWIG_fail;
8003 }
8004 Py_INCREF(Py_None); resultobj = Py_None;
8005 return resultobj;
8006 fail:
8007 return NULL;
8008 }
8009
8010
8011 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8012 PyObject *resultobj;
8013 wxFSFile *arg1 = (wxFSFile *) 0 ;
8014 wxInputStream *result;
8015 PyObject * obj0 = 0 ;
8016 char *kwnames[] = {
8017 (char *) "self", NULL
8018 };
8019
8020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8022 if (SWIG_arg_fail(1)) SWIG_fail;
8023 {
8024 PyThreadState* __tstate = wxPyBeginAllowThreads();
8025 result = (wxInputStream *)(arg1)->GetStream();
8026
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 {
8031 wxPyInputStream * _ptr = NULL;
8032
8033 if (result) {
8034 _ptr = new wxPyInputStream(result);
8035 }
8036 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8037 }
8038 return resultobj;
8039 fail:
8040 return NULL;
8041 }
8042
8043
8044 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8045 PyObject *resultobj;
8046 wxFSFile *arg1 = (wxFSFile *) 0 ;
8047 wxString *result;
8048 PyObject * obj0 = 0 ;
8049 char *kwnames[] = {
8050 (char *) "self", NULL
8051 };
8052
8053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8055 if (SWIG_arg_fail(1)) SWIG_fail;
8056 {
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 {
8059 wxString const &_result_ref = (arg1)->GetMimeType();
8060 result = (wxString *) &_result_ref;
8061 }
8062
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 {
8067 #if wxUSE_UNICODE
8068 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8069 #else
8070 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8071 #endif
8072 }
8073 return resultobj;
8074 fail:
8075 return NULL;
8076 }
8077
8078
8079 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8080 PyObject *resultobj;
8081 wxFSFile *arg1 = (wxFSFile *) 0 ;
8082 wxString *result;
8083 PyObject * obj0 = 0 ;
8084 char *kwnames[] = {
8085 (char *) "self", NULL
8086 };
8087
8088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8090 if (SWIG_arg_fail(1)) SWIG_fail;
8091 {
8092 PyThreadState* __tstate = wxPyBeginAllowThreads();
8093 {
8094 wxString const &_result_ref = (arg1)->GetLocation();
8095 result = (wxString *) &_result_ref;
8096 }
8097
8098 wxPyEndAllowThreads(__tstate);
8099 if (PyErr_Occurred()) SWIG_fail;
8100 }
8101 {
8102 #if wxUSE_UNICODE
8103 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8104 #else
8105 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8106 #endif
8107 }
8108 return resultobj;
8109 fail:
8110 return NULL;
8111 }
8112
8113
8114 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8115 PyObject *resultobj;
8116 wxFSFile *arg1 = (wxFSFile *) 0 ;
8117 wxString *result;
8118 PyObject * obj0 = 0 ;
8119 char *kwnames[] = {
8120 (char *) "self", NULL
8121 };
8122
8123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8125 if (SWIG_arg_fail(1)) SWIG_fail;
8126 {
8127 PyThreadState* __tstate = wxPyBeginAllowThreads();
8128 {
8129 wxString const &_result_ref = (arg1)->GetAnchor();
8130 result = (wxString *) &_result_ref;
8131 }
8132
8133 wxPyEndAllowThreads(__tstate);
8134 if (PyErr_Occurred()) SWIG_fail;
8135 }
8136 {
8137 #if wxUSE_UNICODE
8138 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8139 #else
8140 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8141 #endif
8142 }
8143 return resultobj;
8144 fail:
8145 return NULL;
8146 }
8147
8148
8149 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8150 PyObject *resultobj;
8151 wxFSFile *arg1 = (wxFSFile *) 0 ;
8152 wxDateTime result;
8153 PyObject * obj0 = 0 ;
8154 char *kwnames[] = {
8155 (char *) "self", NULL
8156 };
8157
8158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8160 if (SWIG_arg_fail(1)) SWIG_fail;
8161 {
8162 PyThreadState* __tstate = wxPyBeginAllowThreads();
8163 result = (arg1)->GetModificationTime();
8164
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 {
8169 wxDateTime * resultptr;
8170 resultptr = new wxDateTime((wxDateTime &)(result));
8171 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8172 }
8173 return resultobj;
8174 fail:
8175 return NULL;
8176 }
8177
8178
8179 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8180 PyObject *obj;
8181 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8182 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8183 Py_INCREF(obj);
8184 return Py_BuildValue((char *)"");
8185 }
8186 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8187 PyObject *obj;
8188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8189 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8190 Py_INCREF(obj);
8191 return Py_BuildValue((char *)"");
8192 }
8193 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8194 PyObject *resultobj;
8195 wxPyFileSystemHandler *result;
8196 char *kwnames[] = {
8197 NULL
8198 };
8199
8200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8201 {
8202 PyThreadState* __tstate = wxPyBeginAllowThreads();
8203 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8204
8205 wxPyEndAllowThreads(__tstate);
8206 if (PyErr_Occurred()) SWIG_fail;
8207 }
8208 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8209 return resultobj;
8210 fail:
8211 return NULL;
8212 }
8213
8214
8215 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8216 PyObject *resultobj;
8217 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8218 PyObject *arg2 = (PyObject *) 0 ;
8219 PyObject *arg3 = (PyObject *) 0 ;
8220 PyObject * obj0 = 0 ;
8221 PyObject * obj1 = 0 ;
8222 PyObject * obj2 = 0 ;
8223 char *kwnames[] = {
8224 (char *) "self",(char *) "self",(char *) "_class", NULL
8225 };
8226
8227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8229 if (SWIG_arg_fail(1)) SWIG_fail;
8230 arg2 = obj1;
8231 arg3 = obj2;
8232 {
8233 PyThreadState* __tstate = wxPyBeginAllowThreads();
8234 (arg1)->_setCallbackInfo(arg2,arg3);
8235
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 Py_INCREF(Py_None); resultobj = Py_None;
8240 return resultobj;
8241 fail:
8242 return NULL;
8243 }
8244
8245
8246 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8247 PyObject *resultobj;
8248 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8249 wxString *arg2 = 0 ;
8250 bool result;
8251 bool temp2 = false ;
8252 PyObject * obj0 = 0 ;
8253 PyObject * obj1 = 0 ;
8254 char *kwnames[] = {
8255 (char *) "self",(char *) "location", NULL
8256 };
8257
8258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8260 if (SWIG_arg_fail(1)) SWIG_fail;
8261 {
8262 arg2 = wxString_in_helper(obj1);
8263 if (arg2 == NULL) SWIG_fail;
8264 temp2 = true;
8265 }
8266 {
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8269
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 {
8274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8275 }
8276 {
8277 if (temp2)
8278 delete arg2;
8279 }
8280 return resultobj;
8281 fail:
8282 {
8283 if (temp2)
8284 delete arg2;
8285 }
8286 return NULL;
8287 }
8288
8289
8290 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8291 PyObject *resultobj;
8292 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8293 wxFileSystem *arg2 = 0 ;
8294 wxString *arg3 = 0 ;
8295 wxFSFile *result;
8296 bool temp3 = false ;
8297 PyObject * obj0 = 0 ;
8298 PyObject * obj1 = 0 ;
8299 PyObject * obj2 = 0 ;
8300 char *kwnames[] = {
8301 (char *) "self",(char *) "fs",(char *) "location", NULL
8302 };
8303
8304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8306 if (SWIG_arg_fail(1)) SWIG_fail;
8307 {
8308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8309 if (SWIG_arg_fail(2)) SWIG_fail;
8310 if (arg2 == NULL) {
8311 SWIG_null_ref("wxFileSystem");
8312 }
8313 if (SWIG_arg_fail(2)) SWIG_fail;
8314 }
8315 {
8316 arg3 = wxString_in_helper(obj2);
8317 if (arg3 == NULL) SWIG_fail;
8318 temp3 = true;
8319 }
8320 {
8321 PyThreadState* __tstate = wxPyBeginAllowThreads();
8322 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8323
8324 wxPyEndAllowThreads(__tstate);
8325 if (PyErr_Occurred()) SWIG_fail;
8326 }
8327 {
8328 resultobj = wxPyMake_wxObject(result, 1);
8329 }
8330 {
8331 if (temp3)
8332 delete arg3;
8333 }
8334 return resultobj;
8335 fail:
8336 {
8337 if (temp3)
8338 delete arg3;
8339 }
8340 return NULL;
8341 }
8342
8343
8344 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj;
8346 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8347 wxString *arg2 = 0 ;
8348 int arg3 = (int) 0 ;
8349 wxString result;
8350 bool temp2 = false ;
8351 PyObject * obj0 = 0 ;
8352 PyObject * obj1 = 0 ;
8353 PyObject * obj2 = 0 ;
8354 char *kwnames[] = {
8355 (char *) "self",(char *) "spec",(char *) "flags", NULL
8356 };
8357
8358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8360 if (SWIG_arg_fail(1)) SWIG_fail;
8361 {
8362 arg2 = wxString_in_helper(obj1);
8363 if (arg2 == NULL) SWIG_fail;
8364 temp2 = true;
8365 }
8366 if (obj2) {
8367 {
8368 arg3 = (int)(SWIG_As_int(obj2));
8369 if (SWIG_arg_fail(3)) SWIG_fail;
8370 }
8371 }
8372 {
8373 PyThreadState* __tstate = wxPyBeginAllowThreads();
8374 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8375
8376 wxPyEndAllowThreads(__tstate);
8377 if (PyErr_Occurred()) SWIG_fail;
8378 }
8379 {
8380 #if wxUSE_UNICODE
8381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8382 #else
8383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8384 #endif
8385 }
8386 {
8387 if (temp2)
8388 delete arg2;
8389 }
8390 return resultobj;
8391 fail:
8392 {
8393 if (temp2)
8394 delete arg2;
8395 }
8396 return NULL;
8397 }
8398
8399
8400 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8401 PyObject *resultobj;
8402 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8403 wxString result;
8404 PyObject * obj0 = 0 ;
8405 char *kwnames[] = {
8406 (char *) "self", NULL
8407 };
8408
8409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8411 if (SWIG_arg_fail(1)) SWIG_fail;
8412 {
8413 PyThreadState* __tstate = wxPyBeginAllowThreads();
8414 result = (arg1)->FindNext();
8415
8416 wxPyEndAllowThreads(__tstate);
8417 if (PyErr_Occurred()) SWIG_fail;
8418 }
8419 {
8420 #if wxUSE_UNICODE
8421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8422 #else
8423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8424 #endif
8425 }
8426 return resultobj;
8427 fail:
8428 return NULL;
8429 }
8430
8431
8432 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8433 PyObject *resultobj;
8434 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8435 wxString *arg2 = 0 ;
8436 wxString result;
8437 bool temp2 = false ;
8438 PyObject * obj0 = 0 ;
8439 PyObject * obj1 = 0 ;
8440 char *kwnames[] = {
8441 (char *) "self",(char *) "location", NULL
8442 };
8443
8444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8446 if (SWIG_arg_fail(1)) SWIG_fail;
8447 {
8448 arg2 = wxString_in_helper(obj1);
8449 if (arg2 == NULL) SWIG_fail;
8450 temp2 = true;
8451 }
8452 {
8453 PyThreadState* __tstate = wxPyBeginAllowThreads();
8454 result = (arg1)->GetProtocol((wxString const &)*arg2);
8455
8456 wxPyEndAllowThreads(__tstate);
8457 if (PyErr_Occurred()) SWIG_fail;
8458 }
8459 {
8460 #if wxUSE_UNICODE
8461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8462 #else
8463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8464 #endif
8465 }
8466 {
8467 if (temp2)
8468 delete arg2;
8469 }
8470 return resultobj;
8471 fail:
8472 {
8473 if (temp2)
8474 delete arg2;
8475 }
8476 return NULL;
8477 }
8478
8479
8480 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8481 PyObject *resultobj;
8482 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8483 wxString *arg2 = 0 ;
8484 wxString result;
8485 bool temp2 = false ;
8486 PyObject * obj0 = 0 ;
8487 PyObject * obj1 = 0 ;
8488 char *kwnames[] = {
8489 (char *) "self",(char *) "location", NULL
8490 };
8491
8492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8494 if (SWIG_arg_fail(1)) SWIG_fail;
8495 {
8496 arg2 = wxString_in_helper(obj1);
8497 if (arg2 == NULL) SWIG_fail;
8498 temp2 = true;
8499 }
8500 {
8501 PyThreadState* __tstate = wxPyBeginAllowThreads();
8502 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8503
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 {
8508 #if wxUSE_UNICODE
8509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8510 #else
8511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8512 #endif
8513 }
8514 {
8515 if (temp2)
8516 delete arg2;
8517 }
8518 return resultobj;
8519 fail:
8520 {
8521 if (temp2)
8522 delete arg2;
8523 }
8524 return NULL;
8525 }
8526
8527
8528 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8529 PyObject *resultobj;
8530 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8531 wxString *arg2 = 0 ;
8532 wxString result;
8533 bool temp2 = false ;
8534 PyObject * obj0 = 0 ;
8535 PyObject * obj1 = 0 ;
8536 char *kwnames[] = {
8537 (char *) "self",(char *) "location", NULL
8538 };
8539
8540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8542 if (SWIG_arg_fail(1)) SWIG_fail;
8543 {
8544 arg2 = wxString_in_helper(obj1);
8545 if (arg2 == NULL) SWIG_fail;
8546 temp2 = true;
8547 }
8548 {
8549 PyThreadState* __tstate = wxPyBeginAllowThreads();
8550 result = (arg1)->GetAnchor((wxString const &)*arg2);
8551
8552 wxPyEndAllowThreads(__tstate);
8553 if (PyErr_Occurred()) SWIG_fail;
8554 }
8555 {
8556 #if wxUSE_UNICODE
8557 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8558 #else
8559 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8560 #endif
8561 }
8562 {
8563 if (temp2)
8564 delete arg2;
8565 }
8566 return resultobj;
8567 fail:
8568 {
8569 if (temp2)
8570 delete arg2;
8571 }
8572 return NULL;
8573 }
8574
8575
8576 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8577 PyObject *resultobj;
8578 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8579 wxString *arg2 = 0 ;
8580 wxString result;
8581 bool temp2 = false ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char *kwnames[] = {
8585 (char *) "self",(char *) "location", NULL
8586 };
8587
8588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8590 if (SWIG_arg_fail(1)) SWIG_fail;
8591 {
8592 arg2 = wxString_in_helper(obj1);
8593 if (arg2 == NULL) SWIG_fail;
8594 temp2 = true;
8595 }
8596 {
8597 PyThreadState* __tstate = wxPyBeginAllowThreads();
8598 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8599
8600 wxPyEndAllowThreads(__tstate);
8601 if (PyErr_Occurred()) SWIG_fail;
8602 }
8603 {
8604 #if wxUSE_UNICODE
8605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8606 #else
8607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8608 #endif
8609 }
8610 {
8611 if (temp2)
8612 delete arg2;
8613 }
8614 return resultobj;
8615 fail:
8616 {
8617 if (temp2)
8618 delete arg2;
8619 }
8620 return NULL;
8621 }
8622
8623
8624 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8625 PyObject *resultobj;
8626 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8627 wxString *arg2 = 0 ;
8628 wxString result;
8629 bool temp2 = false ;
8630 PyObject * obj0 = 0 ;
8631 PyObject * obj1 = 0 ;
8632 char *kwnames[] = {
8633 (char *) "self",(char *) "location", NULL
8634 };
8635
8636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8638 if (SWIG_arg_fail(1)) SWIG_fail;
8639 {
8640 arg2 = wxString_in_helper(obj1);
8641 if (arg2 == NULL) SWIG_fail;
8642 temp2 = true;
8643 }
8644 {
8645 PyThreadState* __tstate = wxPyBeginAllowThreads();
8646 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8647
8648 wxPyEndAllowThreads(__tstate);
8649 if (PyErr_Occurred()) SWIG_fail;
8650 }
8651 {
8652 #if wxUSE_UNICODE
8653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8654 #else
8655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8656 #endif
8657 }
8658 {
8659 if (temp2)
8660 delete arg2;
8661 }
8662 return resultobj;
8663 fail:
8664 {
8665 if (temp2)
8666 delete arg2;
8667 }
8668 return NULL;
8669 }
8670
8671
8672 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8673 PyObject *obj;
8674 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8675 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8676 Py_INCREF(obj);
8677 return Py_BuildValue((char *)"");
8678 }
8679 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8680 PyObject *resultobj;
8681 wxFileSystem *result;
8682 char *kwnames[] = {
8683 NULL
8684 };
8685
8686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8687 {
8688 PyThreadState* __tstate = wxPyBeginAllowThreads();
8689 result = (wxFileSystem *)new wxFileSystem();
8690
8691 wxPyEndAllowThreads(__tstate);
8692 if (PyErr_Occurred()) SWIG_fail;
8693 }
8694 {
8695 resultobj = wxPyMake_wxObject(result, 1);
8696 }
8697 return resultobj;
8698 fail:
8699 return NULL;
8700 }
8701
8702
8703 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8704 PyObject *resultobj;
8705 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8706 PyObject * obj0 = 0 ;
8707 char *kwnames[] = {
8708 (char *) "self", NULL
8709 };
8710
8711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8713 if (SWIG_arg_fail(1)) SWIG_fail;
8714 {
8715 PyThreadState* __tstate = wxPyBeginAllowThreads();
8716 delete arg1;
8717
8718 wxPyEndAllowThreads(__tstate);
8719 if (PyErr_Occurred()) SWIG_fail;
8720 }
8721 Py_INCREF(Py_None); resultobj = Py_None;
8722 return resultobj;
8723 fail:
8724 return NULL;
8725 }
8726
8727
8728 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8729 PyObject *resultobj;
8730 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8731 wxString *arg2 = 0 ;
8732 bool arg3 = (bool) false ;
8733 bool temp2 = false ;
8734 PyObject * obj0 = 0 ;
8735 PyObject * obj1 = 0 ;
8736 PyObject * obj2 = 0 ;
8737 char *kwnames[] = {
8738 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8739 };
8740
8741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8743 if (SWIG_arg_fail(1)) SWIG_fail;
8744 {
8745 arg2 = wxString_in_helper(obj1);
8746 if (arg2 == NULL) SWIG_fail;
8747 temp2 = true;
8748 }
8749 if (obj2) {
8750 {
8751 arg3 = (bool)(SWIG_As_bool(obj2));
8752 if (SWIG_arg_fail(3)) SWIG_fail;
8753 }
8754 }
8755 {
8756 PyThreadState* __tstate = wxPyBeginAllowThreads();
8757 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8758
8759 wxPyEndAllowThreads(__tstate);
8760 if (PyErr_Occurred()) SWIG_fail;
8761 }
8762 Py_INCREF(Py_None); resultobj = Py_None;
8763 {
8764 if (temp2)
8765 delete arg2;
8766 }
8767 return resultobj;
8768 fail:
8769 {
8770 if (temp2)
8771 delete arg2;
8772 }
8773 return NULL;
8774 }
8775
8776
8777 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8778 PyObject *resultobj;
8779 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8780 wxString result;
8781 PyObject * obj0 = 0 ;
8782 char *kwnames[] = {
8783 (char *) "self", NULL
8784 };
8785
8786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8788 if (SWIG_arg_fail(1)) SWIG_fail;
8789 {
8790 PyThreadState* __tstate = wxPyBeginAllowThreads();
8791 result = (arg1)->GetPath();
8792
8793 wxPyEndAllowThreads(__tstate);
8794 if (PyErr_Occurred()) SWIG_fail;
8795 }
8796 {
8797 #if wxUSE_UNICODE
8798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8799 #else
8800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8801 #endif
8802 }
8803 return resultobj;
8804 fail:
8805 return NULL;
8806 }
8807
8808
8809 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8810 PyObject *resultobj;
8811 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8812 wxString *arg2 = 0 ;
8813 wxFSFile *result;
8814 bool temp2 = false ;
8815 PyObject * obj0 = 0 ;
8816 PyObject * obj1 = 0 ;
8817 char *kwnames[] = {
8818 (char *) "self",(char *) "location", NULL
8819 };
8820
8821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8823 if (SWIG_arg_fail(1)) SWIG_fail;
8824 {
8825 arg2 = wxString_in_helper(obj1);
8826 if (arg2 == NULL) SWIG_fail;
8827 temp2 = true;
8828 }
8829 {
8830 PyThreadState* __tstate = wxPyBeginAllowThreads();
8831 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8832
8833 wxPyEndAllowThreads(__tstate);
8834 if (PyErr_Occurred()) SWIG_fail;
8835 }
8836 {
8837 resultobj = wxPyMake_wxObject(result, 1);
8838 }
8839 {
8840 if (temp2)
8841 delete arg2;
8842 }
8843 return resultobj;
8844 fail:
8845 {
8846 if (temp2)
8847 delete arg2;
8848 }
8849 return NULL;
8850 }
8851
8852
8853 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8854 PyObject *resultobj;
8855 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8856 wxString *arg2 = 0 ;
8857 int arg3 = (int) 0 ;
8858 wxString result;
8859 bool temp2 = false ;
8860 PyObject * obj0 = 0 ;
8861 PyObject * obj1 = 0 ;
8862 PyObject * obj2 = 0 ;
8863 char *kwnames[] = {
8864 (char *) "self",(char *) "spec",(char *) "flags", NULL
8865 };
8866
8867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8869 if (SWIG_arg_fail(1)) SWIG_fail;
8870 {
8871 arg2 = wxString_in_helper(obj1);
8872 if (arg2 == NULL) SWIG_fail;
8873 temp2 = true;
8874 }
8875 if (obj2) {
8876 {
8877 arg3 = (int)(SWIG_As_int(obj2));
8878 if (SWIG_arg_fail(3)) SWIG_fail;
8879 }
8880 }
8881 {
8882 PyThreadState* __tstate = wxPyBeginAllowThreads();
8883 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8884
8885 wxPyEndAllowThreads(__tstate);
8886 if (PyErr_Occurred()) SWIG_fail;
8887 }
8888 {
8889 #if wxUSE_UNICODE
8890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8891 #else
8892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8893 #endif
8894 }
8895 {
8896 if (temp2)
8897 delete arg2;
8898 }
8899 return resultobj;
8900 fail:
8901 {
8902 if (temp2)
8903 delete arg2;
8904 }
8905 return NULL;
8906 }
8907
8908
8909 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8910 PyObject *resultobj;
8911 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8912 wxString result;
8913 PyObject * obj0 = 0 ;
8914 char *kwnames[] = {
8915 (char *) "self", NULL
8916 };
8917
8918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8920 if (SWIG_arg_fail(1)) SWIG_fail;
8921 {
8922 PyThreadState* __tstate = wxPyBeginAllowThreads();
8923 result = (arg1)->FindNext();
8924
8925 wxPyEndAllowThreads(__tstate);
8926 if (PyErr_Occurred()) SWIG_fail;
8927 }
8928 {
8929 #if wxUSE_UNICODE
8930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8931 #else
8932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8933 #endif
8934 }
8935 return resultobj;
8936 fail:
8937 return NULL;
8938 }
8939
8940
8941 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8942 PyObject *resultobj;
8943 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8944 PyObject * obj0 = 0 ;
8945 char *kwnames[] = {
8946 (char *) "handler", NULL
8947 };
8948
8949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8951 if (SWIG_arg_fail(1)) SWIG_fail;
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 wxFileSystem::AddHandler(arg1);
8955
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 Py_INCREF(Py_None); resultobj = Py_None;
8960 return resultobj;
8961 fail:
8962 return NULL;
8963 }
8964
8965
8966 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8967 PyObject *resultobj;
8968 char *kwnames[] = {
8969 NULL
8970 };
8971
8972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8973 {
8974 PyThreadState* __tstate = wxPyBeginAllowThreads();
8975 wxFileSystem::CleanUpHandlers();
8976
8977 wxPyEndAllowThreads(__tstate);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 Py_INCREF(Py_None); resultobj = Py_None;
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
8988 PyObject *resultobj;
8989 wxString *arg1 = 0 ;
8990 wxString result;
8991 bool temp1 = false ;
8992 PyObject * obj0 = 0 ;
8993 char *kwnames[] = {
8994 (char *) "filename", NULL
8995 };
8996
8997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
8998 {
8999 arg1 = wxString_in_helper(obj0);
9000 if (arg1 == NULL) SWIG_fail;
9001 temp1 = true;
9002 }
9003 {
9004 PyThreadState* __tstate = wxPyBeginAllowThreads();
9005 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9006
9007 wxPyEndAllowThreads(__tstate);
9008 if (PyErr_Occurred()) SWIG_fail;
9009 }
9010 {
9011 #if wxUSE_UNICODE
9012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9013 #else
9014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9015 #endif
9016 }
9017 {
9018 if (temp1)
9019 delete arg1;
9020 }
9021 return resultobj;
9022 fail:
9023 {
9024 if (temp1)
9025 delete arg1;
9026 }
9027 return NULL;
9028 }
9029
9030
9031 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9032 PyObject *resultobj;
9033 wxString *arg1 = 0 ;
9034 wxString result;
9035 bool temp1 = false ;
9036 PyObject * obj0 = 0 ;
9037 char *kwnames[] = {
9038 (char *) "url", NULL
9039 };
9040
9041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9042 {
9043 arg1 = wxString_in_helper(obj0);
9044 if (arg1 == NULL) SWIG_fail;
9045 temp1 = true;
9046 }
9047 {
9048 PyThreadState* __tstate = wxPyBeginAllowThreads();
9049 result = FileSystem_URLToFileName((wxString const &)*arg1);
9050
9051 wxPyEndAllowThreads(__tstate);
9052 if (PyErr_Occurred()) SWIG_fail;
9053 }
9054 {
9055 #if wxUSE_UNICODE
9056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9057 #else
9058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9059 #endif
9060 }
9061 {
9062 if (temp1)
9063 delete arg1;
9064 }
9065 return resultobj;
9066 fail:
9067 {
9068 if (temp1)
9069 delete arg1;
9070 }
9071 return NULL;
9072 }
9073
9074
9075 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9076 PyObject *obj;
9077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9078 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9079 Py_INCREF(obj);
9080 return Py_BuildValue((char *)"");
9081 }
9082 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9083 PyObject *resultobj;
9084 wxInternetFSHandler *result;
9085 char *kwnames[] = {
9086 NULL
9087 };
9088
9089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9090 {
9091 PyThreadState* __tstate = wxPyBeginAllowThreads();
9092 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9093
9094 wxPyEndAllowThreads(__tstate);
9095 if (PyErr_Occurred()) SWIG_fail;
9096 }
9097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9098 return resultobj;
9099 fail:
9100 return NULL;
9101 }
9102
9103
9104 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9105 PyObject *resultobj;
9106 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9107 wxString *arg2 = 0 ;
9108 bool result;
9109 bool temp2 = false ;
9110 PyObject * obj0 = 0 ;
9111 PyObject * obj1 = 0 ;
9112 char *kwnames[] = {
9113 (char *) "self",(char *) "location", NULL
9114 };
9115
9116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9118 if (SWIG_arg_fail(1)) SWIG_fail;
9119 {
9120 arg2 = wxString_in_helper(obj1);
9121 if (arg2 == NULL) SWIG_fail;
9122 temp2 = true;
9123 }
9124 {
9125 PyThreadState* __tstate = wxPyBeginAllowThreads();
9126 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9127
9128 wxPyEndAllowThreads(__tstate);
9129 if (PyErr_Occurred()) SWIG_fail;
9130 }
9131 {
9132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9133 }
9134 {
9135 if (temp2)
9136 delete arg2;
9137 }
9138 return resultobj;
9139 fail:
9140 {
9141 if (temp2)
9142 delete arg2;
9143 }
9144 return NULL;
9145 }
9146
9147
9148 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9149 PyObject *resultobj;
9150 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9151 wxFileSystem *arg2 = 0 ;
9152 wxString *arg3 = 0 ;
9153 wxFSFile *result;
9154 bool temp3 = false ;
9155 PyObject * obj0 = 0 ;
9156 PyObject * obj1 = 0 ;
9157 PyObject * obj2 = 0 ;
9158 char *kwnames[] = {
9159 (char *) "self",(char *) "fs",(char *) "location", NULL
9160 };
9161
9162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9164 if (SWIG_arg_fail(1)) SWIG_fail;
9165 {
9166 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9167 if (SWIG_arg_fail(2)) SWIG_fail;
9168 if (arg2 == NULL) {
9169 SWIG_null_ref("wxFileSystem");
9170 }
9171 if (SWIG_arg_fail(2)) SWIG_fail;
9172 }
9173 {
9174 arg3 = wxString_in_helper(obj2);
9175 if (arg3 == NULL) SWIG_fail;
9176 temp3 = true;
9177 }
9178 {
9179 PyThreadState* __tstate = wxPyBeginAllowThreads();
9180 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9181
9182 wxPyEndAllowThreads(__tstate);
9183 if (PyErr_Occurred()) SWIG_fail;
9184 }
9185 {
9186 resultobj = wxPyMake_wxObject(result, 1);
9187 }
9188 {
9189 if (temp3)
9190 delete arg3;
9191 }
9192 return resultobj;
9193 fail:
9194 {
9195 if (temp3)
9196 delete arg3;
9197 }
9198 return NULL;
9199 }
9200
9201
9202 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9203 PyObject *obj;
9204 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9205 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9206 Py_INCREF(obj);
9207 return Py_BuildValue((char *)"");
9208 }
9209 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9210 PyObject *resultobj;
9211 wxZipFSHandler *result;
9212 char *kwnames[] = {
9213 NULL
9214 };
9215
9216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9217 {
9218 PyThreadState* __tstate = wxPyBeginAllowThreads();
9219 result = (wxZipFSHandler *)new wxZipFSHandler();
9220
9221 wxPyEndAllowThreads(__tstate);
9222 if (PyErr_Occurred()) SWIG_fail;
9223 }
9224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9225 return resultobj;
9226 fail:
9227 return NULL;
9228 }
9229
9230
9231 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9232 PyObject *resultobj;
9233 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9234 wxString *arg2 = 0 ;
9235 bool result;
9236 bool temp2 = false ;
9237 PyObject * obj0 = 0 ;
9238 PyObject * obj1 = 0 ;
9239 char *kwnames[] = {
9240 (char *) "self",(char *) "location", NULL
9241 };
9242
9243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9245 if (SWIG_arg_fail(1)) SWIG_fail;
9246 {
9247 arg2 = wxString_in_helper(obj1);
9248 if (arg2 == NULL) SWIG_fail;
9249 temp2 = true;
9250 }
9251 {
9252 PyThreadState* __tstate = wxPyBeginAllowThreads();
9253 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9254
9255 wxPyEndAllowThreads(__tstate);
9256 if (PyErr_Occurred()) SWIG_fail;
9257 }
9258 {
9259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9260 }
9261 {
9262 if (temp2)
9263 delete arg2;
9264 }
9265 return resultobj;
9266 fail:
9267 {
9268 if (temp2)
9269 delete arg2;
9270 }
9271 return NULL;
9272 }
9273
9274
9275 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9276 PyObject *resultobj;
9277 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9278 wxFileSystem *arg2 = 0 ;
9279 wxString *arg3 = 0 ;
9280 wxFSFile *result;
9281 bool temp3 = false ;
9282 PyObject * obj0 = 0 ;
9283 PyObject * obj1 = 0 ;
9284 PyObject * obj2 = 0 ;
9285 char *kwnames[] = {
9286 (char *) "self",(char *) "fs",(char *) "location", NULL
9287 };
9288
9289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9291 if (SWIG_arg_fail(1)) SWIG_fail;
9292 {
9293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9294 if (SWIG_arg_fail(2)) SWIG_fail;
9295 if (arg2 == NULL) {
9296 SWIG_null_ref("wxFileSystem");
9297 }
9298 if (SWIG_arg_fail(2)) SWIG_fail;
9299 }
9300 {
9301 arg3 = wxString_in_helper(obj2);
9302 if (arg3 == NULL) SWIG_fail;
9303 temp3 = true;
9304 }
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9308
9309 wxPyEndAllowThreads(__tstate);
9310 if (PyErr_Occurred()) SWIG_fail;
9311 }
9312 {
9313 resultobj = wxPyMake_wxObject(result, 1);
9314 }
9315 {
9316 if (temp3)
9317 delete arg3;
9318 }
9319 return resultobj;
9320 fail:
9321 {
9322 if (temp3)
9323 delete arg3;
9324 }
9325 return NULL;
9326 }
9327
9328
9329 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9330 PyObject *resultobj;
9331 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9332 wxString *arg2 = 0 ;
9333 int arg3 = (int) 0 ;
9334 wxString result;
9335 bool temp2 = false ;
9336 PyObject * obj0 = 0 ;
9337 PyObject * obj1 = 0 ;
9338 PyObject * obj2 = 0 ;
9339 char *kwnames[] = {
9340 (char *) "self",(char *) "spec",(char *) "flags", NULL
9341 };
9342
9343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9345 if (SWIG_arg_fail(1)) SWIG_fail;
9346 {
9347 arg2 = wxString_in_helper(obj1);
9348 if (arg2 == NULL) SWIG_fail;
9349 temp2 = true;
9350 }
9351 if (obj2) {
9352 {
9353 arg3 = (int)(SWIG_As_int(obj2));
9354 if (SWIG_arg_fail(3)) SWIG_fail;
9355 }
9356 }
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9360
9361 wxPyEndAllowThreads(__tstate);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 {
9365 #if wxUSE_UNICODE
9366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9367 #else
9368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9369 #endif
9370 }
9371 {
9372 if (temp2)
9373 delete arg2;
9374 }
9375 return resultobj;
9376 fail:
9377 {
9378 if (temp2)
9379 delete arg2;
9380 }
9381 return NULL;
9382 }
9383
9384
9385 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9386 PyObject *resultobj;
9387 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9388 wxString result;
9389 PyObject * obj0 = 0 ;
9390 char *kwnames[] = {
9391 (char *) "self", NULL
9392 };
9393
9394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9396 if (SWIG_arg_fail(1)) SWIG_fail;
9397 {
9398 PyThreadState* __tstate = wxPyBeginAllowThreads();
9399 result = (arg1)->FindNext();
9400
9401 wxPyEndAllowThreads(__tstate);
9402 if (PyErr_Occurred()) SWIG_fail;
9403 }
9404 {
9405 #if wxUSE_UNICODE
9406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9407 #else
9408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9409 #endif
9410 }
9411 return resultobj;
9412 fail:
9413 return NULL;
9414 }
9415
9416
9417 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9418 PyObject *obj;
9419 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9420 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9421 Py_INCREF(obj);
9422 return Py_BuildValue((char *)"");
9423 }
9424 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9425 PyObject *resultobj;
9426 wxString *arg1 = 0 ;
9427 wxImage *arg2 = 0 ;
9428 long arg3 ;
9429 bool temp1 = false ;
9430 PyObject * obj0 = 0 ;
9431 PyObject * obj1 = 0 ;
9432 PyObject * obj2 = 0 ;
9433 char *kwnames[] = {
9434 (char *) "filename",(char *) "image",(char *) "type", NULL
9435 };
9436
9437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9438 {
9439 arg1 = wxString_in_helper(obj0);
9440 if (arg1 == NULL) SWIG_fail;
9441 temp1 = true;
9442 }
9443 {
9444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9445 if (SWIG_arg_fail(2)) SWIG_fail;
9446 if (arg2 == NULL) {
9447 SWIG_null_ref("wxImage");
9448 }
9449 if (SWIG_arg_fail(2)) SWIG_fail;
9450 }
9451 {
9452 arg3 = (long)(SWIG_As_long(obj2));
9453 if (SWIG_arg_fail(3)) SWIG_fail;
9454 }
9455 {
9456 PyThreadState* __tstate = wxPyBeginAllowThreads();
9457 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9458
9459 wxPyEndAllowThreads(__tstate);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 Py_INCREF(Py_None); resultobj = Py_None;
9463 {
9464 if (temp1)
9465 delete arg1;
9466 }
9467 return resultobj;
9468 fail:
9469 {
9470 if (temp1)
9471 delete arg1;
9472 }
9473 return NULL;
9474 }
9475
9476
9477 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9478 PyObject *resultobj;
9479 wxString *arg1 = 0 ;
9480 wxBitmap *arg2 = 0 ;
9481 long arg3 ;
9482 bool temp1 = false ;
9483 PyObject * obj0 = 0 ;
9484 PyObject * obj1 = 0 ;
9485 PyObject * obj2 = 0 ;
9486 char *kwnames[] = {
9487 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9488 };
9489
9490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9491 {
9492 arg1 = wxString_in_helper(obj0);
9493 if (arg1 == NULL) SWIG_fail;
9494 temp1 = true;
9495 }
9496 {
9497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9498 if (SWIG_arg_fail(2)) SWIG_fail;
9499 if (arg2 == NULL) {
9500 SWIG_null_ref("wxBitmap");
9501 }
9502 if (SWIG_arg_fail(2)) SWIG_fail;
9503 }
9504 {
9505 arg3 = (long)(SWIG_As_long(obj2));
9506 if (SWIG_arg_fail(3)) SWIG_fail;
9507 }
9508 {
9509 PyThreadState* __tstate = wxPyBeginAllowThreads();
9510 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9511
9512 wxPyEndAllowThreads(__tstate);
9513 if (PyErr_Occurred()) SWIG_fail;
9514 }
9515 Py_INCREF(Py_None); resultobj = Py_None;
9516 {
9517 if (temp1)
9518 delete arg1;
9519 }
9520 return resultobj;
9521 fail:
9522 {
9523 if (temp1)
9524 delete arg1;
9525 }
9526 return NULL;
9527 }
9528
9529
9530 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9531 PyObject *resultobj;
9532 wxString *arg1 = 0 ;
9533 PyObject *arg2 = (PyObject *) 0 ;
9534 bool temp1 = false ;
9535 PyObject * obj0 = 0 ;
9536 PyObject * obj1 = 0 ;
9537 char *kwnames[] = {
9538 (char *) "filename",(char *) "data", NULL
9539 };
9540
9541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9542 {
9543 arg1 = wxString_in_helper(obj0);
9544 if (arg1 == NULL) SWIG_fail;
9545 temp1 = true;
9546 }
9547 arg2 = obj1;
9548 {
9549 PyThreadState* __tstate = wxPyBeginAllowThreads();
9550 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9551
9552 wxPyEndAllowThreads(__tstate);
9553 if (PyErr_Occurred()) SWIG_fail;
9554 }
9555 Py_INCREF(Py_None); resultobj = Py_None;
9556 {
9557 if (temp1)
9558 delete arg1;
9559 }
9560 return resultobj;
9561 fail:
9562 {
9563 if (temp1)
9564 delete arg1;
9565 }
9566 return NULL;
9567 }
9568
9569
9570 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9571 PyObject *resultobj;
9572 wxMemoryFSHandler *result;
9573 char *kwnames[] = {
9574 NULL
9575 };
9576
9577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9578 {
9579 PyThreadState* __tstate = wxPyBeginAllowThreads();
9580 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9581
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9586 return resultobj;
9587 fail:
9588 return NULL;
9589 }
9590
9591
9592 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9593 PyObject *resultobj;
9594 wxString *arg1 = 0 ;
9595 bool temp1 = false ;
9596 PyObject * obj0 = 0 ;
9597 char *kwnames[] = {
9598 (char *) "filename", NULL
9599 };
9600
9601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9602 {
9603 arg1 = wxString_in_helper(obj0);
9604 if (arg1 == NULL) SWIG_fail;
9605 temp1 = true;
9606 }
9607 {
9608 PyThreadState* __tstate = wxPyBeginAllowThreads();
9609 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9610
9611 wxPyEndAllowThreads(__tstate);
9612 if (PyErr_Occurred()) SWIG_fail;
9613 }
9614 Py_INCREF(Py_None); resultobj = Py_None;
9615 {
9616 if (temp1)
9617 delete arg1;
9618 }
9619 return resultobj;
9620 fail:
9621 {
9622 if (temp1)
9623 delete arg1;
9624 }
9625 return NULL;
9626 }
9627
9628
9629 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9630 PyObject *resultobj;
9631 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9632 wxString *arg2 = 0 ;
9633 bool result;
9634 bool temp2 = false ;
9635 PyObject * obj0 = 0 ;
9636 PyObject * obj1 = 0 ;
9637 char *kwnames[] = {
9638 (char *) "self",(char *) "location", NULL
9639 };
9640
9641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9643 if (SWIG_arg_fail(1)) SWIG_fail;
9644 {
9645 arg2 = wxString_in_helper(obj1);
9646 if (arg2 == NULL) SWIG_fail;
9647 temp2 = true;
9648 }
9649 {
9650 PyThreadState* __tstate = wxPyBeginAllowThreads();
9651 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9652
9653 wxPyEndAllowThreads(__tstate);
9654 if (PyErr_Occurred()) SWIG_fail;
9655 }
9656 {
9657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9658 }
9659 {
9660 if (temp2)
9661 delete arg2;
9662 }
9663 return resultobj;
9664 fail:
9665 {
9666 if (temp2)
9667 delete arg2;
9668 }
9669 return NULL;
9670 }
9671
9672
9673 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj;
9675 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9676 wxFileSystem *arg2 = 0 ;
9677 wxString *arg3 = 0 ;
9678 wxFSFile *result;
9679 bool temp3 = false ;
9680 PyObject * obj0 = 0 ;
9681 PyObject * obj1 = 0 ;
9682 PyObject * obj2 = 0 ;
9683 char *kwnames[] = {
9684 (char *) "self",(char *) "fs",(char *) "location", NULL
9685 };
9686
9687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9689 if (SWIG_arg_fail(1)) SWIG_fail;
9690 {
9691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9692 if (SWIG_arg_fail(2)) SWIG_fail;
9693 if (arg2 == NULL) {
9694 SWIG_null_ref("wxFileSystem");
9695 }
9696 if (SWIG_arg_fail(2)) SWIG_fail;
9697 }
9698 {
9699 arg3 = wxString_in_helper(obj2);
9700 if (arg3 == NULL) SWIG_fail;
9701 temp3 = true;
9702 }
9703 {
9704 PyThreadState* __tstate = wxPyBeginAllowThreads();
9705 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9706
9707 wxPyEndAllowThreads(__tstate);
9708 if (PyErr_Occurred()) SWIG_fail;
9709 }
9710 {
9711 resultobj = wxPyMake_wxObject(result, 1);
9712 }
9713 {
9714 if (temp3)
9715 delete arg3;
9716 }
9717 return resultobj;
9718 fail:
9719 {
9720 if (temp3)
9721 delete arg3;
9722 }
9723 return NULL;
9724 }
9725
9726
9727 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9728 PyObject *resultobj;
9729 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9730 wxString *arg2 = 0 ;
9731 int arg3 = (int) 0 ;
9732 wxString result;
9733 bool temp2 = false ;
9734 PyObject * obj0 = 0 ;
9735 PyObject * obj1 = 0 ;
9736 PyObject * obj2 = 0 ;
9737 char *kwnames[] = {
9738 (char *) "self",(char *) "spec",(char *) "flags", NULL
9739 };
9740
9741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9743 if (SWIG_arg_fail(1)) SWIG_fail;
9744 {
9745 arg2 = wxString_in_helper(obj1);
9746 if (arg2 == NULL) SWIG_fail;
9747 temp2 = true;
9748 }
9749 if (obj2) {
9750 {
9751 arg3 = (int)(SWIG_As_int(obj2));
9752 if (SWIG_arg_fail(3)) SWIG_fail;
9753 }
9754 }
9755 {
9756 PyThreadState* __tstate = wxPyBeginAllowThreads();
9757 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9758
9759 wxPyEndAllowThreads(__tstate);
9760 if (PyErr_Occurred()) SWIG_fail;
9761 }
9762 {
9763 #if wxUSE_UNICODE
9764 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9765 #else
9766 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9767 #endif
9768 }
9769 {
9770 if (temp2)
9771 delete arg2;
9772 }
9773 return resultobj;
9774 fail:
9775 {
9776 if (temp2)
9777 delete arg2;
9778 }
9779 return NULL;
9780 }
9781
9782
9783 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9784 PyObject *resultobj;
9785 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9786 wxString result;
9787 PyObject * obj0 = 0 ;
9788 char *kwnames[] = {
9789 (char *) "self", NULL
9790 };
9791
9792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9794 if (SWIG_arg_fail(1)) SWIG_fail;
9795 {
9796 PyThreadState* __tstate = wxPyBeginAllowThreads();
9797 result = (arg1)->FindNext();
9798
9799 wxPyEndAllowThreads(__tstate);
9800 if (PyErr_Occurred()) SWIG_fail;
9801 }
9802 {
9803 #if wxUSE_UNICODE
9804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9805 #else
9806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9807 #endif
9808 }
9809 return resultobj;
9810 fail:
9811 return NULL;
9812 }
9813
9814
9815 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9816 PyObject *obj;
9817 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9818 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9819 Py_INCREF(obj);
9820 return Py_BuildValue((char *)"");
9821 }
9822 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9823 PyObject *resultobj;
9824 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9825 wxString result;
9826 PyObject * obj0 = 0 ;
9827 char *kwnames[] = {
9828 (char *) "self", NULL
9829 };
9830
9831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9833 if (SWIG_arg_fail(1)) SWIG_fail;
9834 {
9835 PyThreadState* __tstate = wxPyBeginAllowThreads();
9836 result = (arg1)->GetName();
9837
9838 wxPyEndAllowThreads(__tstate);
9839 if (PyErr_Occurred()) SWIG_fail;
9840 }
9841 {
9842 #if wxUSE_UNICODE
9843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9844 #else
9845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9846 #endif
9847 }
9848 return resultobj;
9849 fail:
9850 return NULL;
9851 }
9852
9853
9854 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9855 PyObject *resultobj;
9856 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9857 wxString result;
9858 PyObject * obj0 = 0 ;
9859 char *kwnames[] = {
9860 (char *) "self", NULL
9861 };
9862
9863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9865 if (SWIG_arg_fail(1)) SWIG_fail;
9866 {
9867 PyThreadState* __tstate = wxPyBeginAllowThreads();
9868 result = (arg1)->GetExtension();
9869
9870 wxPyEndAllowThreads(__tstate);
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 {
9874 #if wxUSE_UNICODE
9875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9876 #else
9877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9878 #endif
9879 }
9880 return resultobj;
9881 fail:
9882 return NULL;
9883 }
9884
9885
9886 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9887 PyObject *resultobj;
9888 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9889 long result;
9890 PyObject * obj0 = 0 ;
9891 char *kwnames[] = {
9892 (char *) "self", NULL
9893 };
9894
9895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9897 if (SWIG_arg_fail(1)) SWIG_fail;
9898 {
9899 PyThreadState* __tstate = wxPyBeginAllowThreads();
9900 result = (long)(arg1)->GetType();
9901
9902 wxPyEndAllowThreads(__tstate);
9903 if (PyErr_Occurred()) SWIG_fail;
9904 }
9905 {
9906 resultobj = SWIG_From_long((long)(result));
9907 }
9908 return resultobj;
9909 fail:
9910 return NULL;
9911 }
9912
9913
9914 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9915 PyObject *resultobj;
9916 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9917 wxString result;
9918 PyObject * obj0 = 0 ;
9919 char *kwnames[] = {
9920 (char *) "self", NULL
9921 };
9922
9923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9925 if (SWIG_arg_fail(1)) SWIG_fail;
9926 {
9927 PyThreadState* __tstate = wxPyBeginAllowThreads();
9928 result = (arg1)->GetMimeType();
9929
9930 wxPyEndAllowThreads(__tstate);
9931 if (PyErr_Occurred()) SWIG_fail;
9932 }
9933 {
9934 #if wxUSE_UNICODE
9935 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9936 #else
9937 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9938 #endif
9939 }
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9947 PyObject *resultobj;
9948 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9949 wxString *arg2 = 0 ;
9950 bool result;
9951 bool temp2 = false ;
9952 PyObject * obj0 = 0 ;
9953 PyObject * obj1 = 0 ;
9954 char *kwnames[] = {
9955 (char *) "self",(char *) "name", NULL
9956 };
9957
9958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9960 if (SWIG_arg_fail(1)) SWIG_fail;
9961 {
9962 arg2 = wxString_in_helper(obj1);
9963 if (arg2 == NULL) SWIG_fail;
9964 temp2 = true;
9965 }
9966 {
9967 PyThreadState* __tstate = wxPyBeginAllowThreads();
9968 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9969
9970 wxPyEndAllowThreads(__tstate);
9971 if (PyErr_Occurred()) SWIG_fail;
9972 }
9973 {
9974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9975 }
9976 {
9977 if (temp2)
9978 delete arg2;
9979 }
9980 return resultobj;
9981 fail:
9982 {
9983 if (temp2)
9984 delete arg2;
9985 }
9986 return NULL;
9987 }
9988
9989
9990 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
9991 PyObject *resultobj;
9992 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9993 wxString *arg2 = 0 ;
9994 bool temp2 = false ;
9995 PyObject * obj0 = 0 ;
9996 PyObject * obj1 = 0 ;
9997 char *kwnames[] = {
9998 (char *) "self",(char *) "name", NULL
9999 };
10000
10001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10003 if (SWIG_arg_fail(1)) SWIG_fail;
10004 {
10005 arg2 = wxString_in_helper(obj1);
10006 if (arg2 == NULL) SWIG_fail;
10007 temp2 = true;
10008 }
10009 {
10010 PyThreadState* __tstate = wxPyBeginAllowThreads();
10011 (arg1)->SetName((wxString const &)*arg2);
10012
10013 wxPyEndAllowThreads(__tstate);
10014 if (PyErr_Occurred()) SWIG_fail;
10015 }
10016 Py_INCREF(Py_None); resultobj = Py_None;
10017 {
10018 if (temp2)
10019 delete arg2;
10020 }
10021 return resultobj;
10022 fail:
10023 {
10024 if (temp2)
10025 delete arg2;
10026 }
10027 return NULL;
10028 }
10029
10030
10031 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10032 PyObject *resultobj;
10033 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10034 wxString *arg2 = 0 ;
10035 bool temp2 = false ;
10036 PyObject * obj0 = 0 ;
10037 PyObject * obj1 = 0 ;
10038 char *kwnames[] = {
10039 (char *) "self",(char *) "extension", NULL
10040 };
10041
10042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10044 if (SWIG_arg_fail(1)) SWIG_fail;
10045 {
10046 arg2 = wxString_in_helper(obj1);
10047 if (arg2 == NULL) SWIG_fail;
10048 temp2 = true;
10049 }
10050 {
10051 PyThreadState* __tstate = wxPyBeginAllowThreads();
10052 (arg1)->SetExtension((wxString const &)*arg2);
10053
10054 wxPyEndAllowThreads(__tstate);
10055 if (PyErr_Occurred()) SWIG_fail;
10056 }
10057 Py_INCREF(Py_None); resultobj = Py_None;
10058 {
10059 if (temp2)
10060 delete arg2;
10061 }
10062 return resultobj;
10063 fail:
10064 {
10065 if (temp2)
10066 delete arg2;
10067 }
10068 return NULL;
10069 }
10070
10071
10072 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10073 PyObject *resultobj;
10074 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10075 long arg2 ;
10076 PyObject * obj0 = 0 ;
10077 PyObject * obj1 = 0 ;
10078 char *kwnames[] = {
10079 (char *) "self",(char *) "type", NULL
10080 };
10081
10082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10084 if (SWIG_arg_fail(1)) SWIG_fail;
10085 {
10086 arg2 = (long)(SWIG_As_long(obj1));
10087 if (SWIG_arg_fail(2)) SWIG_fail;
10088 }
10089 {
10090 PyThreadState* __tstate = wxPyBeginAllowThreads();
10091 (arg1)->SetType(arg2);
10092
10093 wxPyEndAllowThreads(__tstate);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 Py_INCREF(Py_None); resultobj = Py_None;
10097 return resultobj;
10098 fail:
10099 return NULL;
10100 }
10101
10102
10103 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj;
10105 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10106 wxString *arg2 = 0 ;
10107 bool temp2 = false ;
10108 PyObject * obj0 = 0 ;
10109 PyObject * obj1 = 0 ;
10110 char *kwnames[] = {
10111 (char *) "self",(char *) "mimetype", NULL
10112 };
10113
10114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10116 if (SWIG_arg_fail(1)) SWIG_fail;
10117 {
10118 arg2 = wxString_in_helper(obj1);
10119 if (arg2 == NULL) SWIG_fail;
10120 temp2 = true;
10121 }
10122 {
10123 PyThreadState* __tstate = wxPyBeginAllowThreads();
10124 (arg1)->SetMimeType((wxString const &)*arg2);
10125
10126 wxPyEndAllowThreads(__tstate);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 Py_INCREF(Py_None); resultobj = Py_None;
10130 {
10131 if (temp2)
10132 delete arg2;
10133 }
10134 return resultobj;
10135 fail:
10136 {
10137 if (temp2)
10138 delete arg2;
10139 }
10140 return NULL;
10141 }
10142
10143
10144 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10145 PyObject *obj;
10146 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10147 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10148 Py_INCREF(obj);
10149 return Py_BuildValue((char *)"");
10150 }
10151 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10152 PyObject *resultobj;
10153 wxImageHistogram *result;
10154 char *kwnames[] = {
10155 NULL
10156 };
10157
10158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 result = (wxImageHistogram *)new wxImageHistogram();
10162
10163 wxPyEndAllowThreads(__tstate);
10164 if (PyErr_Occurred()) SWIG_fail;
10165 }
10166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10167 return resultobj;
10168 fail:
10169 return NULL;
10170 }
10171
10172
10173 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10174 PyObject *resultobj;
10175 unsigned char arg1 ;
10176 unsigned char arg2 ;
10177 unsigned char arg3 ;
10178 unsigned long result;
10179 PyObject * obj0 = 0 ;
10180 PyObject * obj1 = 0 ;
10181 PyObject * obj2 = 0 ;
10182 char *kwnames[] = {
10183 (char *) "r",(char *) "g",(char *) "b", NULL
10184 };
10185
10186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10187 {
10188 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10189 if (SWIG_arg_fail(1)) SWIG_fail;
10190 }
10191 {
10192 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10193 if (SWIG_arg_fail(2)) SWIG_fail;
10194 }
10195 {
10196 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10197 if (SWIG_arg_fail(3)) SWIG_fail;
10198 }
10199 {
10200 PyThreadState* __tstate = wxPyBeginAllowThreads();
10201 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10202
10203 wxPyEndAllowThreads(__tstate);
10204 if (PyErr_Occurred()) SWIG_fail;
10205 }
10206 {
10207 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10208 }
10209 return resultobj;
10210 fail:
10211 return NULL;
10212 }
10213
10214
10215 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10216 PyObject *resultobj;
10217 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10218 unsigned char *arg2 = (unsigned char *) 0 ;
10219 unsigned char *arg3 = (unsigned char *) 0 ;
10220 unsigned char *arg4 = (unsigned char *) 0 ;
10221 unsigned char arg5 = (unsigned char) 1 ;
10222 unsigned char arg6 = (unsigned char) 0 ;
10223 unsigned char arg7 = (unsigned char) 0 ;
10224 bool result;
10225 unsigned char temp2 ;
10226 int res2 = 0 ;
10227 unsigned char temp3 ;
10228 int res3 = 0 ;
10229 unsigned char temp4 ;
10230 int res4 = 0 ;
10231 PyObject * obj0 = 0 ;
10232 PyObject * obj1 = 0 ;
10233 PyObject * obj2 = 0 ;
10234 PyObject * obj3 = 0 ;
10235 char *kwnames[] = {
10236 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10237 };
10238
10239 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10240 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10241 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10244 if (SWIG_arg_fail(1)) SWIG_fail;
10245 if (obj1) {
10246 {
10247 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10248 if (SWIG_arg_fail(5)) SWIG_fail;
10249 }
10250 }
10251 if (obj2) {
10252 {
10253 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10254 if (SWIG_arg_fail(6)) SWIG_fail;
10255 }
10256 }
10257 if (obj3) {
10258 {
10259 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10260 if (SWIG_arg_fail(7)) SWIG_fail;
10261 }
10262 }
10263 {
10264 PyThreadState* __tstate = wxPyBeginAllowThreads();
10265 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10266
10267 wxPyEndAllowThreads(__tstate);
10268 if (PyErr_Occurred()) SWIG_fail;
10269 }
10270 {
10271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10272 }
10273 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10274 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10275 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10276 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10277 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10278 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10279 return resultobj;
10280 fail:
10281 return NULL;
10282 }
10283
10284
10285 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10286 PyObject *obj;
10287 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10288 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10289 Py_INCREF(obj);
10290 return Py_BuildValue((char *)"");
10291 }
10292 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10293 PyObject *resultobj;
10294 wxString *arg1 = 0 ;
10295 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10296 int arg3 = (int) -1 ;
10297 wxImage *result;
10298 bool temp1 = false ;
10299 PyObject * obj0 = 0 ;
10300 PyObject * obj1 = 0 ;
10301 PyObject * obj2 = 0 ;
10302 char *kwnames[] = {
10303 (char *) "name",(char *) "type",(char *) "index", NULL
10304 };
10305
10306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10307 {
10308 arg1 = wxString_in_helper(obj0);
10309 if (arg1 == NULL) SWIG_fail;
10310 temp1 = true;
10311 }
10312 if (obj1) {
10313 {
10314 arg2 = (long)(SWIG_As_long(obj1));
10315 if (SWIG_arg_fail(2)) SWIG_fail;
10316 }
10317 }
10318 if (obj2) {
10319 {
10320 arg3 = (int)(SWIG_As_int(obj2));
10321 if (SWIG_arg_fail(3)) SWIG_fail;
10322 }
10323 }
10324 {
10325 PyThreadState* __tstate = wxPyBeginAllowThreads();
10326 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10327
10328 wxPyEndAllowThreads(__tstate);
10329 if (PyErr_Occurred()) SWIG_fail;
10330 }
10331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10332 {
10333 if (temp1)
10334 delete arg1;
10335 }
10336 return resultobj;
10337 fail:
10338 {
10339 if (temp1)
10340 delete arg1;
10341 }
10342 return NULL;
10343 }
10344
10345
10346 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10347 PyObject *resultobj;
10348 wxImage *arg1 = (wxImage *) 0 ;
10349 PyObject * obj0 = 0 ;
10350 char *kwnames[] = {
10351 (char *) "self", NULL
10352 };
10353
10354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10356 if (SWIG_arg_fail(1)) SWIG_fail;
10357 {
10358 PyThreadState* __tstate = wxPyBeginAllowThreads();
10359 delete arg1;
10360
10361 wxPyEndAllowThreads(__tstate);
10362 if (PyErr_Occurred()) SWIG_fail;
10363 }
10364 Py_INCREF(Py_None); resultobj = Py_None;
10365 return resultobj;
10366 fail:
10367 return NULL;
10368 }
10369
10370
10371 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10372 PyObject *resultobj;
10373 wxString *arg1 = 0 ;
10374 wxString *arg2 = 0 ;
10375 int arg3 = (int) -1 ;
10376 wxImage *result;
10377 bool temp1 = false ;
10378 bool temp2 = false ;
10379 PyObject * obj0 = 0 ;
10380 PyObject * obj1 = 0 ;
10381 PyObject * obj2 = 0 ;
10382 char *kwnames[] = {
10383 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10384 };
10385
10386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10387 {
10388 arg1 = wxString_in_helper(obj0);
10389 if (arg1 == NULL) SWIG_fail;
10390 temp1 = true;
10391 }
10392 {
10393 arg2 = wxString_in_helper(obj1);
10394 if (arg2 == NULL) SWIG_fail;
10395 temp2 = true;
10396 }
10397 if (obj2) {
10398 {
10399 arg3 = (int)(SWIG_As_int(obj2));
10400 if (SWIG_arg_fail(3)) SWIG_fail;
10401 }
10402 }
10403 {
10404 PyThreadState* __tstate = wxPyBeginAllowThreads();
10405 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10406
10407 wxPyEndAllowThreads(__tstate);
10408 if (PyErr_Occurred()) SWIG_fail;
10409 }
10410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10411 {
10412 if (temp1)
10413 delete arg1;
10414 }
10415 {
10416 if (temp2)
10417 delete arg2;
10418 }
10419 return resultobj;
10420 fail:
10421 {
10422 if (temp1)
10423 delete arg1;
10424 }
10425 {
10426 if (temp2)
10427 delete arg2;
10428 }
10429 return NULL;
10430 }
10431
10432
10433 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10434 PyObject *resultobj;
10435 wxInputStream *arg1 = 0 ;
10436 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10437 int arg3 = (int) -1 ;
10438 wxImage *result;
10439 wxPyInputStream *temp1 ;
10440 bool created1 ;
10441 PyObject * obj0 = 0 ;
10442 PyObject * obj1 = 0 ;
10443 PyObject * obj2 = 0 ;
10444 char *kwnames[] = {
10445 (char *) "stream",(char *) "type",(char *) "index", NULL
10446 };
10447
10448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10449 {
10450 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10451 arg1 = temp1->m_wxis;
10452 created1 = false;
10453 } else {
10454 PyErr_Clear(); // clear the failure of the wxPyConvert above
10455 arg1 = wxPyCBInputStream_create(obj0, false);
10456 if (arg1 == NULL) {
10457 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10458 SWIG_fail;
10459 }
10460 created1 = true;
10461 }
10462 }
10463 if (obj1) {
10464 {
10465 arg2 = (long)(SWIG_As_long(obj1));
10466 if (SWIG_arg_fail(2)) SWIG_fail;
10467 }
10468 }
10469 if (obj2) {
10470 {
10471 arg3 = (int)(SWIG_As_int(obj2));
10472 if (SWIG_arg_fail(3)) SWIG_fail;
10473 }
10474 }
10475 {
10476 PyThreadState* __tstate = wxPyBeginAllowThreads();
10477 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10478
10479 wxPyEndAllowThreads(__tstate);
10480 if (PyErr_Occurred()) SWIG_fail;
10481 }
10482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10483 {
10484 if (created1)
10485 delete arg1;
10486 }
10487 return resultobj;
10488 fail:
10489 {
10490 if (created1)
10491 delete arg1;
10492 }
10493 return NULL;
10494 }
10495
10496
10497 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10498 PyObject *resultobj;
10499 wxInputStream *arg1 = 0 ;
10500 wxString *arg2 = 0 ;
10501 int arg3 = (int) -1 ;
10502 wxImage *result;
10503 wxPyInputStream *temp1 ;
10504 bool created1 ;
10505 bool temp2 = false ;
10506 PyObject * obj0 = 0 ;
10507 PyObject * obj1 = 0 ;
10508 PyObject * obj2 = 0 ;
10509 char *kwnames[] = {
10510 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10511 };
10512
10513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10514 {
10515 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10516 arg1 = temp1->m_wxis;
10517 created1 = false;
10518 } else {
10519 PyErr_Clear(); // clear the failure of the wxPyConvert above
10520 arg1 = wxPyCBInputStream_create(obj0, false);
10521 if (arg1 == NULL) {
10522 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10523 SWIG_fail;
10524 }
10525 created1 = true;
10526 }
10527 }
10528 {
10529 arg2 = wxString_in_helper(obj1);
10530 if (arg2 == NULL) SWIG_fail;
10531 temp2 = true;
10532 }
10533 if (obj2) {
10534 {
10535 arg3 = (int)(SWIG_As_int(obj2));
10536 if (SWIG_arg_fail(3)) SWIG_fail;
10537 }
10538 }
10539 {
10540 PyThreadState* __tstate = wxPyBeginAllowThreads();
10541 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10542
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10547 {
10548 if (created1)
10549 delete arg1;
10550 }
10551 {
10552 if (temp2)
10553 delete arg2;
10554 }
10555 return resultobj;
10556 fail:
10557 {
10558 if (created1)
10559 delete arg1;
10560 }
10561 {
10562 if (temp2)
10563 delete arg2;
10564 }
10565 return NULL;
10566 }
10567
10568
10569 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10570 PyObject *resultobj;
10571 int arg1 = (int) 0 ;
10572 int arg2 = (int) 0 ;
10573 bool arg3 = (bool) true ;
10574 wxImage *result;
10575 PyObject * obj0 = 0 ;
10576 PyObject * obj1 = 0 ;
10577 PyObject * obj2 = 0 ;
10578 char *kwnames[] = {
10579 (char *) "width",(char *) "height",(char *) "clear", NULL
10580 };
10581
10582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10583 if (obj0) {
10584 {
10585 arg1 = (int)(SWIG_As_int(obj0));
10586 if (SWIG_arg_fail(1)) SWIG_fail;
10587 }
10588 }
10589 if (obj1) {
10590 {
10591 arg2 = (int)(SWIG_As_int(obj1));
10592 if (SWIG_arg_fail(2)) SWIG_fail;
10593 }
10594 }
10595 if (obj2) {
10596 {
10597 arg3 = (bool)(SWIG_As_bool(obj2));
10598 if (SWIG_arg_fail(3)) SWIG_fail;
10599 }
10600 }
10601 {
10602 PyThreadState* __tstate = wxPyBeginAllowThreads();
10603 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10604
10605 wxPyEndAllowThreads(__tstate);
10606 if (PyErr_Occurred()) SWIG_fail;
10607 }
10608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10609 return resultobj;
10610 fail:
10611 return NULL;
10612 }
10613
10614
10615 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10616 PyObject *resultobj;
10617 wxBitmap *arg1 = 0 ;
10618 wxImage *result;
10619 PyObject * obj0 = 0 ;
10620 char *kwnames[] = {
10621 (char *) "bitmap", NULL
10622 };
10623
10624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10625 {
10626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10627 if (SWIG_arg_fail(1)) SWIG_fail;
10628 if (arg1 == NULL) {
10629 SWIG_null_ref("wxBitmap");
10630 }
10631 if (SWIG_arg_fail(1)) SWIG_fail;
10632 }
10633 {
10634 if (!wxPyCheckForApp()) SWIG_fail;
10635 PyThreadState* __tstate = wxPyBeginAllowThreads();
10636 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10637
10638 wxPyEndAllowThreads(__tstate);
10639 if (PyErr_Occurred()) SWIG_fail;
10640 }
10641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10642 return resultobj;
10643 fail:
10644 return NULL;
10645 }
10646
10647
10648 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10649 PyObject *resultobj;
10650 int arg1 ;
10651 int arg2 ;
10652 unsigned char *arg3 = (unsigned char *) 0 ;
10653 wxImage *result;
10654 PyObject * obj0 = 0 ;
10655 PyObject * obj1 = 0 ;
10656 PyObject * obj2 = 0 ;
10657 char *kwnames[] = {
10658 (char *) "width",(char *) "height",(char *) "data", NULL
10659 };
10660
10661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10662 {
10663 arg1 = (int)(SWIG_As_int(obj0));
10664 if (SWIG_arg_fail(1)) SWIG_fail;
10665 }
10666 {
10667 arg2 = (int)(SWIG_As_int(obj1));
10668 if (SWIG_arg_fail(2)) SWIG_fail;
10669 }
10670 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10671 if (SWIG_arg_fail(3)) SWIG_fail;
10672 {
10673 PyThreadState* __tstate = wxPyBeginAllowThreads();
10674 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10675
10676 wxPyEndAllowThreads(__tstate);
10677 if (PyErr_Occurred()) SWIG_fail;
10678 }
10679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10680 return resultobj;
10681 fail:
10682 return NULL;
10683 }
10684
10685
10686 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10687 PyObject *resultobj;
10688 int arg1 ;
10689 int arg2 ;
10690 unsigned char *arg3 = (unsigned char *) 0 ;
10691 unsigned char *arg4 = (unsigned char *) 0 ;
10692 wxImage *result;
10693 PyObject * obj0 = 0 ;
10694 PyObject * obj1 = 0 ;
10695 PyObject * obj2 = 0 ;
10696 PyObject * obj3 = 0 ;
10697 char *kwnames[] = {
10698 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10699 };
10700
10701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10702 {
10703 arg1 = (int)(SWIG_As_int(obj0));
10704 if (SWIG_arg_fail(1)) SWIG_fail;
10705 }
10706 {
10707 arg2 = (int)(SWIG_As_int(obj1));
10708 if (SWIG_arg_fail(2)) SWIG_fail;
10709 }
10710 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10711 if (SWIG_arg_fail(3)) SWIG_fail;
10712 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10713 if (SWIG_arg_fail(4)) SWIG_fail;
10714 {
10715 PyThreadState* __tstate = wxPyBeginAllowThreads();
10716 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10717
10718 wxPyEndAllowThreads(__tstate);
10719 if (PyErr_Occurred()) SWIG_fail;
10720 }
10721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10722 return resultobj;
10723 fail:
10724 return NULL;
10725 }
10726
10727
10728 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10729 PyObject *resultobj;
10730 wxImage *arg1 = (wxImage *) 0 ;
10731 int arg2 ;
10732 int arg3 ;
10733 PyObject * obj0 = 0 ;
10734 PyObject * obj1 = 0 ;
10735 PyObject * obj2 = 0 ;
10736 char *kwnames[] = {
10737 (char *) "self",(char *) "width",(char *) "height", NULL
10738 };
10739
10740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10742 if (SWIG_arg_fail(1)) SWIG_fail;
10743 {
10744 arg2 = (int)(SWIG_As_int(obj1));
10745 if (SWIG_arg_fail(2)) SWIG_fail;
10746 }
10747 {
10748 arg3 = (int)(SWIG_As_int(obj2));
10749 if (SWIG_arg_fail(3)) SWIG_fail;
10750 }
10751 {
10752 PyThreadState* __tstate = wxPyBeginAllowThreads();
10753 (arg1)->Create(arg2,arg3);
10754
10755 wxPyEndAllowThreads(__tstate);
10756 if (PyErr_Occurred()) SWIG_fail;
10757 }
10758 Py_INCREF(Py_None); resultobj = Py_None;
10759 return resultobj;
10760 fail:
10761 return NULL;
10762 }
10763
10764
10765 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10766 PyObject *resultobj;
10767 wxImage *arg1 = (wxImage *) 0 ;
10768 PyObject * obj0 = 0 ;
10769 char *kwnames[] = {
10770 (char *) "self", NULL
10771 };
10772
10773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10775 if (SWIG_arg_fail(1)) SWIG_fail;
10776 {
10777 PyThreadState* __tstate = wxPyBeginAllowThreads();
10778 (arg1)->Destroy();
10779
10780 wxPyEndAllowThreads(__tstate);
10781 if (PyErr_Occurred()) SWIG_fail;
10782 }
10783 Py_INCREF(Py_None); resultobj = Py_None;
10784 return resultobj;
10785 fail:
10786 return NULL;
10787 }
10788
10789
10790 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10791 PyObject *resultobj;
10792 wxImage *arg1 = (wxImage *) 0 ;
10793 int arg2 ;
10794 int arg3 ;
10795 SwigValueWrapper<wxImage > result;
10796 PyObject * obj0 = 0 ;
10797 PyObject * obj1 = 0 ;
10798 PyObject * obj2 = 0 ;
10799 char *kwnames[] = {
10800 (char *) "self",(char *) "width",(char *) "height", NULL
10801 };
10802
10803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10805 if (SWIG_arg_fail(1)) SWIG_fail;
10806 {
10807 arg2 = (int)(SWIG_As_int(obj1));
10808 if (SWIG_arg_fail(2)) SWIG_fail;
10809 }
10810 {
10811 arg3 = (int)(SWIG_As_int(obj2));
10812 if (SWIG_arg_fail(3)) SWIG_fail;
10813 }
10814 {
10815 PyThreadState* __tstate = wxPyBeginAllowThreads();
10816 result = (arg1)->Scale(arg2,arg3);
10817
10818 wxPyEndAllowThreads(__tstate);
10819 if (PyErr_Occurred()) SWIG_fail;
10820 }
10821 {
10822 wxImage * resultptr;
10823 resultptr = new wxImage((wxImage &)(result));
10824 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10825 }
10826 return resultobj;
10827 fail:
10828 return NULL;
10829 }
10830
10831
10832 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10833 PyObject *resultobj;
10834 wxImage *arg1 = (wxImage *) 0 ;
10835 int arg2 ;
10836 int arg3 ;
10837 SwigValueWrapper<wxImage > result;
10838 PyObject * obj0 = 0 ;
10839 PyObject * obj1 = 0 ;
10840 PyObject * obj2 = 0 ;
10841 char *kwnames[] = {
10842 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10843 };
10844
10845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10847 if (SWIG_arg_fail(1)) SWIG_fail;
10848 {
10849 arg2 = (int)(SWIG_As_int(obj1));
10850 if (SWIG_arg_fail(2)) SWIG_fail;
10851 }
10852 {
10853 arg3 = (int)(SWIG_As_int(obj2));
10854 if (SWIG_arg_fail(3)) SWIG_fail;
10855 }
10856 {
10857 PyThreadState* __tstate = wxPyBeginAllowThreads();
10858 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10859
10860 wxPyEndAllowThreads(__tstate);
10861 if (PyErr_Occurred()) SWIG_fail;
10862 }
10863 {
10864 wxImage * resultptr;
10865 resultptr = new wxImage((wxImage &)(result));
10866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10867 }
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj;
10876 wxImage *arg1 = (wxImage *) 0 ;
10877 int arg2 ;
10878 int arg3 ;
10879 wxImage *result;
10880 PyObject * obj0 = 0 ;
10881 PyObject * obj1 = 0 ;
10882 PyObject * obj2 = 0 ;
10883 char *kwnames[] = {
10884 (char *) "self",(char *) "width",(char *) "height", NULL
10885 };
10886
10887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10889 if (SWIG_arg_fail(1)) SWIG_fail;
10890 {
10891 arg2 = (int)(SWIG_As_int(obj1));
10892 if (SWIG_arg_fail(2)) SWIG_fail;
10893 }
10894 {
10895 arg3 = (int)(SWIG_As_int(obj2));
10896 if (SWIG_arg_fail(3)) SWIG_fail;
10897 }
10898 {
10899 PyThreadState* __tstate = wxPyBeginAllowThreads();
10900 {
10901 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10902 result = (wxImage *) &_result_ref;
10903 }
10904
10905 wxPyEndAllowThreads(__tstate);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10909 return resultobj;
10910 fail:
10911 return NULL;
10912 }
10913
10914
10915 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10916 PyObject *resultobj;
10917 wxImage *arg1 = (wxImage *) 0 ;
10918 int arg2 ;
10919 int arg3 ;
10920 unsigned char arg4 ;
10921 unsigned char arg5 ;
10922 unsigned char arg6 ;
10923 PyObject * obj0 = 0 ;
10924 PyObject * obj1 = 0 ;
10925 PyObject * obj2 = 0 ;
10926 PyObject * obj3 = 0 ;
10927 PyObject * obj4 = 0 ;
10928 PyObject * obj5 = 0 ;
10929 char *kwnames[] = {
10930 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10931 };
10932
10933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10935 if (SWIG_arg_fail(1)) SWIG_fail;
10936 {
10937 arg2 = (int)(SWIG_As_int(obj1));
10938 if (SWIG_arg_fail(2)) SWIG_fail;
10939 }
10940 {
10941 arg3 = (int)(SWIG_As_int(obj2));
10942 if (SWIG_arg_fail(3)) SWIG_fail;
10943 }
10944 {
10945 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10946 if (SWIG_arg_fail(4)) SWIG_fail;
10947 }
10948 {
10949 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10950 if (SWIG_arg_fail(5)) SWIG_fail;
10951 }
10952 {
10953 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10954 if (SWIG_arg_fail(6)) SWIG_fail;
10955 }
10956 {
10957 PyThreadState* __tstate = wxPyBeginAllowThreads();
10958 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10959
10960 wxPyEndAllowThreads(__tstate);
10961 if (PyErr_Occurred()) SWIG_fail;
10962 }
10963 Py_INCREF(Py_None); resultobj = Py_None;
10964 return resultobj;
10965 fail:
10966 return NULL;
10967 }
10968
10969
10970 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10971 PyObject *resultobj;
10972 wxImage *arg1 = (wxImage *) 0 ;
10973 int arg2 ;
10974 int arg3 ;
10975 unsigned char result;
10976 PyObject * obj0 = 0 ;
10977 PyObject * obj1 = 0 ;
10978 PyObject * obj2 = 0 ;
10979 char *kwnames[] = {
10980 (char *) "self",(char *) "x",(char *) "y", NULL
10981 };
10982
10983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10985 if (SWIG_arg_fail(1)) SWIG_fail;
10986 {
10987 arg2 = (int)(SWIG_As_int(obj1));
10988 if (SWIG_arg_fail(2)) SWIG_fail;
10989 }
10990 {
10991 arg3 = (int)(SWIG_As_int(obj2));
10992 if (SWIG_arg_fail(3)) SWIG_fail;
10993 }
10994 {
10995 PyThreadState* __tstate = wxPyBeginAllowThreads();
10996 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
10997
10998 wxPyEndAllowThreads(__tstate);
10999 if (PyErr_Occurred()) SWIG_fail;
11000 }
11001 {
11002 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11003 }
11004 return resultobj;
11005 fail:
11006 return NULL;
11007 }
11008
11009
11010 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11011 PyObject *resultobj;
11012 wxImage *arg1 = (wxImage *) 0 ;
11013 int arg2 ;
11014 int arg3 ;
11015 unsigned char result;
11016 PyObject * obj0 = 0 ;
11017 PyObject * obj1 = 0 ;
11018 PyObject * obj2 = 0 ;
11019 char *kwnames[] = {
11020 (char *) "self",(char *) "x",(char *) "y", NULL
11021 };
11022
11023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11025 if (SWIG_arg_fail(1)) SWIG_fail;
11026 {
11027 arg2 = (int)(SWIG_As_int(obj1));
11028 if (SWIG_arg_fail(2)) SWIG_fail;
11029 }
11030 {
11031 arg3 = (int)(SWIG_As_int(obj2));
11032 if (SWIG_arg_fail(3)) SWIG_fail;
11033 }
11034 {
11035 PyThreadState* __tstate = wxPyBeginAllowThreads();
11036 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11037
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 {
11042 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11043 }
11044 return resultobj;
11045 fail:
11046 return NULL;
11047 }
11048
11049
11050 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11051 PyObject *resultobj;
11052 wxImage *arg1 = (wxImage *) 0 ;
11053 int arg2 ;
11054 int arg3 ;
11055 unsigned char result;
11056 PyObject * obj0 = 0 ;
11057 PyObject * obj1 = 0 ;
11058 PyObject * obj2 = 0 ;
11059 char *kwnames[] = {
11060 (char *) "self",(char *) "x",(char *) "y", NULL
11061 };
11062
11063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11065 if (SWIG_arg_fail(1)) SWIG_fail;
11066 {
11067 arg2 = (int)(SWIG_As_int(obj1));
11068 if (SWIG_arg_fail(2)) SWIG_fail;
11069 }
11070 {
11071 arg3 = (int)(SWIG_As_int(obj2));
11072 if (SWIG_arg_fail(3)) SWIG_fail;
11073 }
11074 {
11075 PyThreadState* __tstate = wxPyBeginAllowThreads();
11076 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11077
11078 wxPyEndAllowThreads(__tstate);
11079 if (PyErr_Occurred()) SWIG_fail;
11080 }
11081 {
11082 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11083 }
11084 return resultobj;
11085 fail:
11086 return NULL;
11087 }
11088
11089
11090 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11091 PyObject *resultobj;
11092 wxImage *arg1 = (wxImage *) 0 ;
11093 int arg2 ;
11094 int arg3 ;
11095 unsigned char arg4 ;
11096 PyObject * obj0 = 0 ;
11097 PyObject * obj1 = 0 ;
11098 PyObject * obj2 = 0 ;
11099 PyObject * obj3 = 0 ;
11100 char *kwnames[] = {
11101 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11102 };
11103
11104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11106 if (SWIG_arg_fail(1)) SWIG_fail;
11107 {
11108 arg2 = (int)(SWIG_As_int(obj1));
11109 if (SWIG_arg_fail(2)) SWIG_fail;
11110 }
11111 {
11112 arg3 = (int)(SWIG_As_int(obj2));
11113 if (SWIG_arg_fail(3)) SWIG_fail;
11114 }
11115 {
11116 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11117 if (SWIG_arg_fail(4)) SWIG_fail;
11118 }
11119 {
11120 PyThreadState* __tstate = wxPyBeginAllowThreads();
11121 (arg1)->SetAlpha(arg2,arg3,arg4);
11122
11123 wxPyEndAllowThreads(__tstate);
11124 if (PyErr_Occurred()) SWIG_fail;
11125 }
11126 Py_INCREF(Py_None); resultobj = Py_None;
11127 return resultobj;
11128 fail:
11129 return NULL;
11130 }
11131
11132
11133 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11134 PyObject *resultobj;
11135 wxImage *arg1 = (wxImage *) 0 ;
11136 int arg2 ;
11137 int arg3 ;
11138 unsigned char result;
11139 PyObject * obj0 = 0 ;
11140 PyObject * obj1 = 0 ;
11141 PyObject * obj2 = 0 ;
11142 char *kwnames[] = {
11143 (char *) "self",(char *) "x",(char *) "y", NULL
11144 };
11145
11146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11148 if (SWIG_arg_fail(1)) SWIG_fail;
11149 {
11150 arg2 = (int)(SWIG_As_int(obj1));
11151 if (SWIG_arg_fail(2)) SWIG_fail;
11152 }
11153 {
11154 arg3 = (int)(SWIG_As_int(obj2));
11155 if (SWIG_arg_fail(3)) SWIG_fail;
11156 }
11157 {
11158 PyThreadState* __tstate = wxPyBeginAllowThreads();
11159 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11160
11161 wxPyEndAllowThreads(__tstate);
11162 if (PyErr_Occurred()) SWIG_fail;
11163 }
11164 {
11165 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11166 }
11167 return resultobj;
11168 fail:
11169 return NULL;
11170 }
11171
11172
11173 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11174 PyObject *resultobj;
11175 wxImage *arg1 = (wxImage *) 0 ;
11176 bool result;
11177 PyObject * obj0 = 0 ;
11178 char *kwnames[] = {
11179 (char *) "self", NULL
11180 };
11181
11182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11184 if (SWIG_arg_fail(1)) SWIG_fail;
11185 {
11186 PyThreadState* __tstate = wxPyBeginAllowThreads();
11187 result = (bool)(arg1)->HasAlpha();
11188
11189 wxPyEndAllowThreads(__tstate);
11190 if (PyErr_Occurred()) SWIG_fail;
11191 }
11192 {
11193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11194 }
11195 return resultobj;
11196 fail:
11197 return NULL;
11198 }
11199
11200
11201 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11202 PyObject *resultobj;
11203 wxImage *arg1 = (wxImage *) 0 ;
11204 byte *arg2 = (byte *) 0 ;
11205 byte *arg3 = (byte *) 0 ;
11206 byte *arg4 = (byte *) 0 ;
11207 byte arg5 = (byte) 0 ;
11208 byte arg6 = (byte) 0 ;
11209 byte arg7 = (byte) 0 ;
11210 bool result;
11211 byte temp2 ;
11212 int res2 = 0 ;
11213 byte temp3 ;
11214 int res3 = 0 ;
11215 byte temp4 ;
11216 int res4 = 0 ;
11217 PyObject * obj0 = 0 ;
11218 PyObject * obj1 = 0 ;
11219 PyObject * obj2 = 0 ;
11220 PyObject * obj3 = 0 ;
11221 char *kwnames[] = {
11222 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11223 };
11224
11225 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11226 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11227 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11230 if (SWIG_arg_fail(1)) SWIG_fail;
11231 if (obj1) {
11232 {
11233 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11234 if (SWIG_arg_fail(5)) SWIG_fail;
11235 }
11236 }
11237 if (obj2) {
11238 {
11239 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11240 if (SWIG_arg_fail(6)) SWIG_fail;
11241 }
11242 }
11243 if (obj3) {
11244 {
11245 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11246 if (SWIG_arg_fail(7)) SWIG_fail;
11247 }
11248 }
11249 {
11250 PyThreadState* __tstate = wxPyBeginAllowThreads();
11251 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11252
11253 wxPyEndAllowThreads(__tstate);
11254 if (PyErr_Occurred()) SWIG_fail;
11255 }
11256 {
11257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11258 }
11259 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11260 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11261 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11262 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11263 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11264 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11265 return resultobj;
11266 fail:
11267 return NULL;
11268 }
11269
11270
11271 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11272 PyObject *resultobj;
11273 wxImage *arg1 = (wxImage *) 0 ;
11274 byte arg2 = (byte) 128 ;
11275 bool result;
11276 PyObject * obj0 = 0 ;
11277 PyObject * obj1 = 0 ;
11278 char *kwnames[] = {
11279 (char *) "self",(char *) "threshold", NULL
11280 };
11281
11282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11284 if (SWIG_arg_fail(1)) SWIG_fail;
11285 if (obj1) {
11286 {
11287 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11288 if (SWIG_arg_fail(2)) SWIG_fail;
11289 }
11290 }
11291 {
11292 PyThreadState* __tstate = wxPyBeginAllowThreads();
11293 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11294
11295 wxPyEndAllowThreads(__tstate);
11296 if (PyErr_Occurred()) SWIG_fail;
11297 }
11298 {
11299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11300 }
11301 return resultobj;
11302 fail:
11303 return NULL;
11304 }
11305
11306
11307 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11308 PyObject *resultobj;
11309 wxImage *arg1 = (wxImage *) 0 ;
11310 unsigned char arg2 ;
11311 unsigned char arg3 ;
11312 unsigned char arg4 ;
11313 bool result;
11314 PyObject * obj0 = 0 ;
11315 PyObject * obj1 = 0 ;
11316 PyObject * obj2 = 0 ;
11317 PyObject * obj3 = 0 ;
11318 char *kwnames[] = {
11319 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11320 };
11321
11322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11324 if (SWIG_arg_fail(1)) SWIG_fail;
11325 {
11326 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11327 if (SWIG_arg_fail(2)) SWIG_fail;
11328 }
11329 {
11330 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11331 if (SWIG_arg_fail(3)) SWIG_fail;
11332 }
11333 {
11334 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11335 if (SWIG_arg_fail(4)) SWIG_fail;
11336 }
11337 {
11338 PyThreadState* __tstate = wxPyBeginAllowThreads();
11339 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11340
11341 wxPyEndAllowThreads(__tstate);
11342 if (PyErr_Occurred()) SWIG_fail;
11343 }
11344 {
11345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11346 }
11347 return resultobj;
11348 fail:
11349 return NULL;
11350 }
11351
11352
11353 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11354 PyObject *resultobj;
11355 wxImage *arg1 = (wxImage *) 0 ;
11356 wxImage *arg2 = 0 ;
11357 byte arg3 ;
11358 byte arg4 ;
11359 byte arg5 ;
11360 bool result;
11361 PyObject * obj0 = 0 ;
11362 PyObject * obj1 = 0 ;
11363 PyObject * obj2 = 0 ;
11364 PyObject * obj3 = 0 ;
11365 PyObject * obj4 = 0 ;
11366 char *kwnames[] = {
11367 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11368 };
11369
11370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11372 if (SWIG_arg_fail(1)) SWIG_fail;
11373 {
11374 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11375 if (SWIG_arg_fail(2)) SWIG_fail;
11376 if (arg2 == NULL) {
11377 SWIG_null_ref("wxImage");
11378 }
11379 if (SWIG_arg_fail(2)) SWIG_fail;
11380 }
11381 {
11382 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11383 if (SWIG_arg_fail(3)) SWIG_fail;
11384 }
11385 {
11386 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11387 if (SWIG_arg_fail(4)) SWIG_fail;
11388 }
11389 {
11390 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11391 if (SWIG_arg_fail(5)) SWIG_fail;
11392 }
11393 {
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11396
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 {
11401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11402 }
11403 return resultobj;
11404 fail:
11405 return NULL;
11406 }
11407
11408
11409 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11410 PyObject *resultobj;
11411 wxString *arg1 = 0 ;
11412 bool result;
11413 bool temp1 = false ;
11414 PyObject * obj0 = 0 ;
11415 char *kwnames[] = {
11416 (char *) "name", NULL
11417 };
11418
11419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11420 {
11421 arg1 = wxString_in_helper(obj0);
11422 if (arg1 == NULL) SWIG_fail;
11423 temp1 = true;
11424 }
11425 {
11426 PyThreadState* __tstate = wxPyBeginAllowThreads();
11427 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11428
11429 wxPyEndAllowThreads(__tstate);
11430 if (PyErr_Occurred()) SWIG_fail;
11431 }
11432 {
11433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11434 }
11435 {
11436 if (temp1)
11437 delete arg1;
11438 }
11439 return resultobj;
11440 fail:
11441 {
11442 if (temp1)
11443 delete arg1;
11444 }
11445 return NULL;
11446 }
11447
11448
11449 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11450 PyObject *resultobj;
11451 wxString *arg1 = 0 ;
11452 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11453 int result;
11454 bool temp1 = false ;
11455 PyObject * obj0 = 0 ;
11456 PyObject * obj1 = 0 ;
11457 char *kwnames[] = {
11458 (char *) "name",(char *) "type", NULL
11459 };
11460
11461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11462 {
11463 arg1 = wxString_in_helper(obj0);
11464 if (arg1 == NULL) SWIG_fail;
11465 temp1 = true;
11466 }
11467 if (obj1) {
11468 {
11469 arg2 = (long)(SWIG_As_long(obj1));
11470 if (SWIG_arg_fail(2)) SWIG_fail;
11471 }
11472 }
11473 {
11474 PyThreadState* __tstate = wxPyBeginAllowThreads();
11475 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11476
11477 wxPyEndAllowThreads(__tstate);
11478 if (PyErr_Occurred()) SWIG_fail;
11479 }
11480 {
11481 resultobj = SWIG_From_int((int)(result));
11482 }
11483 {
11484 if (temp1)
11485 delete arg1;
11486 }
11487 return resultobj;
11488 fail:
11489 {
11490 if (temp1)
11491 delete arg1;
11492 }
11493 return NULL;
11494 }
11495
11496
11497 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11498 PyObject *resultobj;
11499 wxImage *arg1 = (wxImage *) 0 ;
11500 wxString *arg2 = 0 ;
11501 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11502 int arg4 = (int) -1 ;
11503 bool result;
11504 bool temp2 = false ;
11505 PyObject * obj0 = 0 ;
11506 PyObject * obj1 = 0 ;
11507 PyObject * obj2 = 0 ;
11508 PyObject * obj3 = 0 ;
11509 char *kwnames[] = {
11510 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11511 };
11512
11513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11515 if (SWIG_arg_fail(1)) SWIG_fail;
11516 {
11517 arg2 = wxString_in_helper(obj1);
11518 if (arg2 == NULL) SWIG_fail;
11519 temp2 = true;
11520 }
11521 if (obj2) {
11522 {
11523 arg3 = (long)(SWIG_As_long(obj2));
11524 if (SWIG_arg_fail(3)) SWIG_fail;
11525 }
11526 }
11527 if (obj3) {
11528 {
11529 arg4 = (int)(SWIG_As_int(obj3));
11530 if (SWIG_arg_fail(4)) SWIG_fail;
11531 }
11532 }
11533 {
11534 PyThreadState* __tstate = wxPyBeginAllowThreads();
11535 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11536
11537 wxPyEndAllowThreads(__tstate);
11538 if (PyErr_Occurred()) SWIG_fail;
11539 }
11540 {
11541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11542 }
11543 {
11544 if (temp2)
11545 delete arg2;
11546 }
11547 return resultobj;
11548 fail:
11549 {
11550 if (temp2)
11551 delete arg2;
11552 }
11553 return NULL;
11554 }
11555
11556
11557 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11558 PyObject *resultobj;
11559 wxImage *arg1 = (wxImage *) 0 ;
11560 wxString *arg2 = 0 ;
11561 wxString *arg3 = 0 ;
11562 int arg4 = (int) -1 ;
11563 bool result;
11564 bool temp2 = false ;
11565 bool temp3 = false ;
11566 PyObject * obj0 = 0 ;
11567 PyObject * obj1 = 0 ;
11568 PyObject * obj2 = 0 ;
11569 PyObject * obj3 = 0 ;
11570 char *kwnames[] = {
11571 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11572 };
11573
11574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11576 if (SWIG_arg_fail(1)) SWIG_fail;
11577 {
11578 arg2 = wxString_in_helper(obj1);
11579 if (arg2 == NULL) SWIG_fail;
11580 temp2 = true;
11581 }
11582 {
11583 arg3 = wxString_in_helper(obj2);
11584 if (arg3 == NULL) SWIG_fail;
11585 temp3 = true;
11586 }
11587 if (obj3) {
11588 {
11589 arg4 = (int)(SWIG_As_int(obj3));
11590 if (SWIG_arg_fail(4)) SWIG_fail;
11591 }
11592 }
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11596
11597 wxPyEndAllowThreads(__tstate);
11598 if (PyErr_Occurred()) SWIG_fail;
11599 }
11600 {
11601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11602 }
11603 {
11604 if (temp2)
11605 delete arg2;
11606 }
11607 {
11608 if (temp3)
11609 delete arg3;
11610 }
11611 return resultobj;
11612 fail:
11613 {
11614 if (temp2)
11615 delete arg2;
11616 }
11617 {
11618 if (temp3)
11619 delete arg3;
11620 }
11621 return NULL;
11622 }
11623
11624
11625 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11626 PyObject *resultobj;
11627 wxImage *arg1 = (wxImage *) 0 ;
11628 wxString *arg2 = 0 ;
11629 int arg3 ;
11630 bool result;
11631 bool temp2 = false ;
11632 PyObject * obj0 = 0 ;
11633 PyObject * obj1 = 0 ;
11634 PyObject * obj2 = 0 ;
11635 char *kwnames[] = {
11636 (char *) "self",(char *) "name",(char *) "type", NULL
11637 };
11638
11639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11641 if (SWIG_arg_fail(1)) SWIG_fail;
11642 {
11643 arg2 = wxString_in_helper(obj1);
11644 if (arg2 == NULL) SWIG_fail;
11645 temp2 = true;
11646 }
11647 {
11648 arg3 = (int)(SWIG_As_int(obj2));
11649 if (SWIG_arg_fail(3)) SWIG_fail;
11650 }
11651 {
11652 PyThreadState* __tstate = wxPyBeginAllowThreads();
11653 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11654
11655 wxPyEndAllowThreads(__tstate);
11656 if (PyErr_Occurred()) SWIG_fail;
11657 }
11658 {
11659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11660 }
11661 {
11662 if (temp2)
11663 delete arg2;
11664 }
11665 return resultobj;
11666 fail:
11667 {
11668 if (temp2)
11669 delete arg2;
11670 }
11671 return NULL;
11672 }
11673
11674
11675 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11676 PyObject *resultobj;
11677 wxImage *arg1 = (wxImage *) 0 ;
11678 wxString *arg2 = 0 ;
11679 wxString *arg3 = 0 ;
11680 bool result;
11681 bool temp2 = false ;
11682 bool temp3 = false ;
11683 PyObject * obj0 = 0 ;
11684 PyObject * obj1 = 0 ;
11685 PyObject * obj2 = 0 ;
11686 char *kwnames[] = {
11687 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11688 };
11689
11690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11692 if (SWIG_arg_fail(1)) SWIG_fail;
11693 {
11694 arg2 = wxString_in_helper(obj1);
11695 if (arg2 == NULL) SWIG_fail;
11696 temp2 = true;
11697 }
11698 {
11699 arg3 = wxString_in_helper(obj2);
11700 if (arg3 == NULL) SWIG_fail;
11701 temp3 = true;
11702 }
11703 {
11704 PyThreadState* __tstate = wxPyBeginAllowThreads();
11705 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11706
11707 wxPyEndAllowThreads(__tstate);
11708 if (PyErr_Occurred()) SWIG_fail;
11709 }
11710 {
11711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11712 }
11713 {
11714 if (temp2)
11715 delete arg2;
11716 }
11717 {
11718 if (temp3)
11719 delete arg3;
11720 }
11721 return resultobj;
11722 fail:
11723 {
11724 if (temp2)
11725 delete arg2;
11726 }
11727 {
11728 if (temp3)
11729 delete arg3;
11730 }
11731 return NULL;
11732 }
11733
11734
11735 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11736 PyObject *resultobj;
11737 wxInputStream *arg1 = 0 ;
11738 bool result;
11739 wxPyInputStream *temp1 ;
11740 bool created1 ;
11741 PyObject * obj0 = 0 ;
11742 char *kwnames[] = {
11743 (char *) "stream", NULL
11744 };
11745
11746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11747 {
11748 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11749 arg1 = temp1->m_wxis;
11750 created1 = false;
11751 } else {
11752 PyErr_Clear(); // clear the failure of the wxPyConvert above
11753 arg1 = wxPyCBInputStream_create(obj0, false);
11754 if (arg1 == NULL) {
11755 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11756 SWIG_fail;
11757 }
11758 created1 = true;
11759 }
11760 }
11761 {
11762 PyThreadState* __tstate = wxPyBeginAllowThreads();
11763 result = (bool)wxImage::CanRead(*arg1);
11764
11765 wxPyEndAllowThreads(__tstate);
11766 if (PyErr_Occurred()) SWIG_fail;
11767 }
11768 {
11769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11770 }
11771 {
11772 if (created1)
11773 delete arg1;
11774 }
11775 return resultobj;
11776 fail:
11777 {
11778 if (created1)
11779 delete arg1;
11780 }
11781 return NULL;
11782 }
11783
11784
11785 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11786 PyObject *resultobj;
11787 wxImage *arg1 = (wxImage *) 0 ;
11788 wxInputStream *arg2 = 0 ;
11789 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11790 int arg4 = (int) -1 ;
11791 bool result;
11792 wxPyInputStream *temp2 ;
11793 bool created2 ;
11794 PyObject * obj0 = 0 ;
11795 PyObject * obj1 = 0 ;
11796 PyObject * obj2 = 0 ;
11797 PyObject * obj3 = 0 ;
11798 char *kwnames[] = {
11799 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11800 };
11801
11802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11804 if (SWIG_arg_fail(1)) SWIG_fail;
11805 {
11806 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11807 arg2 = temp2->m_wxis;
11808 created2 = false;
11809 } else {
11810 PyErr_Clear(); // clear the failure of the wxPyConvert above
11811 arg2 = wxPyCBInputStream_create(obj1, false);
11812 if (arg2 == NULL) {
11813 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11814 SWIG_fail;
11815 }
11816 created2 = true;
11817 }
11818 }
11819 if (obj2) {
11820 {
11821 arg3 = (long)(SWIG_As_long(obj2));
11822 if (SWIG_arg_fail(3)) SWIG_fail;
11823 }
11824 }
11825 if (obj3) {
11826 {
11827 arg4 = (int)(SWIG_As_int(obj3));
11828 if (SWIG_arg_fail(4)) SWIG_fail;
11829 }
11830 }
11831 {
11832 PyThreadState* __tstate = wxPyBeginAllowThreads();
11833 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11834
11835 wxPyEndAllowThreads(__tstate);
11836 if (PyErr_Occurred()) SWIG_fail;
11837 }
11838 {
11839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11840 }
11841 {
11842 if (created2)
11843 delete arg2;
11844 }
11845 return resultobj;
11846 fail:
11847 {
11848 if (created2)
11849 delete arg2;
11850 }
11851 return NULL;
11852 }
11853
11854
11855 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11856 PyObject *resultobj;
11857 wxImage *arg1 = (wxImage *) 0 ;
11858 wxInputStream *arg2 = 0 ;
11859 wxString *arg3 = 0 ;
11860 int arg4 = (int) -1 ;
11861 bool result;
11862 wxPyInputStream *temp2 ;
11863 bool created2 ;
11864 bool temp3 = false ;
11865 PyObject * obj0 = 0 ;
11866 PyObject * obj1 = 0 ;
11867 PyObject * obj2 = 0 ;
11868 PyObject * obj3 = 0 ;
11869 char *kwnames[] = {
11870 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11871 };
11872
11873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11875 if (SWIG_arg_fail(1)) SWIG_fail;
11876 {
11877 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11878 arg2 = temp2->m_wxis;
11879 created2 = false;
11880 } else {
11881 PyErr_Clear(); // clear the failure of the wxPyConvert above
11882 arg2 = wxPyCBInputStream_create(obj1, false);
11883 if (arg2 == NULL) {
11884 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11885 SWIG_fail;
11886 }
11887 created2 = true;
11888 }
11889 }
11890 {
11891 arg3 = wxString_in_helper(obj2);
11892 if (arg3 == NULL) SWIG_fail;
11893 temp3 = true;
11894 }
11895 if (obj3) {
11896 {
11897 arg4 = (int)(SWIG_As_int(obj3));
11898 if (SWIG_arg_fail(4)) SWIG_fail;
11899 }
11900 }
11901 {
11902 PyThreadState* __tstate = wxPyBeginAllowThreads();
11903 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11904
11905 wxPyEndAllowThreads(__tstate);
11906 if (PyErr_Occurred()) SWIG_fail;
11907 }
11908 {
11909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11910 }
11911 {
11912 if (created2)
11913 delete arg2;
11914 }
11915 {
11916 if (temp3)
11917 delete arg3;
11918 }
11919 return resultobj;
11920 fail:
11921 {
11922 if (created2)
11923 delete arg2;
11924 }
11925 {
11926 if (temp3)
11927 delete arg3;
11928 }
11929 return NULL;
11930 }
11931
11932
11933 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11934 PyObject *resultobj;
11935 wxImage *arg1 = (wxImage *) 0 ;
11936 bool result;
11937 PyObject * obj0 = 0 ;
11938 char *kwnames[] = {
11939 (char *) "self", NULL
11940 };
11941
11942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11944 if (SWIG_arg_fail(1)) SWIG_fail;
11945 {
11946 PyThreadState* __tstate = wxPyBeginAllowThreads();
11947 result = (bool)(arg1)->Ok();
11948
11949 wxPyEndAllowThreads(__tstate);
11950 if (PyErr_Occurred()) SWIG_fail;
11951 }
11952 {
11953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11954 }
11955 return resultobj;
11956 fail:
11957 return NULL;
11958 }
11959
11960
11961 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11962 PyObject *resultobj;
11963 wxImage *arg1 = (wxImage *) 0 ;
11964 int result;
11965 PyObject * obj0 = 0 ;
11966 char *kwnames[] = {
11967 (char *) "self", NULL
11968 };
11969
11970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
11971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11972 if (SWIG_arg_fail(1)) SWIG_fail;
11973 {
11974 PyThreadState* __tstate = wxPyBeginAllowThreads();
11975 result = (int)(arg1)->GetWidth();
11976
11977 wxPyEndAllowThreads(__tstate);
11978 if (PyErr_Occurred()) SWIG_fail;
11979 }
11980 {
11981 resultobj = SWIG_From_int((int)(result));
11982 }
11983 return resultobj;
11984 fail:
11985 return NULL;
11986 }
11987
11988
11989 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
11990 PyObject *resultobj;
11991 wxImage *arg1 = (wxImage *) 0 ;
11992 int result;
11993 PyObject * obj0 = 0 ;
11994 char *kwnames[] = {
11995 (char *) "self", NULL
11996 };
11997
11998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
11999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12000 if (SWIG_arg_fail(1)) SWIG_fail;
12001 {
12002 PyThreadState* __tstate = wxPyBeginAllowThreads();
12003 result = (int)(arg1)->GetHeight();
12004
12005 wxPyEndAllowThreads(__tstate);
12006 if (PyErr_Occurred()) SWIG_fail;
12007 }
12008 {
12009 resultobj = SWIG_From_int((int)(result));
12010 }
12011 return resultobj;
12012 fail:
12013 return NULL;
12014 }
12015
12016
12017 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj;
12019 wxImage *arg1 = (wxImage *) 0 ;
12020 wxSize result;
12021 PyObject * obj0 = 0 ;
12022 char *kwnames[] = {
12023 (char *) "self", NULL
12024 };
12025
12026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12028 if (SWIG_arg_fail(1)) SWIG_fail;
12029 {
12030 PyThreadState* __tstate = wxPyBeginAllowThreads();
12031 result = wxImage_GetSize(arg1);
12032
12033 wxPyEndAllowThreads(__tstate);
12034 if (PyErr_Occurred()) SWIG_fail;
12035 }
12036 {
12037 wxSize * resultptr;
12038 resultptr = new wxSize((wxSize &)(result));
12039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12040 }
12041 return resultobj;
12042 fail:
12043 return NULL;
12044 }
12045
12046
12047 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12048 PyObject *resultobj;
12049 wxImage *arg1 = (wxImage *) 0 ;
12050 wxRect *arg2 = 0 ;
12051 SwigValueWrapper<wxImage > result;
12052 wxRect temp2 ;
12053 PyObject * obj0 = 0 ;
12054 PyObject * obj1 = 0 ;
12055 char *kwnames[] = {
12056 (char *) "self",(char *) "rect", NULL
12057 };
12058
12059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12061 if (SWIG_arg_fail(1)) SWIG_fail;
12062 {
12063 arg2 = &temp2;
12064 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12065 }
12066 {
12067 PyThreadState* __tstate = wxPyBeginAllowThreads();
12068 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12069
12070 wxPyEndAllowThreads(__tstate);
12071 if (PyErr_Occurred()) SWIG_fail;
12072 }
12073 {
12074 wxImage * resultptr;
12075 resultptr = new wxImage((wxImage &)(result));
12076 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12077 }
12078 return resultobj;
12079 fail:
12080 return NULL;
12081 }
12082
12083
12084 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12085 PyObject *resultobj;
12086 wxImage *arg1 = (wxImage *) 0 ;
12087 SwigValueWrapper<wxImage > result;
12088 PyObject * obj0 = 0 ;
12089 char *kwnames[] = {
12090 (char *) "self", NULL
12091 };
12092
12093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12095 if (SWIG_arg_fail(1)) SWIG_fail;
12096 {
12097 PyThreadState* __tstate = wxPyBeginAllowThreads();
12098 result = (arg1)->Copy();
12099
12100 wxPyEndAllowThreads(__tstate);
12101 if (PyErr_Occurred()) SWIG_fail;
12102 }
12103 {
12104 wxImage * resultptr;
12105 resultptr = new wxImage((wxImage &)(result));
12106 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12107 }
12108 return resultobj;
12109 fail:
12110 return NULL;
12111 }
12112
12113
12114 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12115 PyObject *resultobj;
12116 wxImage *arg1 = (wxImage *) 0 ;
12117 wxImage *arg2 = 0 ;
12118 int arg3 ;
12119 int arg4 ;
12120 PyObject * obj0 = 0 ;
12121 PyObject * obj1 = 0 ;
12122 PyObject * obj2 = 0 ;
12123 PyObject * obj3 = 0 ;
12124 char *kwnames[] = {
12125 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12126 };
12127
12128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12130 if (SWIG_arg_fail(1)) SWIG_fail;
12131 {
12132 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12133 if (SWIG_arg_fail(2)) SWIG_fail;
12134 if (arg2 == NULL) {
12135 SWIG_null_ref("wxImage");
12136 }
12137 if (SWIG_arg_fail(2)) SWIG_fail;
12138 }
12139 {
12140 arg3 = (int)(SWIG_As_int(obj2));
12141 if (SWIG_arg_fail(3)) SWIG_fail;
12142 }
12143 {
12144 arg4 = (int)(SWIG_As_int(obj3));
12145 if (SWIG_arg_fail(4)) SWIG_fail;
12146 }
12147 {
12148 PyThreadState* __tstate = wxPyBeginAllowThreads();
12149 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12150
12151 wxPyEndAllowThreads(__tstate);
12152 if (PyErr_Occurred()) SWIG_fail;
12153 }
12154 Py_INCREF(Py_None); resultobj = Py_None;
12155 return resultobj;
12156 fail:
12157 return NULL;
12158 }
12159
12160
12161 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12162 PyObject *resultobj;
12163 wxImage *arg1 = (wxImage *) 0 ;
12164 PyObject *result;
12165 PyObject * obj0 = 0 ;
12166 char *kwnames[] = {
12167 (char *) "self", NULL
12168 };
12169
12170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12172 if (SWIG_arg_fail(1)) SWIG_fail;
12173 {
12174 PyThreadState* __tstate = wxPyBeginAllowThreads();
12175 result = (PyObject *)wxImage_GetData(arg1);
12176
12177 wxPyEndAllowThreads(__tstate);
12178 if (PyErr_Occurred()) SWIG_fail;
12179 }
12180 resultobj = result;
12181 return resultobj;
12182 fail:
12183 return NULL;
12184 }
12185
12186
12187 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12188 PyObject *resultobj;
12189 wxImage *arg1 = (wxImage *) 0 ;
12190 PyObject *arg2 = (PyObject *) 0 ;
12191 PyObject * obj0 = 0 ;
12192 PyObject * obj1 = 0 ;
12193 char *kwnames[] = {
12194 (char *) "self",(char *) "data", NULL
12195 };
12196
12197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12199 if (SWIG_arg_fail(1)) SWIG_fail;
12200 arg2 = obj1;
12201 {
12202 PyThreadState* __tstate = wxPyBeginAllowThreads();
12203 wxImage_SetData(arg1,arg2);
12204
12205 wxPyEndAllowThreads(__tstate);
12206 if (PyErr_Occurred()) SWIG_fail;
12207 }
12208 Py_INCREF(Py_None); resultobj = Py_None;
12209 return resultobj;
12210 fail:
12211 return NULL;
12212 }
12213
12214
12215 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12216 PyObject *resultobj;
12217 wxImage *arg1 = (wxImage *) 0 ;
12218 PyObject *result;
12219 PyObject * obj0 = 0 ;
12220 char *kwnames[] = {
12221 (char *) "self", NULL
12222 };
12223
12224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12226 if (SWIG_arg_fail(1)) SWIG_fail;
12227 {
12228 PyThreadState* __tstate = wxPyBeginAllowThreads();
12229 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12230
12231 wxPyEndAllowThreads(__tstate);
12232 if (PyErr_Occurred()) SWIG_fail;
12233 }
12234 resultobj = result;
12235 return resultobj;
12236 fail:
12237 return NULL;
12238 }
12239
12240
12241 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12242 PyObject *resultobj;
12243 wxImage *arg1 = (wxImage *) 0 ;
12244 PyObject *arg2 = (PyObject *) 0 ;
12245 PyObject * obj0 = 0 ;
12246 PyObject * obj1 = 0 ;
12247 char *kwnames[] = {
12248 (char *) "self",(char *) "data", NULL
12249 };
12250
12251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12253 if (SWIG_arg_fail(1)) SWIG_fail;
12254 arg2 = obj1;
12255 {
12256 PyThreadState* __tstate = wxPyBeginAllowThreads();
12257 wxImage_SetDataBuffer(arg1,arg2);
12258
12259 wxPyEndAllowThreads(__tstate);
12260 if (PyErr_Occurred()) SWIG_fail;
12261 }
12262 Py_INCREF(Py_None); resultobj = Py_None;
12263 return resultobj;
12264 fail:
12265 return NULL;
12266 }
12267
12268
12269 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12270 PyObject *resultobj;
12271 wxImage *arg1 = (wxImage *) 0 ;
12272 PyObject *result;
12273 PyObject * obj0 = 0 ;
12274 char *kwnames[] = {
12275 (char *) "self", NULL
12276 };
12277
12278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12280 if (SWIG_arg_fail(1)) SWIG_fail;
12281 {
12282 PyThreadState* __tstate = wxPyBeginAllowThreads();
12283 result = (PyObject *)wxImage_GetAlphaData(arg1);
12284
12285 wxPyEndAllowThreads(__tstate);
12286 if (PyErr_Occurred()) SWIG_fail;
12287 }
12288 resultobj = result;
12289 return resultobj;
12290 fail:
12291 return NULL;
12292 }
12293
12294
12295 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12296 PyObject *resultobj;
12297 wxImage *arg1 = (wxImage *) 0 ;
12298 PyObject *arg2 = (PyObject *) 0 ;
12299 PyObject * obj0 = 0 ;
12300 PyObject * obj1 = 0 ;
12301 char *kwnames[] = {
12302 (char *) "self",(char *) "data", NULL
12303 };
12304
12305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12307 if (SWIG_arg_fail(1)) SWIG_fail;
12308 arg2 = obj1;
12309 {
12310 PyThreadState* __tstate = wxPyBeginAllowThreads();
12311 wxImage_SetAlphaData(arg1,arg2);
12312
12313 wxPyEndAllowThreads(__tstate);
12314 if (PyErr_Occurred()) SWIG_fail;
12315 }
12316 Py_INCREF(Py_None); resultobj = Py_None;
12317 return resultobj;
12318 fail:
12319 return NULL;
12320 }
12321
12322
12323 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12324 PyObject *resultobj;
12325 wxImage *arg1 = (wxImage *) 0 ;
12326 PyObject *result;
12327 PyObject * obj0 = 0 ;
12328 char *kwnames[] = {
12329 (char *) "self", NULL
12330 };
12331
12332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12334 if (SWIG_arg_fail(1)) SWIG_fail;
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12338
12339 wxPyEndAllowThreads(__tstate);
12340 if (PyErr_Occurred()) SWIG_fail;
12341 }
12342 resultobj = result;
12343 return resultobj;
12344 fail:
12345 return NULL;
12346 }
12347
12348
12349 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12350 PyObject *resultobj;
12351 wxImage *arg1 = (wxImage *) 0 ;
12352 PyObject *arg2 = (PyObject *) 0 ;
12353 PyObject * obj0 = 0 ;
12354 PyObject * obj1 = 0 ;
12355 char *kwnames[] = {
12356 (char *) "self",(char *) "data", NULL
12357 };
12358
12359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12361 if (SWIG_arg_fail(1)) SWIG_fail;
12362 arg2 = obj1;
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 wxImage_SetAlphaBuffer(arg1,arg2);
12366
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 Py_INCREF(Py_None); resultobj = Py_None;
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12378 PyObject *resultobj;
12379 wxImage *arg1 = (wxImage *) 0 ;
12380 unsigned char arg2 ;
12381 unsigned char arg3 ;
12382 unsigned char arg4 ;
12383 PyObject * obj0 = 0 ;
12384 PyObject * obj1 = 0 ;
12385 PyObject * obj2 = 0 ;
12386 PyObject * obj3 = 0 ;
12387 char *kwnames[] = {
12388 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12389 };
12390
12391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12393 if (SWIG_arg_fail(1)) SWIG_fail;
12394 {
12395 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12396 if (SWIG_arg_fail(2)) SWIG_fail;
12397 }
12398 {
12399 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12400 if (SWIG_arg_fail(3)) SWIG_fail;
12401 }
12402 {
12403 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12404 if (SWIG_arg_fail(4)) SWIG_fail;
12405 }
12406 {
12407 PyThreadState* __tstate = wxPyBeginAllowThreads();
12408 (arg1)->SetMaskColour(arg2,arg3,arg4);
12409
12410 wxPyEndAllowThreads(__tstate);
12411 if (PyErr_Occurred()) SWIG_fail;
12412 }
12413 Py_INCREF(Py_None); resultobj = Py_None;
12414 return resultobj;
12415 fail:
12416 return NULL;
12417 }
12418
12419
12420 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12421 PyObject *resultobj;
12422 wxImage *arg1 = (wxImage *) 0 ;
12423 unsigned char result;
12424 PyObject * obj0 = 0 ;
12425 char *kwnames[] = {
12426 (char *) "self", NULL
12427 };
12428
12429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12431 if (SWIG_arg_fail(1)) SWIG_fail;
12432 {
12433 PyThreadState* __tstate = wxPyBeginAllowThreads();
12434 result = (unsigned char)(arg1)->GetMaskRed();
12435
12436 wxPyEndAllowThreads(__tstate);
12437 if (PyErr_Occurred()) SWIG_fail;
12438 }
12439 {
12440 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12441 }
12442 return resultobj;
12443 fail:
12444 return NULL;
12445 }
12446
12447
12448 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12449 PyObject *resultobj;
12450 wxImage *arg1 = (wxImage *) 0 ;
12451 unsigned char result;
12452 PyObject * obj0 = 0 ;
12453 char *kwnames[] = {
12454 (char *) "self", NULL
12455 };
12456
12457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12459 if (SWIG_arg_fail(1)) SWIG_fail;
12460 {
12461 PyThreadState* __tstate = wxPyBeginAllowThreads();
12462 result = (unsigned char)(arg1)->GetMaskGreen();
12463
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 {
12468 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12469 }
12470 return resultobj;
12471 fail:
12472 return NULL;
12473 }
12474
12475
12476 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12477 PyObject *resultobj;
12478 wxImage *arg1 = (wxImage *) 0 ;
12479 unsigned char result;
12480 PyObject * obj0 = 0 ;
12481 char *kwnames[] = {
12482 (char *) "self", NULL
12483 };
12484
12485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12487 if (SWIG_arg_fail(1)) SWIG_fail;
12488 {
12489 PyThreadState* __tstate = wxPyBeginAllowThreads();
12490 result = (unsigned char)(arg1)->GetMaskBlue();
12491
12492 wxPyEndAllowThreads(__tstate);
12493 if (PyErr_Occurred()) SWIG_fail;
12494 }
12495 {
12496 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12497 }
12498 return resultobj;
12499 fail:
12500 return NULL;
12501 }
12502
12503
12504 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12505 PyObject *resultobj;
12506 wxImage *arg1 = (wxImage *) 0 ;
12507 bool arg2 = (bool) true ;
12508 PyObject * obj0 = 0 ;
12509 PyObject * obj1 = 0 ;
12510 char *kwnames[] = {
12511 (char *) "self",(char *) "mask", NULL
12512 };
12513
12514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12516 if (SWIG_arg_fail(1)) SWIG_fail;
12517 if (obj1) {
12518 {
12519 arg2 = (bool)(SWIG_As_bool(obj1));
12520 if (SWIG_arg_fail(2)) SWIG_fail;
12521 }
12522 }
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 (arg1)->SetMask(arg2);
12526
12527 wxPyEndAllowThreads(__tstate);
12528 if (PyErr_Occurred()) SWIG_fail;
12529 }
12530 Py_INCREF(Py_None); resultobj = Py_None;
12531 return resultobj;
12532 fail:
12533 return NULL;
12534 }
12535
12536
12537 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12538 PyObject *resultobj;
12539 wxImage *arg1 = (wxImage *) 0 ;
12540 bool result;
12541 PyObject * obj0 = 0 ;
12542 char *kwnames[] = {
12543 (char *) "self", NULL
12544 };
12545
12546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12548 if (SWIG_arg_fail(1)) SWIG_fail;
12549 {
12550 PyThreadState* __tstate = wxPyBeginAllowThreads();
12551 result = (bool)(arg1)->HasMask();
12552
12553 wxPyEndAllowThreads(__tstate);
12554 if (PyErr_Occurred()) SWIG_fail;
12555 }
12556 {
12557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12558 }
12559 return resultobj;
12560 fail:
12561 return NULL;
12562 }
12563
12564
12565 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12566 PyObject *resultobj;
12567 wxImage *arg1 = (wxImage *) 0 ;
12568 double arg2 ;
12569 wxPoint *arg3 = 0 ;
12570 bool arg4 = (bool) true ;
12571 wxPoint *arg5 = (wxPoint *) NULL ;
12572 SwigValueWrapper<wxImage > result;
12573 wxPoint temp3 ;
12574 PyObject * obj0 = 0 ;
12575 PyObject * obj1 = 0 ;
12576 PyObject * obj2 = 0 ;
12577 PyObject * obj3 = 0 ;
12578 PyObject * obj4 = 0 ;
12579 char *kwnames[] = {
12580 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12581 };
12582
12583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12585 if (SWIG_arg_fail(1)) SWIG_fail;
12586 {
12587 arg2 = (double)(SWIG_As_double(obj1));
12588 if (SWIG_arg_fail(2)) SWIG_fail;
12589 }
12590 {
12591 arg3 = &temp3;
12592 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12593 }
12594 if (obj3) {
12595 {
12596 arg4 = (bool)(SWIG_As_bool(obj3));
12597 if (SWIG_arg_fail(4)) SWIG_fail;
12598 }
12599 }
12600 if (obj4) {
12601 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12602 if (SWIG_arg_fail(5)) SWIG_fail;
12603 }
12604 {
12605 PyThreadState* __tstate = wxPyBeginAllowThreads();
12606 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12607
12608 wxPyEndAllowThreads(__tstate);
12609 if (PyErr_Occurred()) SWIG_fail;
12610 }
12611 {
12612 wxImage * resultptr;
12613 resultptr = new wxImage((wxImage &)(result));
12614 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12615 }
12616 return resultobj;
12617 fail:
12618 return NULL;
12619 }
12620
12621
12622 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12623 PyObject *resultobj;
12624 wxImage *arg1 = (wxImage *) 0 ;
12625 bool arg2 = (bool) true ;
12626 SwigValueWrapper<wxImage > result;
12627 PyObject * obj0 = 0 ;
12628 PyObject * obj1 = 0 ;
12629 char *kwnames[] = {
12630 (char *) "self",(char *) "clockwise", NULL
12631 };
12632
12633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12635 if (SWIG_arg_fail(1)) SWIG_fail;
12636 if (obj1) {
12637 {
12638 arg2 = (bool)(SWIG_As_bool(obj1));
12639 if (SWIG_arg_fail(2)) SWIG_fail;
12640 }
12641 }
12642 {
12643 PyThreadState* __tstate = wxPyBeginAllowThreads();
12644 result = (arg1)->Rotate90(arg2);
12645
12646 wxPyEndAllowThreads(__tstate);
12647 if (PyErr_Occurred()) SWIG_fail;
12648 }
12649 {
12650 wxImage * resultptr;
12651 resultptr = new wxImage((wxImage &)(result));
12652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12653 }
12654 return resultobj;
12655 fail:
12656 return NULL;
12657 }
12658
12659
12660 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12661 PyObject *resultobj;
12662 wxImage *arg1 = (wxImage *) 0 ;
12663 bool arg2 = (bool) true ;
12664 SwigValueWrapper<wxImage > result;
12665 PyObject * obj0 = 0 ;
12666 PyObject * obj1 = 0 ;
12667 char *kwnames[] = {
12668 (char *) "self",(char *) "horizontally", NULL
12669 };
12670
12671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12673 if (SWIG_arg_fail(1)) SWIG_fail;
12674 if (obj1) {
12675 {
12676 arg2 = (bool)(SWIG_As_bool(obj1));
12677 if (SWIG_arg_fail(2)) SWIG_fail;
12678 }
12679 }
12680 {
12681 PyThreadState* __tstate = wxPyBeginAllowThreads();
12682 result = (arg1)->Mirror(arg2);
12683
12684 wxPyEndAllowThreads(__tstate);
12685 if (PyErr_Occurred()) SWIG_fail;
12686 }
12687 {
12688 wxImage * resultptr;
12689 resultptr = new wxImage((wxImage &)(result));
12690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12691 }
12692 return resultobj;
12693 fail:
12694 return NULL;
12695 }
12696
12697
12698 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12699 PyObject *resultobj;
12700 wxImage *arg1 = (wxImage *) 0 ;
12701 unsigned char arg2 ;
12702 unsigned char arg3 ;
12703 unsigned char arg4 ;
12704 unsigned char arg5 ;
12705 unsigned char arg6 ;
12706 unsigned char arg7 ;
12707 PyObject * obj0 = 0 ;
12708 PyObject * obj1 = 0 ;
12709 PyObject * obj2 = 0 ;
12710 PyObject * obj3 = 0 ;
12711 PyObject * obj4 = 0 ;
12712 PyObject * obj5 = 0 ;
12713 PyObject * obj6 = 0 ;
12714 char *kwnames[] = {
12715 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12716 };
12717
12718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12720 if (SWIG_arg_fail(1)) SWIG_fail;
12721 {
12722 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12723 if (SWIG_arg_fail(2)) SWIG_fail;
12724 }
12725 {
12726 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12727 if (SWIG_arg_fail(3)) SWIG_fail;
12728 }
12729 {
12730 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12731 if (SWIG_arg_fail(4)) SWIG_fail;
12732 }
12733 {
12734 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12735 if (SWIG_arg_fail(5)) SWIG_fail;
12736 }
12737 {
12738 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12739 if (SWIG_arg_fail(6)) SWIG_fail;
12740 }
12741 {
12742 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12743 if (SWIG_arg_fail(7)) SWIG_fail;
12744 }
12745 {
12746 PyThreadState* __tstate = wxPyBeginAllowThreads();
12747 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12748
12749 wxPyEndAllowThreads(__tstate);
12750 if (PyErr_Occurred()) SWIG_fail;
12751 }
12752 Py_INCREF(Py_None); resultobj = Py_None;
12753 return resultobj;
12754 fail:
12755 return NULL;
12756 }
12757
12758
12759 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12760 PyObject *resultobj;
12761 wxImage *arg1 = (wxImage *) 0 ;
12762 unsigned char arg2 ;
12763 unsigned char arg3 ;
12764 unsigned char arg4 ;
12765 SwigValueWrapper<wxImage > result;
12766 PyObject * obj0 = 0 ;
12767 PyObject * obj1 = 0 ;
12768 PyObject * obj2 = 0 ;
12769 PyObject * obj3 = 0 ;
12770 char *kwnames[] = {
12771 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12772 };
12773
12774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12776 if (SWIG_arg_fail(1)) SWIG_fail;
12777 {
12778 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12779 if (SWIG_arg_fail(2)) SWIG_fail;
12780 }
12781 {
12782 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12783 if (SWIG_arg_fail(3)) SWIG_fail;
12784 }
12785 {
12786 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12787 if (SWIG_arg_fail(4)) SWIG_fail;
12788 }
12789 {
12790 PyThreadState* __tstate = wxPyBeginAllowThreads();
12791 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12792
12793 wxPyEndAllowThreads(__tstate);
12794 if (PyErr_Occurred()) SWIG_fail;
12795 }
12796 {
12797 wxImage * resultptr;
12798 resultptr = new wxImage((wxImage &)(result));
12799 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12800 }
12801 return resultobj;
12802 fail:
12803 return NULL;
12804 }
12805
12806
12807 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12808 PyObject *resultobj;
12809 wxImage *arg1 = (wxImage *) 0 ;
12810 wxString *arg2 = 0 ;
12811 wxString *arg3 = 0 ;
12812 bool temp2 = false ;
12813 bool temp3 = false ;
12814 PyObject * obj0 = 0 ;
12815 PyObject * obj1 = 0 ;
12816 PyObject * obj2 = 0 ;
12817 char *kwnames[] = {
12818 (char *) "self",(char *) "name",(char *) "value", NULL
12819 };
12820
12821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12823 if (SWIG_arg_fail(1)) SWIG_fail;
12824 {
12825 arg2 = wxString_in_helper(obj1);
12826 if (arg2 == NULL) SWIG_fail;
12827 temp2 = true;
12828 }
12829 {
12830 arg3 = wxString_in_helper(obj2);
12831 if (arg3 == NULL) SWIG_fail;
12832 temp3 = true;
12833 }
12834 {
12835 PyThreadState* __tstate = wxPyBeginAllowThreads();
12836 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12837
12838 wxPyEndAllowThreads(__tstate);
12839 if (PyErr_Occurred()) SWIG_fail;
12840 }
12841 Py_INCREF(Py_None); resultobj = Py_None;
12842 {
12843 if (temp2)
12844 delete arg2;
12845 }
12846 {
12847 if (temp3)
12848 delete arg3;
12849 }
12850 return resultobj;
12851 fail:
12852 {
12853 if (temp2)
12854 delete arg2;
12855 }
12856 {
12857 if (temp3)
12858 delete arg3;
12859 }
12860 return NULL;
12861 }
12862
12863
12864 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12865 PyObject *resultobj;
12866 wxImage *arg1 = (wxImage *) 0 ;
12867 wxString *arg2 = 0 ;
12868 int arg3 ;
12869 bool temp2 = false ;
12870 PyObject * obj0 = 0 ;
12871 PyObject * obj1 = 0 ;
12872 PyObject * obj2 = 0 ;
12873 char *kwnames[] = {
12874 (char *) "self",(char *) "name",(char *) "value", NULL
12875 };
12876
12877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12879 if (SWIG_arg_fail(1)) SWIG_fail;
12880 {
12881 arg2 = wxString_in_helper(obj1);
12882 if (arg2 == NULL) SWIG_fail;
12883 temp2 = true;
12884 }
12885 {
12886 arg3 = (int)(SWIG_As_int(obj2));
12887 if (SWIG_arg_fail(3)) SWIG_fail;
12888 }
12889 {
12890 PyThreadState* __tstate = wxPyBeginAllowThreads();
12891 (arg1)->SetOption((wxString const &)*arg2,arg3);
12892
12893 wxPyEndAllowThreads(__tstate);
12894 if (PyErr_Occurred()) SWIG_fail;
12895 }
12896 Py_INCREF(Py_None); resultobj = Py_None;
12897 {
12898 if (temp2)
12899 delete arg2;
12900 }
12901 return resultobj;
12902 fail:
12903 {
12904 if (temp2)
12905 delete arg2;
12906 }
12907 return NULL;
12908 }
12909
12910
12911 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12912 PyObject *resultobj;
12913 wxImage *arg1 = (wxImage *) 0 ;
12914 wxString *arg2 = 0 ;
12915 wxString result;
12916 bool temp2 = false ;
12917 PyObject * obj0 = 0 ;
12918 PyObject * obj1 = 0 ;
12919 char *kwnames[] = {
12920 (char *) "self",(char *) "name", NULL
12921 };
12922
12923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12925 if (SWIG_arg_fail(1)) SWIG_fail;
12926 {
12927 arg2 = wxString_in_helper(obj1);
12928 if (arg2 == NULL) SWIG_fail;
12929 temp2 = true;
12930 }
12931 {
12932 PyThreadState* __tstate = wxPyBeginAllowThreads();
12933 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12934
12935 wxPyEndAllowThreads(__tstate);
12936 if (PyErr_Occurred()) SWIG_fail;
12937 }
12938 {
12939 #if wxUSE_UNICODE
12940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12941 #else
12942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12943 #endif
12944 }
12945 {
12946 if (temp2)
12947 delete arg2;
12948 }
12949 return resultobj;
12950 fail:
12951 {
12952 if (temp2)
12953 delete arg2;
12954 }
12955 return NULL;
12956 }
12957
12958
12959 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12960 PyObject *resultobj;
12961 wxImage *arg1 = (wxImage *) 0 ;
12962 wxString *arg2 = 0 ;
12963 int result;
12964 bool temp2 = false ;
12965 PyObject * obj0 = 0 ;
12966 PyObject * obj1 = 0 ;
12967 char *kwnames[] = {
12968 (char *) "self",(char *) "name", NULL
12969 };
12970
12971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
12972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12973 if (SWIG_arg_fail(1)) SWIG_fail;
12974 {
12975 arg2 = wxString_in_helper(obj1);
12976 if (arg2 == NULL) SWIG_fail;
12977 temp2 = true;
12978 }
12979 {
12980 PyThreadState* __tstate = wxPyBeginAllowThreads();
12981 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
12982
12983 wxPyEndAllowThreads(__tstate);
12984 if (PyErr_Occurred()) SWIG_fail;
12985 }
12986 {
12987 resultobj = SWIG_From_int((int)(result));
12988 }
12989 {
12990 if (temp2)
12991 delete arg2;
12992 }
12993 return resultobj;
12994 fail:
12995 {
12996 if (temp2)
12997 delete arg2;
12998 }
12999 return NULL;
13000 }
13001
13002
13003 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13004 PyObject *resultobj;
13005 wxImage *arg1 = (wxImage *) 0 ;
13006 wxString *arg2 = 0 ;
13007 bool result;
13008 bool temp2 = false ;
13009 PyObject * obj0 = 0 ;
13010 PyObject * obj1 = 0 ;
13011 char *kwnames[] = {
13012 (char *) "self",(char *) "name", NULL
13013 };
13014
13015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13017 if (SWIG_arg_fail(1)) SWIG_fail;
13018 {
13019 arg2 = wxString_in_helper(obj1);
13020 if (arg2 == NULL) SWIG_fail;
13021 temp2 = true;
13022 }
13023 {
13024 PyThreadState* __tstate = wxPyBeginAllowThreads();
13025 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13026
13027 wxPyEndAllowThreads(__tstate);
13028 if (PyErr_Occurred()) SWIG_fail;
13029 }
13030 {
13031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13032 }
13033 {
13034 if (temp2)
13035 delete arg2;
13036 }
13037 return resultobj;
13038 fail:
13039 {
13040 if (temp2)
13041 delete arg2;
13042 }
13043 return NULL;
13044 }
13045
13046
13047 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13048 PyObject *resultobj;
13049 wxImage *arg1 = (wxImage *) 0 ;
13050 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13051 unsigned long result;
13052 PyObject * obj0 = 0 ;
13053 PyObject * obj1 = 0 ;
13054 char *kwnames[] = {
13055 (char *) "self",(char *) "stopafter", NULL
13056 };
13057
13058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13060 if (SWIG_arg_fail(1)) SWIG_fail;
13061 if (obj1) {
13062 {
13063 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13064 if (SWIG_arg_fail(2)) SWIG_fail;
13065 }
13066 }
13067 {
13068 PyThreadState* __tstate = wxPyBeginAllowThreads();
13069 result = (unsigned long)(arg1)->CountColours(arg2);
13070
13071 wxPyEndAllowThreads(__tstate);
13072 if (PyErr_Occurred()) SWIG_fail;
13073 }
13074 {
13075 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13076 }
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13084 PyObject *resultobj;
13085 wxImage *arg1 = (wxImage *) 0 ;
13086 wxImageHistogram *arg2 = 0 ;
13087 unsigned long result;
13088 PyObject * obj0 = 0 ;
13089 PyObject * obj1 = 0 ;
13090 char *kwnames[] = {
13091 (char *) "self",(char *) "h", NULL
13092 };
13093
13094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13096 if (SWIG_arg_fail(1)) SWIG_fail;
13097 {
13098 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13099 if (SWIG_arg_fail(2)) SWIG_fail;
13100 if (arg2 == NULL) {
13101 SWIG_null_ref("wxImageHistogram");
13102 }
13103 if (SWIG_arg_fail(2)) SWIG_fail;
13104 }
13105 {
13106 PyThreadState* __tstate = wxPyBeginAllowThreads();
13107 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13108
13109 wxPyEndAllowThreads(__tstate);
13110 if (PyErr_Occurred()) SWIG_fail;
13111 }
13112 {
13113 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13114 }
13115 return resultobj;
13116 fail:
13117 return NULL;
13118 }
13119
13120
13121 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13122 PyObject *resultobj;
13123 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13124 PyObject * obj0 = 0 ;
13125 char *kwnames[] = {
13126 (char *) "handler", NULL
13127 };
13128
13129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13131 if (SWIG_arg_fail(1)) SWIG_fail;
13132 {
13133 PyThreadState* __tstate = wxPyBeginAllowThreads();
13134 wxImage::AddHandler(arg1);
13135
13136 wxPyEndAllowThreads(__tstate);
13137 if (PyErr_Occurred()) SWIG_fail;
13138 }
13139 Py_INCREF(Py_None); resultobj = Py_None;
13140 return resultobj;
13141 fail:
13142 return NULL;
13143 }
13144
13145
13146 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13147 PyObject *resultobj;
13148 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13149 PyObject * obj0 = 0 ;
13150 char *kwnames[] = {
13151 (char *) "handler", NULL
13152 };
13153
13154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13156 if (SWIG_arg_fail(1)) SWIG_fail;
13157 {
13158 PyThreadState* __tstate = wxPyBeginAllowThreads();
13159 wxImage::InsertHandler(arg1);
13160
13161 wxPyEndAllowThreads(__tstate);
13162 if (PyErr_Occurred()) SWIG_fail;
13163 }
13164 Py_INCREF(Py_None); resultobj = Py_None;
13165 return resultobj;
13166 fail:
13167 return NULL;
13168 }
13169
13170
13171 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13172 PyObject *resultobj;
13173 wxString *arg1 = 0 ;
13174 bool result;
13175 bool temp1 = false ;
13176 PyObject * obj0 = 0 ;
13177 char *kwnames[] = {
13178 (char *) "name", NULL
13179 };
13180
13181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13182 {
13183 arg1 = wxString_in_helper(obj0);
13184 if (arg1 == NULL) SWIG_fail;
13185 temp1 = true;
13186 }
13187 {
13188 PyThreadState* __tstate = wxPyBeginAllowThreads();
13189 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13190
13191 wxPyEndAllowThreads(__tstate);
13192 if (PyErr_Occurred()) SWIG_fail;
13193 }
13194 {
13195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13196 }
13197 {
13198 if (temp1)
13199 delete arg1;
13200 }
13201 return resultobj;
13202 fail:
13203 {
13204 if (temp1)
13205 delete arg1;
13206 }
13207 return NULL;
13208 }
13209
13210
13211 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13212 PyObject *resultobj;
13213 wxString result;
13214 char *kwnames[] = {
13215 NULL
13216 };
13217
13218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13219 {
13220 PyThreadState* __tstate = wxPyBeginAllowThreads();
13221 result = wxImage::GetImageExtWildcard();
13222
13223 wxPyEndAllowThreads(__tstate);
13224 if (PyErr_Occurred()) SWIG_fail;
13225 }
13226 {
13227 #if wxUSE_UNICODE
13228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13229 #else
13230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13231 #endif
13232 }
13233 return resultobj;
13234 fail:
13235 return NULL;
13236 }
13237
13238
13239 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13240 PyObject *resultobj;
13241 wxImage *arg1 = (wxImage *) 0 ;
13242 int arg2 = (int) -1 ;
13243 wxBitmap result;
13244 PyObject * obj0 = 0 ;
13245 PyObject * obj1 = 0 ;
13246 char *kwnames[] = {
13247 (char *) "self",(char *) "depth", NULL
13248 };
13249
13250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13252 if (SWIG_arg_fail(1)) SWIG_fail;
13253 if (obj1) {
13254 {
13255 arg2 = (int)(SWIG_As_int(obj1));
13256 if (SWIG_arg_fail(2)) SWIG_fail;
13257 }
13258 }
13259 {
13260 if (!wxPyCheckForApp()) SWIG_fail;
13261 PyThreadState* __tstate = wxPyBeginAllowThreads();
13262 result = wxImage_ConvertToBitmap(arg1,arg2);
13263
13264 wxPyEndAllowThreads(__tstate);
13265 if (PyErr_Occurred()) SWIG_fail;
13266 }
13267 {
13268 wxBitmap * resultptr;
13269 resultptr = new wxBitmap((wxBitmap &)(result));
13270 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13271 }
13272 return resultobj;
13273 fail:
13274 return NULL;
13275 }
13276
13277
13278 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13279 PyObject *resultobj;
13280 wxImage *arg1 = (wxImage *) 0 ;
13281 unsigned char arg2 ;
13282 unsigned char arg3 ;
13283 unsigned char arg4 ;
13284 wxBitmap result;
13285 PyObject * obj0 = 0 ;
13286 PyObject * obj1 = 0 ;
13287 PyObject * obj2 = 0 ;
13288 PyObject * obj3 = 0 ;
13289 char *kwnames[] = {
13290 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13291 };
13292
13293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13295 if (SWIG_arg_fail(1)) SWIG_fail;
13296 {
13297 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13298 if (SWIG_arg_fail(2)) SWIG_fail;
13299 }
13300 {
13301 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13302 if (SWIG_arg_fail(3)) SWIG_fail;
13303 }
13304 {
13305 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13306 if (SWIG_arg_fail(4)) SWIG_fail;
13307 }
13308 {
13309 if (!wxPyCheckForApp()) SWIG_fail;
13310 PyThreadState* __tstate = wxPyBeginAllowThreads();
13311 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13312
13313 wxPyEndAllowThreads(__tstate);
13314 if (PyErr_Occurred()) SWIG_fail;
13315 }
13316 {
13317 wxBitmap * resultptr;
13318 resultptr = new wxBitmap((wxBitmap &)(result));
13319 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13320 }
13321 return resultobj;
13322 fail:
13323 return NULL;
13324 }
13325
13326
13327 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13328 PyObject *obj;
13329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13330 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13331 Py_INCREF(obj);
13332 return Py_BuildValue((char *)"");
13333 }
13334 static int _wrap_NullImage_set(PyObject *) {
13335 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13336 return 1;
13337 }
13338
13339
13340 static PyObject *_wrap_NullImage_get(void) {
13341 PyObject *pyobj;
13342
13343 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13344 return pyobj;
13345 }
13346
13347
13348 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13349 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13350 return 1;
13351 }
13352
13353
13354 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13355 PyObject *pyobj;
13356
13357 {
13358 #if wxUSE_UNICODE
13359 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13360 #else
13361 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13362 #endif
13363 }
13364 return pyobj;
13365 }
13366
13367
13368 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13369 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13370 return 1;
13371 }
13372
13373
13374 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13375 PyObject *pyobj;
13376
13377 {
13378 #if wxUSE_UNICODE
13379 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13380 #else
13381 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13382 #endif
13383 }
13384 return pyobj;
13385 }
13386
13387
13388 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13389 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13390 return 1;
13391 }
13392
13393
13394 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13395 PyObject *pyobj;
13396
13397 {
13398 #if wxUSE_UNICODE
13399 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13400 #else
13401 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13402 #endif
13403 }
13404 return pyobj;
13405 }
13406
13407
13408 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13409 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13410 return 1;
13411 }
13412
13413
13414 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13415 PyObject *pyobj;
13416
13417 {
13418 #if wxUSE_UNICODE
13419 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13420 #else
13421 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13422 #endif
13423 }
13424 return pyobj;
13425 }
13426
13427
13428 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13429 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13430 return 1;
13431 }
13432
13433
13434 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13435 PyObject *pyobj;
13436
13437 {
13438 #if wxUSE_UNICODE
13439 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13440 #else
13441 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13442 #endif
13443 }
13444 return pyobj;
13445 }
13446
13447
13448 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13449 PyObject *resultobj;
13450 wxBMPHandler *result;
13451 char *kwnames[] = {
13452 NULL
13453 };
13454
13455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13456 {
13457 PyThreadState* __tstate = wxPyBeginAllowThreads();
13458 result = (wxBMPHandler *)new wxBMPHandler();
13459
13460 wxPyEndAllowThreads(__tstate);
13461 if (PyErr_Occurred()) SWIG_fail;
13462 }
13463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13464 return resultobj;
13465 fail:
13466 return NULL;
13467 }
13468
13469
13470 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13471 PyObject *obj;
13472 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13473 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13474 Py_INCREF(obj);
13475 return Py_BuildValue((char *)"");
13476 }
13477 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13478 PyObject *resultobj;
13479 wxICOHandler *result;
13480 char *kwnames[] = {
13481 NULL
13482 };
13483
13484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13485 {
13486 PyThreadState* __tstate = wxPyBeginAllowThreads();
13487 result = (wxICOHandler *)new wxICOHandler();
13488
13489 wxPyEndAllowThreads(__tstate);
13490 if (PyErr_Occurred()) SWIG_fail;
13491 }
13492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13493 return resultobj;
13494 fail:
13495 return NULL;
13496 }
13497
13498
13499 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13500 PyObject *obj;
13501 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13502 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13503 Py_INCREF(obj);
13504 return Py_BuildValue((char *)"");
13505 }
13506 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13507 PyObject *resultobj;
13508 wxCURHandler *result;
13509 char *kwnames[] = {
13510 NULL
13511 };
13512
13513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13514 {
13515 PyThreadState* __tstate = wxPyBeginAllowThreads();
13516 result = (wxCURHandler *)new wxCURHandler();
13517
13518 wxPyEndAllowThreads(__tstate);
13519 if (PyErr_Occurred()) SWIG_fail;
13520 }
13521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13522 return resultobj;
13523 fail:
13524 return NULL;
13525 }
13526
13527
13528 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13529 PyObject *obj;
13530 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13531 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13532 Py_INCREF(obj);
13533 return Py_BuildValue((char *)"");
13534 }
13535 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13536 PyObject *resultobj;
13537 wxANIHandler *result;
13538 char *kwnames[] = {
13539 NULL
13540 };
13541
13542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13543 {
13544 PyThreadState* __tstate = wxPyBeginAllowThreads();
13545 result = (wxANIHandler *)new wxANIHandler();
13546
13547 wxPyEndAllowThreads(__tstate);
13548 if (PyErr_Occurred()) SWIG_fail;
13549 }
13550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13551 return resultobj;
13552 fail:
13553 return NULL;
13554 }
13555
13556
13557 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13558 PyObject *obj;
13559 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13560 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13561 Py_INCREF(obj);
13562 return Py_BuildValue((char *)"");
13563 }
13564 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13565 PyObject *resultobj;
13566 wxPNGHandler *result;
13567 char *kwnames[] = {
13568 NULL
13569 };
13570
13571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13572 {
13573 PyThreadState* __tstate = wxPyBeginAllowThreads();
13574 result = (wxPNGHandler *)new wxPNGHandler();
13575
13576 wxPyEndAllowThreads(__tstate);
13577 if (PyErr_Occurred()) SWIG_fail;
13578 }
13579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13580 return resultobj;
13581 fail:
13582 return NULL;
13583 }
13584
13585
13586 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13587 PyObject *obj;
13588 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13589 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13590 Py_INCREF(obj);
13591 return Py_BuildValue((char *)"");
13592 }
13593 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13594 PyObject *resultobj;
13595 wxGIFHandler *result;
13596 char *kwnames[] = {
13597 NULL
13598 };
13599
13600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13601 {
13602 PyThreadState* __tstate = wxPyBeginAllowThreads();
13603 result = (wxGIFHandler *)new wxGIFHandler();
13604
13605 wxPyEndAllowThreads(__tstate);
13606 if (PyErr_Occurred()) SWIG_fail;
13607 }
13608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13609 return resultobj;
13610 fail:
13611 return NULL;
13612 }
13613
13614
13615 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13616 PyObject *obj;
13617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13618 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13619 Py_INCREF(obj);
13620 return Py_BuildValue((char *)"");
13621 }
13622 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13623 PyObject *resultobj;
13624 wxPCXHandler *result;
13625 char *kwnames[] = {
13626 NULL
13627 };
13628
13629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13630 {
13631 PyThreadState* __tstate = wxPyBeginAllowThreads();
13632 result = (wxPCXHandler *)new wxPCXHandler();
13633
13634 wxPyEndAllowThreads(__tstate);
13635 if (PyErr_Occurred()) SWIG_fail;
13636 }
13637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13638 return resultobj;
13639 fail:
13640 return NULL;
13641 }
13642
13643
13644 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13645 PyObject *obj;
13646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13647 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13648 Py_INCREF(obj);
13649 return Py_BuildValue((char *)"");
13650 }
13651 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13652 PyObject *resultobj;
13653 wxJPEGHandler *result;
13654 char *kwnames[] = {
13655 NULL
13656 };
13657
13658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13659 {
13660 PyThreadState* __tstate = wxPyBeginAllowThreads();
13661 result = (wxJPEGHandler *)new wxJPEGHandler();
13662
13663 wxPyEndAllowThreads(__tstate);
13664 if (PyErr_Occurred()) SWIG_fail;
13665 }
13666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13667 return resultobj;
13668 fail:
13669 return NULL;
13670 }
13671
13672
13673 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13674 PyObject *obj;
13675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13676 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13677 Py_INCREF(obj);
13678 return Py_BuildValue((char *)"");
13679 }
13680 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13681 PyObject *resultobj;
13682 wxPNMHandler *result;
13683 char *kwnames[] = {
13684 NULL
13685 };
13686
13687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13688 {
13689 PyThreadState* __tstate = wxPyBeginAllowThreads();
13690 result = (wxPNMHandler *)new wxPNMHandler();
13691
13692 wxPyEndAllowThreads(__tstate);
13693 if (PyErr_Occurred()) SWIG_fail;
13694 }
13695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13696 return resultobj;
13697 fail:
13698 return NULL;
13699 }
13700
13701
13702 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13703 PyObject *obj;
13704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13705 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13706 Py_INCREF(obj);
13707 return Py_BuildValue((char *)"");
13708 }
13709 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13710 PyObject *resultobj;
13711 wxXPMHandler *result;
13712 char *kwnames[] = {
13713 NULL
13714 };
13715
13716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13717 {
13718 PyThreadState* __tstate = wxPyBeginAllowThreads();
13719 result = (wxXPMHandler *)new wxXPMHandler();
13720
13721 wxPyEndAllowThreads(__tstate);
13722 if (PyErr_Occurred()) SWIG_fail;
13723 }
13724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13725 return resultobj;
13726 fail:
13727 return NULL;
13728 }
13729
13730
13731 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13732 PyObject *obj;
13733 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13734 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13735 Py_INCREF(obj);
13736 return Py_BuildValue((char *)"");
13737 }
13738 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13739 PyObject *resultobj;
13740 wxTIFFHandler *result;
13741 char *kwnames[] = {
13742 NULL
13743 };
13744
13745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13746 {
13747 PyThreadState* __tstate = wxPyBeginAllowThreads();
13748 result = (wxTIFFHandler *)new wxTIFFHandler();
13749
13750 wxPyEndAllowThreads(__tstate);
13751 if (PyErr_Occurred()) SWIG_fail;
13752 }
13753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13754 return resultobj;
13755 fail:
13756 return NULL;
13757 }
13758
13759
13760 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13761 PyObject *obj;
13762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13763 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13764 Py_INCREF(obj);
13765 return Py_BuildValue((char *)"");
13766 }
13767 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13768 PyObject *resultobj;
13769 wxImage *arg1 = 0 ;
13770 wxImage *arg2 = 0 ;
13771 int arg3 = (int) 236 ;
13772 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13773 bool result;
13774 PyObject * obj0 = 0 ;
13775 PyObject * obj1 = 0 ;
13776 PyObject * obj2 = 0 ;
13777 PyObject * obj3 = 0 ;
13778 char *kwnames[] = {
13779 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13780 };
13781
13782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13783 {
13784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13785 if (SWIG_arg_fail(1)) SWIG_fail;
13786 if (arg1 == NULL) {
13787 SWIG_null_ref("wxImage");
13788 }
13789 if (SWIG_arg_fail(1)) SWIG_fail;
13790 }
13791 {
13792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13793 if (SWIG_arg_fail(2)) SWIG_fail;
13794 if (arg2 == NULL) {
13795 SWIG_null_ref("wxImage");
13796 }
13797 if (SWIG_arg_fail(2)) SWIG_fail;
13798 }
13799 if (obj2) {
13800 {
13801 arg3 = (int)(SWIG_As_int(obj2));
13802 if (SWIG_arg_fail(3)) SWIG_fail;
13803 }
13804 }
13805 if (obj3) {
13806 {
13807 arg4 = (int)(SWIG_As_int(obj3));
13808 if (SWIG_arg_fail(4)) SWIG_fail;
13809 }
13810 }
13811 {
13812 PyThreadState* __tstate = wxPyBeginAllowThreads();
13813 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
13814
13815 wxPyEndAllowThreads(__tstate);
13816 if (PyErr_Occurred()) SWIG_fail;
13817 }
13818 {
13819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13820 }
13821 return resultobj;
13822 fail:
13823 return NULL;
13824 }
13825
13826
13827 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
13828 PyObject *obj;
13829 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13830 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
13831 Py_INCREF(obj);
13832 return Py_BuildValue((char *)"");
13833 }
13834 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13835 PyObject *resultobj;
13836 wxEvtHandler *result;
13837 char *kwnames[] = {
13838 NULL
13839 };
13840
13841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
13842 {
13843 PyThreadState* __tstate = wxPyBeginAllowThreads();
13844 result = (wxEvtHandler *)new wxEvtHandler();
13845
13846 wxPyEndAllowThreads(__tstate);
13847 if (PyErr_Occurred()) SWIG_fail;
13848 }
13849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
13850 return resultobj;
13851 fail:
13852 return NULL;
13853 }
13854
13855
13856 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13857 PyObject *resultobj;
13858 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13859 wxEvtHandler *result;
13860 PyObject * obj0 = 0 ;
13861 char *kwnames[] = {
13862 (char *) "self", NULL
13863 };
13864
13865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
13866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13867 if (SWIG_arg_fail(1)) SWIG_fail;
13868 {
13869 PyThreadState* __tstate = wxPyBeginAllowThreads();
13870 result = (wxEvtHandler *)(arg1)->GetNextHandler();
13871
13872 wxPyEndAllowThreads(__tstate);
13873 if (PyErr_Occurred()) SWIG_fail;
13874 }
13875 {
13876 resultobj = wxPyMake_wxObject(result, 0);
13877 }
13878 return resultobj;
13879 fail:
13880 return NULL;
13881 }
13882
13883
13884 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13885 PyObject *resultobj;
13886 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13887 wxEvtHandler *result;
13888 PyObject * obj0 = 0 ;
13889 char *kwnames[] = {
13890 (char *) "self", NULL
13891 };
13892
13893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
13894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13895 if (SWIG_arg_fail(1)) SWIG_fail;
13896 {
13897 PyThreadState* __tstate = wxPyBeginAllowThreads();
13898 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
13899
13900 wxPyEndAllowThreads(__tstate);
13901 if (PyErr_Occurred()) SWIG_fail;
13902 }
13903 {
13904 resultobj = wxPyMake_wxObject(result, 0);
13905 }
13906 return resultobj;
13907 fail:
13908 return NULL;
13909 }
13910
13911
13912 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13913 PyObject *resultobj;
13914 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13915 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13916 PyObject * obj0 = 0 ;
13917 PyObject * obj1 = 0 ;
13918 char *kwnames[] = {
13919 (char *) "self",(char *) "handler", NULL
13920 };
13921
13922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
13923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13924 if (SWIG_arg_fail(1)) SWIG_fail;
13925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13926 if (SWIG_arg_fail(2)) SWIG_fail;
13927 {
13928 PyThreadState* __tstate = wxPyBeginAllowThreads();
13929 (arg1)->SetNextHandler(arg2);
13930
13931 wxPyEndAllowThreads(__tstate);
13932 if (PyErr_Occurred()) SWIG_fail;
13933 }
13934 Py_INCREF(Py_None); resultobj = Py_None;
13935 return resultobj;
13936 fail:
13937 return NULL;
13938 }
13939
13940
13941 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13942 PyObject *resultobj;
13943 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13944 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13945 PyObject * obj0 = 0 ;
13946 PyObject * obj1 = 0 ;
13947 char *kwnames[] = {
13948 (char *) "self",(char *) "handler", NULL
13949 };
13950
13951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
13952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13953 if (SWIG_arg_fail(1)) SWIG_fail;
13954 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13955 if (SWIG_arg_fail(2)) SWIG_fail;
13956 {
13957 PyThreadState* __tstate = wxPyBeginAllowThreads();
13958 (arg1)->SetPreviousHandler(arg2);
13959
13960 wxPyEndAllowThreads(__tstate);
13961 if (PyErr_Occurred()) SWIG_fail;
13962 }
13963 Py_INCREF(Py_None); resultobj = Py_None;
13964 return resultobj;
13965 fail:
13966 return NULL;
13967 }
13968
13969
13970 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13971 PyObject *resultobj;
13972 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13973 bool result;
13974 PyObject * obj0 = 0 ;
13975 char *kwnames[] = {
13976 (char *) "self", NULL
13977 };
13978
13979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
13980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13981 if (SWIG_arg_fail(1)) SWIG_fail;
13982 {
13983 PyThreadState* __tstate = wxPyBeginAllowThreads();
13984 result = (bool)(arg1)->GetEvtHandlerEnabled();
13985
13986 wxPyEndAllowThreads(__tstate);
13987 if (PyErr_Occurred()) SWIG_fail;
13988 }
13989 {
13990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13991 }
13992 return resultobj;
13993 fail:
13994 return NULL;
13995 }
13996
13997
13998 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13999 PyObject *resultobj;
14000 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14001 bool arg2 ;
14002 PyObject * obj0 = 0 ;
14003 PyObject * obj1 = 0 ;
14004 char *kwnames[] = {
14005 (char *) "self",(char *) "enabled", NULL
14006 };
14007
14008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14010 if (SWIG_arg_fail(1)) SWIG_fail;
14011 {
14012 arg2 = (bool)(SWIG_As_bool(obj1));
14013 if (SWIG_arg_fail(2)) SWIG_fail;
14014 }
14015 {
14016 PyThreadState* __tstate = wxPyBeginAllowThreads();
14017 (arg1)->SetEvtHandlerEnabled(arg2);
14018
14019 wxPyEndAllowThreads(__tstate);
14020 if (PyErr_Occurred()) SWIG_fail;
14021 }
14022 Py_INCREF(Py_None); resultobj = Py_None;
14023 return resultobj;
14024 fail:
14025 return NULL;
14026 }
14027
14028
14029 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14030 PyObject *resultobj;
14031 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14032 wxEvent *arg2 = 0 ;
14033 bool result;
14034 PyObject * obj0 = 0 ;
14035 PyObject * obj1 = 0 ;
14036 char *kwnames[] = {
14037 (char *) "self",(char *) "event", NULL
14038 };
14039
14040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14042 if (SWIG_arg_fail(1)) SWIG_fail;
14043 {
14044 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14045 if (SWIG_arg_fail(2)) SWIG_fail;
14046 if (arg2 == NULL) {
14047 SWIG_null_ref("wxEvent");
14048 }
14049 if (SWIG_arg_fail(2)) SWIG_fail;
14050 }
14051 {
14052 PyThreadState* __tstate = wxPyBeginAllowThreads();
14053 result = (bool)(arg1)->ProcessEvent(*arg2);
14054
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 {
14059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14060 }
14061 return resultobj;
14062 fail:
14063 return NULL;
14064 }
14065
14066
14067 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14068 PyObject *resultobj;
14069 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14070 wxEvent *arg2 = 0 ;
14071 PyObject * obj0 = 0 ;
14072 PyObject * obj1 = 0 ;
14073 char *kwnames[] = {
14074 (char *) "self",(char *) "event", NULL
14075 };
14076
14077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14079 if (SWIG_arg_fail(1)) SWIG_fail;
14080 {
14081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14082 if (SWIG_arg_fail(2)) SWIG_fail;
14083 if (arg2 == NULL) {
14084 SWIG_null_ref("wxEvent");
14085 }
14086 if (SWIG_arg_fail(2)) SWIG_fail;
14087 }
14088 {
14089 PyThreadState* __tstate = wxPyBeginAllowThreads();
14090 (arg1)->AddPendingEvent(*arg2);
14091
14092 wxPyEndAllowThreads(__tstate);
14093 if (PyErr_Occurred()) SWIG_fail;
14094 }
14095 Py_INCREF(Py_None); resultobj = Py_None;
14096 return resultobj;
14097 fail:
14098 return NULL;
14099 }
14100
14101
14102 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14103 PyObject *resultobj;
14104 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14105 PyObject * obj0 = 0 ;
14106 char *kwnames[] = {
14107 (char *) "self", NULL
14108 };
14109
14110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14112 if (SWIG_arg_fail(1)) SWIG_fail;
14113 {
14114 PyThreadState* __tstate = wxPyBeginAllowThreads();
14115 (arg1)->ProcessPendingEvents();
14116
14117 wxPyEndAllowThreads(__tstate);
14118 if (PyErr_Occurred()) SWIG_fail;
14119 }
14120 Py_INCREF(Py_None); resultobj = Py_None;
14121 return resultobj;
14122 fail:
14123 return NULL;
14124 }
14125
14126
14127 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14128 PyObject *resultobj;
14129 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14130 int arg2 ;
14131 int arg3 ;
14132 int arg4 ;
14133 PyObject *arg5 = (PyObject *) 0 ;
14134 PyObject * obj0 = 0 ;
14135 PyObject * obj1 = 0 ;
14136 PyObject * obj2 = 0 ;
14137 PyObject * obj3 = 0 ;
14138 PyObject * obj4 = 0 ;
14139 char *kwnames[] = {
14140 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14141 };
14142
14143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14145 if (SWIG_arg_fail(1)) SWIG_fail;
14146 {
14147 arg2 = (int)(SWIG_As_int(obj1));
14148 if (SWIG_arg_fail(2)) SWIG_fail;
14149 }
14150 {
14151 arg3 = (int)(SWIG_As_int(obj2));
14152 if (SWIG_arg_fail(3)) SWIG_fail;
14153 }
14154 {
14155 arg4 = (int)(SWIG_As_int(obj3));
14156 if (SWIG_arg_fail(4)) SWIG_fail;
14157 }
14158 arg5 = obj4;
14159 {
14160 PyThreadState* __tstate = wxPyBeginAllowThreads();
14161 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14162
14163 wxPyEndAllowThreads(__tstate);
14164 if (PyErr_Occurred()) SWIG_fail;
14165 }
14166 Py_INCREF(Py_None); resultobj = Py_None;
14167 return resultobj;
14168 fail:
14169 return NULL;
14170 }
14171
14172
14173 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14174 PyObject *resultobj;
14175 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14176 int arg2 ;
14177 int arg3 = (int) -1 ;
14178 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14179 bool result;
14180 PyObject * obj0 = 0 ;
14181 PyObject * obj1 = 0 ;
14182 PyObject * obj2 = 0 ;
14183 PyObject * obj3 = 0 ;
14184 char *kwnames[] = {
14185 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14186 };
14187
14188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14190 if (SWIG_arg_fail(1)) SWIG_fail;
14191 {
14192 arg2 = (int)(SWIG_As_int(obj1));
14193 if (SWIG_arg_fail(2)) SWIG_fail;
14194 }
14195 if (obj2) {
14196 {
14197 arg3 = (int)(SWIG_As_int(obj2));
14198 if (SWIG_arg_fail(3)) SWIG_fail;
14199 }
14200 }
14201 if (obj3) {
14202 {
14203 arg4 = (wxEventType)(SWIG_As_int(obj3));
14204 if (SWIG_arg_fail(4)) SWIG_fail;
14205 }
14206 }
14207 {
14208 PyThreadState* __tstate = wxPyBeginAllowThreads();
14209 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14210
14211 wxPyEndAllowThreads(__tstate);
14212 if (PyErr_Occurred()) SWIG_fail;
14213 }
14214 {
14215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14216 }
14217 return resultobj;
14218 fail:
14219 return NULL;
14220 }
14221
14222
14223 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14224 PyObject *resultobj;
14225 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14226 PyObject *arg2 = (PyObject *) 0 ;
14227 bool arg3 = (bool) true ;
14228 PyObject * obj0 = 0 ;
14229 PyObject * obj1 = 0 ;
14230 PyObject * obj2 = 0 ;
14231 char *kwnames[] = {
14232 (char *) "self",(char *) "_self",(char *) "incref", NULL
14233 };
14234
14235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14237 if (SWIG_arg_fail(1)) SWIG_fail;
14238 arg2 = obj1;
14239 if (obj2) {
14240 {
14241 arg3 = (bool)(SWIG_As_bool(obj2));
14242 if (SWIG_arg_fail(3)) SWIG_fail;
14243 }
14244 }
14245 {
14246 PyThreadState* __tstate = wxPyBeginAllowThreads();
14247 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14248
14249 wxPyEndAllowThreads(__tstate);
14250 if (PyErr_Occurred()) SWIG_fail;
14251 }
14252 Py_INCREF(Py_None); resultobj = Py_None;
14253 return resultobj;
14254 fail:
14255 return NULL;
14256 }
14257
14258
14259 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14260 PyObject *obj;
14261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14262 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14263 Py_INCREF(obj);
14264 return Py_BuildValue((char *)"");
14265 }
14266 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14267 PyObject *resultobj;
14268 wxEventType result;
14269 char *kwnames[] = {
14270 NULL
14271 };
14272
14273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14274 {
14275 PyThreadState* __tstate = wxPyBeginAllowThreads();
14276 result = (wxEventType)wxNewEventType();
14277
14278 wxPyEndAllowThreads(__tstate);
14279 if (PyErr_Occurred()) SWIG_fail;
14280 }
14281 {
14282 resultobj = SWIG_From_int((int)(result));
14283 }
14284 return resultobj;
14285 fail:
14286 return NULL;
14287 }
14288
14289
14290 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14291 PyObject *resultobj;
14292 wxEvent *arg1 = (wxEvent *) 0 ;
14293 PyObject * obj0 = 0 ;
14294 char *kwnames[] = {
14295 (char *) "self", NULL
14296 };
14297
14298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14300 if (SWIG_arg_fail(1)) SWIG_fail;
14301 {
14302 PyThreadState* __tstate = wxPyBeginAllowThreads();
14303 delete arg1;
14304
14305 wxPyEndAllowThreads(__tstate);
14306 if (PyErr_Occurred()) SWIG_fail;
14307 }
14308 Py_INCREF(Py_None); resultobj = Py_None;
14309 return resultobj;
14310 fail:
14311 return NULL;
14312 }
14313
14314
14315 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14316 PyObject *resultobj;
14317 wxEvent *arg1 = (wxEvent *) 0 ;
14318 wxEventType arg2 ;
14319 PyObject * obj0 = 0 ;
14320 PyObject * obj1 = 0 ;
14321 char *kwnames[] = {
14322 (char *) "self",(char *) "typ", NULL
14323 };
14324
14325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14327 if (SWIG_arg_fail(1)) SWIG_fail;
14328 {
14329 arg2 = (wxEventType)(SWIG_As_int(obj1));
14330 if (SWIG_arg_fail(2)) SWIG_fail;
14331 }
14332 {
14333 PyThreadState* __tstate = wxPyBeginAllowThreads();
14334 (arg1)->SetEventType(arg2);
14335
14336 wxPyEndAllowThreads(__tstate);
14337 if (PyErr_Occurred()) SWIG_fail;
14338 }
14339 Py_INCREF(Py_None); resultobj = Py_None;
14340 return resultobj;
14341 fail:
14342 return NULL;
14343 }
14344
14345
14346 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14347 PyObject *resultobj;
14348 wxEvent *arg1 = (wxEvent *) 0 ;
14349 wxEventType result;
14350 PyObject * obj0 = 0 ;
14351 char *kwnames[] = {
14352 (char *) "self", NULL
14353 };
14354
14355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14357 if (SWIG_arg_fail(1)) SWIG_fail;
14358 {
14359 PyThreadState* __tstate = wxPyBeginAllowThreads();
14360 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14361
14362 wxPyEndAllowThreads(__tstate);
14363 if (PyErr_Occurred()) SWIG_fail;
14364 }
14365 {
14366 resultobj = SWIG_From_int((int)(result));
14367 }
14368 return resultobj;
14369 fail:
14370 return NULL;
14371 }
14372
14373
14374 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14375 PyObject *resultobj;
14376 wxEvent *arg1 = (wxEvent *) 0 ;
14377 wxObject *result;
14378 PyObject * obj0 = 0 ;
14379 char *kwnames[] = {
14380 (char *) "self", NULL
14381 };
14382
14383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14385 if (SWIG_arg_fail(1)) SWIG_fail;
14386 {
14387 PyThreadState* __tstate = wxPyBeginAllowThreads();
14388 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14389
14390 wxPyEndAllowThreads(__tstate);
14391 if (PyErr_Occurred()) SWIG_fail;
14392 }
14393 {
14394 resultobj = wxPyMake_wxObject(result, 0);
14395 }
14396 return resultobj;
14397 fail:
14398 return NULL;
14399 }
14400
14401
14402 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14403 PyObject *resultobj;
14404 wxEvent *arg1 = (wxEvent *) 0 ;
14405 wxObject *arg2 = (wxObject *) 0 ;
14406 PyObject * obj0 = 0 ;
14407 PyObject * obj1 = 0 ;
14408 char *kwnames[] = {
14409 (char *) "self",(char *) "obj", NULL
14410 };
14411
14412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14414 if (SWIG_arg_fail(1)) SWIG_fail;
14415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14416 if (SWIG_arg_fail(2)) SWIG_fail;
14417 {
14418 PyThreadState* __tstate = wxPyBeginAllowThreads();
14419 (arg1)->SetEventObject(arg2);
14420
14421 wxPyEndAllowThreads(__tstate);
14422 if (PyErr_Occurred()) SWIG_fail;
14423 }
14424 Py_INCREF(Py_None); resultobj = Py_None;
14425 return resultobj;
14426 fail:
14427 return NULL;
14428 }
14429
14430
14431 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14432 PyObject *resultobj;
14433 wxEvent *arg1 = (wxEvent *) 0 ;
14434 long result;
14435 PyObject * obj0 = 0 ;
14436 char *kwnames[] = {
14437 (char *) "self", NULL
14438 };
14439
14440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14442 if (SWIG_arg_fail(1)) SWIG_fail;
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14446
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 {
14451 resultobj = SWIG_From_long((long)(result));
14452 }
14453 return resultobj;
14454 fail:
14455 return NULL;
14456 }
14457
14458
14459 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14460 PyObject *resultobj;
14461 wxEvent *arg1 = (wxEvent *) 0 ;
14462 long arg2 = (long) 0 ;
14463 PyObject * obj0 = 0 ;
14464 PyObject * obj1 = 0 ;
14465 char *kwnames[] = {
14466 (char *) "self",(char *) "ts", NULL
14467 };
14468
14469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14471 if (SWIG_arg_fail(1)) SWIG_fail;
14472 if (obj1) {
14473 {
14474 arg2 = (long)(SWIG_As_long(obj1));
14475 if (SWIG_arg_fail(2)) SWIG_fail;
14476 }
14477 }
14478 {
14479 PyThreadState* __tstate = wxPyBeginAllowThreads();
14480 (arg1)->SetTimestamp(arg2);
14481
14482 wxPyEndAllowThreads(__tstate);
14483 if (PyErr_Occurred()) SWIG_fail;
14484 }
14485 Py_INCREF(Py_None); resultobj = Py_None;
14486 return resultobj;
14487 fail:
14488 return NULL;
14489 }
14490
14491
14492 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14493 PyObject *resultobj;
14494 wxEvent *arg1 = (wxEvent *) 0 ;
14495 int result;
14496 PyObject * obj0 = 0 ;
14497 char *kwnames[] = {
14498 (char *) "self", NULL
14499 };
14500
14501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14503 if (SWIG_arg_fail(1)) SWIG_fail;
14504 {
14505 PyThreadState* __tstate = wxPyBeginAllowThreads();
14506 result = (int)((wxEvent const *)arg1)->GetId();
14507
14508 wxPyEndAllowThreads(__tstate);
14509 if (PyErr_Occurred()) SWIG_fail;
14510 }
14511 {
14512 resultobj = SWIG_From_int((int)(result));
14513 }
14514 return resultobj;
14515 fail:
14516 return NULL;
14517 }
14518
14519
14520 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14521 PyObject *resultobj;
14522 wxEvent *arg1 = (wxEvent *) 0 ;
14523 int arg2 ;
14524 PyObject * obj0 = 0 ;
14525 PyObject * obj1 = 0 ;
14526 char *kwnames[] = {
14527 (char *) "self",(char *) "Id", NULL
14528 };
14529
14530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14532 if (SWIG_arg_fail(1)) SWIG_fail;
14533 {
14534 arg2 = (int)(SWIG_As_int(obj1));
14535 if (SWIG_arg_fail(2)) SWIG_fail;
14536 }
14537 {
14538 PyThreadState* __tstate = wxPyBeginAllowThreads();
14539 (arg1)->SetId(arg2);
14540
14541 wxPyEndAllowThreads(__tstate);
14542 if (PyErr_Occurred()) SWIG_fail;
14543 }
14544 Py_INCREF(Py_None); resultobj = Py_None;
14545 return resultobj;
14546 fail:
14547 return NULL;
14548 }
14549
14550
14551 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14552 PyObject *resultobj;
14553 wxEvent *arg1 = (wxEvent *) 0 ;
14554 bool result;
14555 PyObject * obj0 = 0 ;
14556 char *kwnames[] = {
14557 (char *) "self", NULL
14558 };
14559
14560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14562 if (SWIG_arg_fail(1)) SWIG_fail;
14563 {
14564 PyThreadState* __tstate = wxPyBeginAllowThreads();
14565 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14566
14567 wxPyEndAllowThreads(__tstate);
14568 if (PyErr_Occurred()) SWIG_fail;
14569 }
14570 {
14571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14572 }
14573 return resultobj;
14574 fail:
14575 return NULL;
14576 }
14577
14578
14579 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14580 PyObject *resultobj;
14581 wxEvent *arg1 = (wxEvent *) 0 ;
14582 bool arg2 = (bool) true ;
14583 PyObject * obj0 = 0 ;
14584 PyObject * obj1 = 0 ;
14585 char *kwnames[] = {
14586 (char *) "self",(char *) "skip", NULL
14587 };
14588
14589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14591 if (SWIG_arg_fail(1)) SWIG_fail;
14592 if (obj1) {
14593 {
14594 arg2 = (bool)(SWIG_As_bool(obj1));
14595 if (SWIG_arg_fail(2)) SWIG_fail;
14596 }
14597 }
14598 {
14599 PyThreadState* __tstate = wxPyBeginAllowThreads();
14600 (arg1)->Skip(arg2);
14601
14602 wxPyEndAllowThreads(__tstate);
14603 if (PyErr_Occurred()) SWIG_fail;
14604 }
14605 Py_INCREF(Py_None); resultobj = Py_None;
14606 return resultobj;
14607 fail:
14608 return NULL;
14609 }
14610
14611
14612 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14613 PyObject *resultobj;
14614 wxEvent *arg1 = (wxEvent *) 0 ;
14615 bool result;
14616 PyObject * obj0 = 0 ;
14617 char *kwnames[] = {
14618 (char *) "self", NULL
14619 };
14620
14621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14623 if (SWIG_arg_fail(1)) SWIG_fail;
14624 {
14625 PyThreadState* __tstate = wxPyBeginAllowThreads();
14626 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14627
14628 wxPyEndAllowThreads(__tstate);
14629 if (PyErr_Occurred()) SWIG_fail;
14630 }
14631 {
14632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14633 }
14634 return resultobj;
14635 fail:
14636 return NULL;
14637 }
14638
14639
14640 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14641 PyObject *resultobj;
14642 wxEvent *arg1 = (wxEvent *) 0 ;
14643 bool result;
14644 PyObject * obj0 = 0 ;
14645 char *kwnames[] = {
14646 (char *) "self", NULL
14647 };
14648
14649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14651 if (SWIG_arg_fail(1)) SWIG_fail;
14652 {
14653 PyThreadState* __tstate = wxPyBeginAllowThreads();
14654 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14655
14656 wxPyEndAllowThreads(__tstate);
14657 if (PyErr_Occurred()) SWIG_fail;
14658 }
14659 {
14660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14661 }
14662 return resultobj;
14663 fail:
14664 return NULL;
14665 }
14666
14667
14668 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14669 PyObject *resultobj;
14670 wxEvent *arg1 = (wxEvent *) 0 ;
14671 int result;
14672 PyObject * obj0 = 0 ;
14673 char *kwnames[] = {
14674 (char *) "self", NULL
14675 };
14676
14677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14679 if (SWIG_arg_fail(1)) SWIG_fail;
14680 {
14681 PyThreadState* __tstate = wxPyBeginAllowThreads();
14682 result = (int)(arg1)->StopPropagation();
14683
14684 wxPyEndAllowThreads(__tstate);
14685 if (PyErr_Occurred()) SWIG_fail;
14686 }
14687 {
14688 resultobj = SWIG_From_int((int)(result));
14689 }
14690 return resultobj;
14691 fail:
14692 return NULL;
14693 }
14694
14695
14696 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14697 PyObject *resultobj;
14698 wxEvent *arg1 = (wxEvent *) 0 ;
14699 int arg2 ;
14700 PyObject * obj0 = 0 ;
14701 PyObject * obj1 = 0 ;
14702 char *kwnames[] = {
14703 (char *) "self",(char *) "propagationLevel", NULL
14704 };
14705
14706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14708 if (SWIG_arg_fail(1)) SWIG_fail;
14709 {
14710 arg2 = (int)(SWIG_As_int(obj1));
14711 if (SWIG_arg_fail(2)) SWIG_fail;
14712 }
14713 {
14714 PyThreadState* __tstate = wxPyBeginAllowThreads();
14715 (arg1)->ResumePropagation(arg2);
14716
14717 wxPyEndAllowThreads(__tstate);
14718 if (PyErr_Occurred()) SWIG_fail;
14719 }
14720 Py_INCREF(Py_None); resultobj = Py_None;
14721 return resultobj;
14722 fail:
14723 return NULL;
14724 }
14725
14726
14727 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14728 PyObject *resultobj;
14729 wxEvent *arg1 = (wxEvent *) 0 ;
14730 wxEvent *result;
14731 PyObject * obj0 = 0 ;
14732 char *kwnames[] = {
14733 (char *) "self", NULL
14734 };
14735
14736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14738 if (SWIG_arg_fail(1)) SWIG_fail;
14739 {
14740 PyThreadState* __tstate = wxPyBeginAllowThreads();
14741 result = (wxEvent *)(arg1)->Clone();
14742
14743 wxPyEndAllowThreads(__tstate);
14744 if (PyErr_Occurred()) SWIG_fail;
14745 }
14746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14747 return resultobj;
14748 fail:
14749 return NULL;
14750 }
14751
14752
14753 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14754 PyObject *obj;
14755 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14756 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14757 Py_INCREF(obj);
14758 return Py_BuildValue((char *)"");
14759 }
14760 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14761 PyObject *resultobj;
14762 wxEvent *arg1 = 0 ;
14763 wxPropagationDisabler *result;
14764 PyObject * obj0 = 0 ;
14765 char *kwnames[] = {
14766 (char *) "event", NULL
14767 };
14768
14769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14770 {
14771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14772 if (SWIG_arg_fail(1)) SWIG_fail;
14773 if (arg1 == NULL) {
14774 SWIG_null_ref("wxEvent");
14775 }
14776 if (SWIG_arg_fail(1)) SWIG_fail;
14777 }
14778 {
14779 PyThreadState* __tstate = wxPyBeginAllowThreads();
14780 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14781
14782 wxPyEndAllowThreads(__tstate);
14783 if (PyErr_Occurred()) SWIG_fail;
14784 }
14785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14786 return resultobj;
14787 fail:
14788 return NULL;
14789 }
14790
14791
14792 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14793 PyObject *resultobj;
14794 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14795 PyObject * obj0 = 0 ;
14796 char *kwnames[] = {
14797 (char *) "self", NULL
14798 };
14799
14800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14802 if (SWIG_arg_fail(1)) SWIG_fail;
14803 {
14804 PyThreadState* __tstate = wxPyBeginAllowThreads();
14805 delete arg1;
14806
14807 wxPyEndAllowThreads(__tstate);
14808 if (PyErr_Occurred()) SWIG_fail;
14809 }
14810 Py_INCREF(Py_None); resultobj = Py_None;
14811 return resultobj;
14812 fail:
14813 return NULL;
14814 }
14815
14816
14817 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
14818 PyObject *obj;
14819 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14820 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
14821 Py_INCREF(obj);
14822 return Py_BuildValue((char *)"");
14823 }
14824 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14825 PyObject *resultobj;
14826 wxEvent *arg1 = 0 ;
14827 wxPropagateOnce *result;
14828 PyObject * obj0 = 0 ;
14829 char *kwnames[] = {
14830 (char *) "event", NULL
14831 };
14832
14833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
14834 {
14835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14836 if (SWIG_arg_fail(1)) SWIG_fail;
14837 if (arg1 == NULL) {
14838 SWIG_null_ref("wxEvent");
14839 }
14840 if (SWIG_arg_fail(1)) SWIG_fail;
14841 }
14842 {
14843 PyThreadState* __tstate = wxPyBeginAllowThreads();
14844 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
14845
14846 wxPyEndAllowThreads(__tstate);
14847 if (PyErr_Occurred()) SWIG_fail;
14848 }
14849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
14850 return resultobj;
14851 fail:
14852 return NULL;
14853 }
14854
14855
14856 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14857 PyObject *resultobj;
14858 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
14859 PyObject * obj0 = 0 ;
14860 char *kwnames[] = {
14861 (char *) "self", NULL
14862 };
14863
14864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
14865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
14866 if (SWIG_arg_fail(1)) SWIG_fail;
14867 {
14868 PyThreadState* __tstate = wxPyBeginAllowThreads();
14869 delete arg1;
14870
14871 wxPyEndAllowThreads(__tstate);
14872 if (PyErr_Occurred()) SWIG_fail;
14873 }
14874 Py_INCREF(Py_None); resultobj = Py_None;
14875 return resultobj;
14876 fail:
14877 return NULL;
14878 }
14879
14880
14881 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
14882 PyObject *obj;
14883 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14884 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
14885 Py_INCREF(obj);
14886 return Py_BuildValue((char *)"");
14887 }
14888 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14889 PyObject *resultobj;
14890 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
14891 int arg2 = (int) 0 ;
14892 wxCommandEvent *result;
14893 PyObject * obj0 = 0 ;
14894 PyObject * obj1 = 0 ;
14895 char *kwnames[] = {
14896 (char *) "commandType",(char *) "winid", NULL
14897 };
14898
14899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
14900 if (obj0) {
14901 {
14902 arg1 = (wxEventType)(SWIG_As_int(obj0));
14903 if (SWIG_arg_fail(1)) SWIG_fail;
14904 }
14905 }
14906 if (obj1) {
14907 {
14908 arg2 = (int)(SWIG_As_int(obj1));
14909 if (SWIG_arg_fail(2)) SWIG_fail;
14910 }
14911 }
14912 {
14913 PyThreadState* __tstate = wxPyBeginAllowThreads();
14914 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
14915
14916 wxPyEndAllowThreads(__tstate);
14917 if (PyErr_Occurred()) SWIG_fail;
14918 }
14919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
14920 return resultobj;
14921 fail:
14922 return NULL;
14923 }
14924
14925
14926 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14927 PyObject *resultobj;
14928 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14929 int result;
14930 PyObject * obj0 = 0 ;
14931 char *kwnames[] = {
14932 (char *) "self", NULL
14933 };
14934
14935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
14936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14937 if (SWIG_arg_fail(1)) SWIG_fail;
14938 {
14939 PyThreadState* __tstate = wxPyBeginAllowThreads();
14940 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
14941
14942 wxPyEndAllowThreads(__tstate);
14943 if (PyErr_Occurred()) SWIG_fail;
14944 }
14945 {
14946 resultobj = SWIG_From_int((int)(result));
14947 }
14948 return resultobj;
14949 fail:
14950 return NULL;
14951 }
14952
14953
14954 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
14955 PyObject *resultobj;
14956 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14957 wxString *arg2 = 0 ;
14958 bool temp2 = false ;
14959 PyObject * obj0 = 0 ;
14960 PyObject * obj1 = 0 ;
14961 char *kwnames[] = {
14962 (char *) "self",(char *) "s", NULL
14963 };
14964
14965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
14966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14967 if (SWIG_arg_fail(1)) SWIG_fail;
14968 {
14969 arg2 = wxString_in_helper(obj1);
14970 if (arg2 == NULL) SWIG_fail;
14971 temp2 = true;
14972 }
14973 {
14974 PyThreadState* __tstate = wxPyBeginAllowThreads();
14975 (arg1)->SetString((wxString const &)*arg2);
14976
14977 wxPyEndAllowThreads(__tstate);
14978 if (PyErr_Occurred()) SWIG_fail;
14979 }
14980 Py_INCREF(Py_None); resultobj = Py_None;
14981 {
14982 if (temp2)
14983 delete arg2;
14984 }
14985 return resultobj;
14986 fail:
14987 {
14988 if (temp2)
14989 delete arg2;
14990 }
14991 return NULL;
14992 }
14993
14994
14995 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
14996 PyObject *resultobj;
14997 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14998 wxString result;
14999 PyObject * obj0 = 0 ;
15000 char *kwnames[] = {
15001 (char *) "self", NULL
15002 };
15003
15004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15006 if (SWIG_arg_fail(1)) SWIG_fail;
15007 {
15008 PyThreadState* __tstate = wxPyBeginAllowThreads();
15009 result = ((wxCommandEvent const *)arg1)->GetString();
15010
15011 wxPyEndAllowThreads(__tstate);
15012 if (PyErr_Occurred()) SWIG_fail;
15013 }
15014 {
15015 #if wxUSE_UNICODE
15016 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15017 #else
15018 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15019 #endif
15020 }
15021 return resultobj;
15022 fail:
15023 return NULL;
15024 }
15025
15026
15027 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15028 PyObject *resultobj;
15029 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15030 bool result;
15031 PyObject * obj0 = 0 ;
15032 char *kwnames[] = {
15033 (char *) "self", NULL
15034 };
15035
15036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15038 if (SWIG_arg_fail(1)) SWIG_fail;
15039 {
15040 PyThreadState* __tstate = wxPyBeginAllowThreads();
15041 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15042
15043 wxPyEndAllowThreads(__tstate);
15044 if (PyErr_Occurred()) SWIG_fail;
15045 }
15046 {
15047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15048 }
15049 return resultobj;
15050 fail:
15051 return NULL;
15052 }
15053
15054
15055 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15056 PyObject *resultobj;
15057 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15058 bool result;
15059 PyObject * obj0 = 0 ;
15060 char *kwnames[] = {
15061 (char *) "self", NULL
15062 };
15063
15064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15066 if (SWIG_arg_fail(1)) SWIG_fail;
15067 {
15068 PyThreadState* __tstate = wxPyBeginAllowThreads();
15069 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15070
15071 wxPyEndAllowThreads(__tstate);
15072 if (PyErr_Occurred()) SWIG_fail;
15073 }
15074 {
15075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15076 }
15077 return resultobj;
15078 fail:
15079 return NULL;
15080 }
15081
15082
15083 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15084 PyObject *resultobj;
15085 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15086 long arg2 ;
15087 PyObject * obj0 = 0 ;
15088 PyObject * obj1 = 0 ;
15089 char *kwnames[] = {
15090 (char *) "self",(char *) "extraLong", NULL
15091 };
15092
15093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15095 if (SWIG_arg_fail(1)) SWIG_fail;
15096 {
15097 arg2 = (long)(SWIG_As_long(obj1));
15098 if (SWIG_arg_fail(2)) SWIG_fail;
15099 }
15100 {
15101 PyThreadState* __tstate = wxPyBeginAllowThreads();
15102 (arg1)->SetExtraLong(arg2);
15103
15104 wxPyEndAllowThreads(__tstate);
15105 if (PyErr_Occurred()) SWIG_fail;
15106 }
15107 Py_INCREF(Py_None); resultobj = Py_None;
15108 return resultobj;
15109 fail:
15110 return NULL;
15111 }
15112
15113
15114 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15115 PyObject *resultobj;
15116 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15117 long result;
15118 PyObject * obj0 = 0 ;
15119 char *kwnames[] = {
15120 (char *) "self", NULL
15121 };
15122
15123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15125 if (SWIG_arg_fail(1)) SWIG_fail;
15126 {
15127 PyThreadState* __tstate = wxPyBeginAllowThreads();
15128 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15129
15130 wxPyEndAllowThreads(__tstate);
15131 if (PyErr_Occurred()) SWIG_fail;
15132 }
15133 {
15134 resultobj = SWIG_From_long((long)(result));
15135 }
15136 return resultobj;
15137 fail:
15138 return NULL;
15139 }
15140
15141
15142 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15143 PyObject *resultobj;
15144 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15145 int arg2 ;
15146 PyObject * obj0 = 0 ;
15147 PyObject * obj1 = 0 ;
15148 char *kwnames[] = {
15149 (char *) "self",(char *) "i", NULL
15150 };
15151
15152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15154 if (SWIG_arg_fail(1)) SWIG_fail;
15155 {
15156 arg2 = (int)(SWIG_As_int(obj1));
15157 if (SWIG_arg_fail(2)) SWIG_fail;
15158 }
15159 {
15160 PyThreadState* __tstate = wxPyBeginAllowThreads();
15161 (arg1)->SetInt(arg2);
15162
15163 wxPyEndAllowThreads(__tstate);
15164 if (PyErr_Occurred()) SWIG_fail;
15165 }
15166 Py_INCREF(Py_None); resultobj = Py_None;
15167 return resultobj;
15168 fail:
15169 return NULL;
15170 }
15171
15172
15173 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15174 PyObject *resultobj;
15175 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15176 long result;
15177 PyObject * obj0 = 0 ;
15178 char *kwnames[] = {
15179 (char *) "self", NULL
15180 };
15181
15182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15184 if (SWIG_arg_fail(1)) SWIG_fail;
15185 {
15186 PyThreadState* __tstate = wxPyBeginAllowThreads();
15187 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15188
15189 wxPyEndAllowThreads(__tstate);
15190 if (PyErr_Occurred()) SWIG_fail;
15191 }
15192 {
15193 resultobj = SWIG_From_long((long)(result));
15194 }
15195 return resultobj;
15196 fail:
15197 return NULL;
15198 }
15199
15200
15201 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15202 PyObject *resultobj;
15203 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15204 wxEvent *result;
15205 PyObject * obj0 = 0 ;
15206 char *kwnames[] = {
15207 (char *) "self", NULL
15208 };
15209
15210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15212 if (SWIG_arg_fail(1)) SWIG_fail;
15213 {
15214 PyThreadState* __tstate = wxPyBeginAllowThreads();
15215 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15216
15217 wxPyEndAllowThreads(__tstate);
15218 if (PyErr_Occurred()) SWIG_fail;
15219 }
15220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15221 return resultobj;
15222 fail:
15223 return NULL;
15224 }
15225
15226
15227 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15228 PyObject *obj;
15229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15230 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15231 Py_INCREF(obj);
15232 return Py_BuildValue((char *)"");
15233 }
15234 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15235 PyObject *resultobj;
15236 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15237 int arg2 = (int) 0 ;
15238 wxNotifyEvent *result;
15239 PyObject * obj0 = 0 ;
15240 PyObject * obj1 = 0 ;
15241 char *kwnames[] = {
15242 (char *) "commandType",(char *) "winid", NULL
15243 };
15244
15245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15246 if (obj0) {
15247 {
15248 arg1 = (wxEventType)(SWIG_As_int(obj0));
15249 if (SWIG_arg_fail(1)) SWIG_fail;
15250 }
15251 }
15252 if (obj1) {
15253 {
15254 arg2 = (int)(SWIG_As_int(obj1));
15255 if (SWIG_arg_fail(2)) SWIG_fail;
15256 }
15257 }
15258 {
15259 PyThreadState* __tstate = wxPyBeginAllowThreads();
15260 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15261
15262 wxPyEndAllowThreads(__tstate);
15263 if (PyErr_Occurred()) SWIG_fail;
15264 }
15265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15266 return resultobj;
15267 fail:
15268 return NULL;
15269 }
15270
15271
15272 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15273 PyObject *resultobj;
15274 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15275 PyObject * obj0 = 0 ;
15276 char *kwnames[] = {
15277 (char *) "self", NULL
15278 };
15279
15280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15282 if (SWIG_arg_fail(1)) SWIG_fail;
15283 {
15284 PyThreadState* __tstate = wxPyBeginAllowThreads();
15285 (arg1)->Veto();
15286
15287 wxPyEndAllowThreads(__tstate);
15288 if (PyErr_Occurred()) SWIG_fail;
15289 }
15290 Py_INCREF(Py_None); resultobj = Py_None;
15291 return resultobj;
15292 fail:
15293 return NULL;
15294 }
15295
15296
15297 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15298 PyObject *resultobj;
15299 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15300 PyObject * obj0 = 0 ;
15301 char *kwnames[] = {
15302 (char *) "self", NULL
15303 };
15304
15305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15307 if (SWIG_arg_fail(1)) SWIG_fail;
15308 {
15309 PyThreadState* __tstate = wxPyBeginAllowThreads();
15310 (arg1)->Allow();
15311
15312 wxPyEndAllowThreads(__tstate);
15313 if (PyErr_Occurred()) SWIG_fail;
15314 }
15315 Py_INCREF(Py_None); resultobj = Py_None;
15316 return resultobj;
15317 fail:
15318 return NULL;
15319 }
15320
15321
15322 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15323 PyObject *resultobj;
15324 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15325 bool result;
15326 PyObject * obj0 = 0 ;
15327 char *kwnames[] = {
15328 (char *) "self", NULL
15329 };
15330
15331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15333 if (SWIG_arg_fail(1)) SWIG_fail;
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 result = (bool)(arg1)->IsAllowed();
15337
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 {
15342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15343 }
15344 return resultobj;
15345 fail:
15346 return NULL;
15347 }
15348
15349
15350 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15351 PyObject *obj;
15352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15353 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15354 Py_INCREF(obj);
15355 return Py_BuildValue((char *)"");
15356 }
15357 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15358 PyObject *resultobj;
15359 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15360 int arg2 = (int) 0 ;
15361 int arg3 = (int) 0 ;
15362 int arg4 = (int) 0 ;
15363 wxScrollEvent *result;
15364 PyObject * obj0 = 0 ;
15365 PyObject * obj1 = 0 ;
15366 PyObject * obj2 = 0 ;
15367 PyObject * obj3 = 0 ;
15368 char *kwnames[] = {
15369 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15370 };
15371
15372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15373 if (obj0) {
15374 {
15375 arg1 = (wxEventType)(SWIG_As_int(obj0));
15376 if (SWIG_arg_fail(1)) SWIG_fail;
15377 }
15378 }
15379 if (obj1) {
15380 {
15381 arg2 = (int)(SWIG_As_int(obj1));
15382 if (SWIG_arg_fail(2)) SWIG_fail;
15383 }
15384 }
15385 if (obj2) {
15386 {
15387 arg3 = (int)(SWIG_As_int(obj2));
15388 if (SWIG_arg_fail(3)) SWIG_fail;
15389 }
15390 }
15391 if (obj3) {
15392 {
15393 arg4 = (int)(SWIG_As_int(obj3));
15394 if (SWIG_arg_fail(4)) SWIG_fail;
15395 }
15396 }
15397 {
15398 PyThreadState* __tstate = wxPyBeginAllowThreads();
15399 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15400
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15405 return resultobj;
15406 fail:
15407 return NULL;
15408 }
15409
15410
15411 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15412 PyObject *resultobj;
15413 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15414 int result;
15415 PyObject * obj0 = 0 ;
15416 char *kwnames[] = {
15417 (char *) "self", NULL
15418 };
15419
15420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15422 if (SWIG_arg_fail(1)) SWIG_fail;
15423 {
15424 PyThreadState* __tstate = wxPyBeginAllowThreads();
15425 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15426
15427 wxPyEndAllowThreads(__tstate);
15428 if (PyErr_Occurred()) SWIG_fail;
15429 }
15430 {
15431 resultobj = SWIG_From_int((int)(result));
15432 }
15433 return resultobj;
15434 fail:
15435 return NULL;
15436 }
15437
15438
15439 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15440 PyObject *resultobj;
15441 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15442 int result;
15443 PyObject * obj0 = 0 ;
15444 char *kwnames[] = {
15445 (char *) "self", NULL
15446 };
15447
15448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15450 if (SWIG_arg_fail(1)) SWIG_fail;
15451 {
15452 PyThreadState* __tstate = wxPyBeginAllowThreads();
15453 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15454
15455 wxPyEndAllowThreads(__tstate);
15456 if (PyErr_Occurred()) SWIG_fail;
15457 }
15458 {
15459 resultobj = SWIG_From_int((int)(result));
15460 }
15461 return resultobj;
15462 fail:
15463 return NULL;
15464 }
15465
15466
15467 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15468 PyObject *resultobj;
15469 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15470 int arg2 ;
15471 PyObject * obj0 = 0 ;
15472 PyObject * obj1 = 0 ;
15473 char *kwnames[] = {
15474 (char *) "self",(char *) "orient", NULL
15475 };
15476
15477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15479 if (SWIG_arg_fail(1)) SWIG_fail;
15480 {
15481 arg2 = (int)(SWIG_As_int(obj1));
15482 if (SWIG_arg_fail(2)) SWIG_fail;
15483 }
15484 {
15485 PyThreadState* __tstate = wxPyBeginAllowThreads();
15486 (arg1)->SetOrientation(arg2);
15487
15488 wxPyEndAllowThreads(__tstate);
15489 if (PyErr_Occurred()) SWIG_fail;
15490 }
15491 Py_INCREF(Py_None); resultobj = Py_None;
15492 return resultobj;
15493 fail:
15494 return NULL;
15495 }
15496
15497
15498 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15499 PyObject *resultobj;
15500 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15501 int arg2 ;
15502 PyObject * obj0 = 0 ;
15503 PyObject * obj1 = 0 ;
15504 char *kwnames[] = {
15505 (char *) "self",(char *) "pos", NULL
15506 };
15507
15508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15510 if (SWIG_arg_fail(1)) SWIG_fail;
15511 {
15512 arg2 = (int)(SWIG_As_int(obj1));
15513 if (SWIG_arg_fail(2)) SWIG_fail;
15514 }
15515 {
15516 PyThreadState* __tstate = wxPyBeginAllowThreads();
15517 (arg1)->SetPosition(arg2);
15518
15519 wxPyEndAllowThreads(__tstate);
15520 if (PyErr_Occurred()) SWIG_fail;
15521 }
15522 Py_INCREF(Py_None); resultobj = Py_None;
15523 return resultobj;
15524 fail:
15525 return NULL;
15526 }
15527
15528
15529 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15530 PyObject *obj;
15531 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15532 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15533 Py_INCREF(obj);
15534 return Py_BuildValue((char *)"");
15535 }
15536 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15537 PyObject *resultobj;
15538 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15539 int arg2 = (int) 0 ;
15540 int arg3 = (int) 0 ;
15541 wxScrollWinEvent *result;
15542 PyObject * obj0 = 0 ;
15543 PyObject * obj1 = 0 ;
15544 PyObject * obj2 = 0 ;
15545 char *kwnames[] = {
15546 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15547 };
15548
15549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15550 if (obj0) {
15551 {
15552 arg1 = (wxEventType)(SWIG_As_int(obj0));
15553 if (SWIG_arg_fail(1)) SWIG_fail;
15554 }
15555 }
15556 if (obj1) {
15557 {
15558 arg2 = (int)(SWIG_As_int(obj1));
15559 if (SWIG_arg_fail(2)) SWIG_fail;
15560 }
15561 }
15562 if (obj2) {
15563 {
15564 arg3 = (int)(SWIG_As_int(obj2));
15565 if (SWIG_arg_fail(3)) SWIG_fail;
15566 }
15567 }
15568 {
15569 PyThreadState* __tstate = wxPyBeginAllowThreads();
15570 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15571
15572 wxPyEndAllowThreads(__tstate);
15573 if (PyErr_Occurred()) SWIG_fail;
15574 }
15575 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15576 return resultobj;
15577 fail:
15578 return NULL;
15579 }
15580
15581
15582 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15583 PyObject *resultobj;
15584 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15585 int result;
15586 PyObject * obj0 = 0 ;
15587 char *kwnames[] = {
15588 (char *) "self", NULL
15589 };
15590
15591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15593 if (SWIG_arg_fail(1)) SWIG_fail;
15594 {
15595 PyThreadState* __tstate = wxPyBeginAllowThreads();
15596 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15597
15598 wxPyEndAllowThreads(__tstate);
15599 if (PyErr_Occurred()) SWIG_fail;
15600 }
15601 {
15602 resultobj = SWIG_From_int((int)(result));
15603 }
15604 return resultobj;
15605 fail:
15606 return NULL;
15607 }
15608
15609
15610 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15611 PyObject *resultobj;
15612 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15613 int result;
15614 PyObject * obj0 = 0 ;
15615 char *kwnames[] = {
15616 (char *) "self", NULL
15617 };
15618
15619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15621 if (SWIG_arg_fail(1)) SWIG_fail;
15622 {
15623 PyThreadState* __tstate = wxPyBeginAllowThreads();
15624 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15625
15626 wxPyEndAllowThreads(__tstate);
15627 if (PyErr_Occurred()) SWIG_fail;
15628 }
15629 {
15630 resultobj = SWIG_From_int((int)(result));
15631 }
15632 return resultobj;
15633 fail:
15634 return NULL;
15635 }
15636
15637
15638 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15639 PyObject *resultobj;
15640 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15641 int arg2 ;
15642 PyObject * obj0 = 0 ;
15643 PyObject * obj1 = 0 ;
15644 char *kwnames[] = {
15645 (char *) "self",(char *) "orient", NULL
15646 };
15647
15648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15650 if (SWIG_arg_fail(1)) SWIG_fail;
15651 {
15652 arg2 = (int)(SWIG_As_int(obj1));
15653 if (SWIG_arg_fail(2)) SWIG_fail;
15654 }
15655 {
15656 PyThreadState* __tstate = wxPyBeginAllowThreads();
15657 (arg1)->SetOrientation(arg2);
15658
15659 wxPyEndAllowThreads(__tstate);
15660 if (PyErr_Occurred()) SWIG_fail;
15661 }
15662 Py_INCREF(Py_None); resultobj = Py_None;
15663 return resultobj;
15664 fail:
15665 return NULL;
15666 }
15667
15668
15669 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15670 PyObject *resultobj;
15671 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15672 int arg2 ;
15673 PyObject * obj0 = 0 ;
15674 PyObject * obj1 = 0 ;
15675 char *kwnames[] = {
15676 (char *) "self",(char *) "pos", NULL
15677 };
15678
15679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15681 if (SWIG_arg_fail(1)) SWIG_fail;
15682 {
15683 arg2 = (int)(SWIG_As_int(obj1));
15684 if (SWIG_arg_fail(2)) SWIG_fail;
15685 }
15686 {
15687 PyThreadState* __tstate = wxPyBeginAllowThreads();
15688 (arg1)->SetPosition(arg2);
15689
15690 wxPyEndAllowThreads(__tstate);
15691 if (PyErr_Occurred()) SWIG_fail;
15692 }
15693 Py_INCREF(Py_None); resultobj = Py_None;
15694 return resultobj;
15695 fail:
15696 return NULL;
15697 }
15698
15699
15700 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15701 PyObject *obj;
15702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15703 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15704 Py_INCREF(obj);
15705 return Py_BuildValue((char *)"");
15706 }
15707 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15708 PyObject *resultobj;
15709 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15710 wxMouseEvent *result;
15711 PyObject * obj0 = 0 ;
15712 char *kwnames[] = {
15713 (char *) "mouseType", NULL
15714 };
15715
15716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15717 if (obj0) {
15718 {
15719 arg1 = (wxEventType)(SWIG_As_int(obj0));
15720 if (SWIG_arg_fail(1)) SWIG_fail;
15721 }
15722 }
15723 {
15724 PyThreadState* __tstate = wxPyBeginAllowThreads();
15725 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15726
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 {
15731 resultobj = wxPyMake_wxObject(result, 1);
15732 }
15733 return resultobj;
15734 fail:
15735 return NULL;
15736 }
15737
15738
15739 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15740 PyObject *resultobj;
15741 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15742 bool result;
15743 PyObject * obj0 = 0 ;
15744 char *kwnames[] = {
15745 (char *) "self", NULL
15746 };
15747
15748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15750 if (SWIG_arg_fail(1)) SWIG_fail;
15751 {
15752 PyThreadState* __tstate = wxPyBeginAllowThreads();
15753 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15754
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 {
15759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15760 }
15761 return resultobj;
15762 fail:
15763 return NULL;
15764 }
15765
15766
15767 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15768 PyObject *resultobj;
15769 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15770 int arg2 = (int) wxMOUSE_BTN_ANY ;
15771 bool result;
15772 PyObject * obj0 = 0 ;
15773 PyObject * obj1 = 0 ;
15774 char *kwnames[] = {
15775 (char *) "self",(char *) "but", NULL
15776 };
15777
15778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15780 if (SWIG_arg_fail(1)) SWIG_fail;
15781 if (obj1) {
15782 {
15783 arg2 = (int)(SWIG_As_int(obj1));
15784 if (SWIG_arg_fail(2)) SWIG_fail;
15785 }
15786 }
15787 {
15788 PyThreadState* __tstate = wxPyBeginAllowThreads();
15789 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15790
15791 wxPyEndAllowThreads(__tstate);
15792 if (PyErr_Occurred()) SWIG_fail;
15793 }
15794 {
15795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15796 }
15797 return resultobj;
15798 fail:
15799 return NULL;
15800 }
15801
15802
15803 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15804 PyObject *resultobj;
15805 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15806 int arg2 = (int) wxMOUSE_BTN_ANY ;
15807 bool result;
15808 PyObject * obj0 = 0 ;
15809 PyObject * obj1 = 0 ;
15810 char *kwnames[] = {
15811 (char *) "self",(char *) "but", NULL
15812 };
15813
15814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
15815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15816 if (SWIG_arg_fail(1)) SWIG_fail;
15817 if (obj1) {
15818 {
15819 arg2 = (int)(SWIG_As_int(obj1));
15820 if (SWIG_arg_fail(2)) SWIG_fail;
15821 }
15822 }
15823 {
15824 PyThreadState* __tstate = wxPyBeginAllowThreads();
15825 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
15826
15827 wxPyEndAllowThreads(__tstate);
15828 if (PyErr_Occurred()) SWIG_fail;
15829 }
15830 {
15831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15832 }
15833 return resultobj;
15834 fail:
15835 return NULL;
15836 }
15837
15838
15839 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
15840 PyObject *resultobj;
15841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15842 int arg2 = (int) wxMOUSE_BTN_ANY ;
15843 bool result;
15844 PyObject * obj0 = 0 ;
15845 PyObject * obj1 = 0 ;
15846 char *kwnames[] = {
15847 (char *) "self",(char *) "but", NULL
15848 };
15849
15850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
15851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15852 if (SWIG_arg_fail(1)) SWIG_fail;
15853 if (obj1) {
15854 {
15855 arg2 = (int)(SWIG_As_int(obj1));
15856 if (SWIG_arg_fail(2)) SWIG_fail;
15857 }
15858 }
15859 {
15860 PyThreadState* __tstate = wxPyBeginAllowThreads();
15861 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
15862
15863 wxPyEndAllowThreads(__tstate);
15864 if (PyErr_Occurred()) SWIG_fail;
15865 }
15866 {
15867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15868 }
15869 return resultobj;
15870 fail:
15871 return NULL;
15872 }
15873
15874
15875 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
15876 PyObject *resultobj;
15877 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15878 int arg2 ;
15879 bool result;
15880 PyObject * obj0 = 0 ;
15881 PyObject * obj1 = 0 ;
15882 char *kwnames[] = {
15883 (char *) "self",(char *) "but", NULL
15884 };
15885
15886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
15887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15888 if (SWIG_arg_fail(1)) SWIG_fail;
15889 {
15890 arg2 = (int)(SWIG_As_int(obj1));
15891 if (SWIG_arg_fail(2)) SWIG_fail;
15892 }
15893 {
15894 PyThreadState* __tstate = wxPyBeginAllowThreads();
15895 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
15896
15897 wxPyEndAllowThreads(__tstate);
15898 if (PyErr_Occurred()) SWIG_fail;
15899 }
15900 {
15901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15902 }
15903 return resultobj;
15904 fail:
15905 return NULL;
15906 }
15907
15908
15909 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
15910 PyObject *resultobj;
15911 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15912 int arg2 ;
15913 bool result;
15914 PyObject * obj0 = 0 ;
15915 PyObject * obj1 = 0 ;
15916 char *kwnames[] = {
15917 (char *) "self",(char *) "but", NULL
15918 };
15919
15920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
15921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15922 if (SWIG_arg_fail(1)) SWIG_fail;
15923 {
15924 arg2 = (int)(SWIG_As_int(obj1));
15925 if (SWIG_arg_fail(2)) SWIG_fail;
15926 }
15927 {
15928 PyThreadState* __tstate = wxPyBeginAllowThreads();
15929 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
15930
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 {
15935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15936 }
15937 return resultobj;
15938 fail:
15939 return NULL;
15940 }
15941
15942
15943 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
15944 PyObject *resultobj;
15945 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15946 int result;
15947 PyObject * obj0 = 0 ;
15948 char *kwnames[] = {
15949 (char *) "self", NULL
15950 };
15951
15952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
15953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15954 if (SWIG_arg_fail(1)) SWIG_fail;
15955 {
15956 PyThreadState* __tstate = wxPyBeginAllowThreads();
15957 result = (int)((wxMouseEvent const *)arg1)->GetButton();
15958
15959 wxPyEndAllowThreads(__tstate);
15960 if (PyErr_Occurred()) SWIG_fail;
15961 }
15962 {
15963 resultobj = SWIG_From_int((int)(result));
15964 }
15965 return resultobj;
15966 fail:
15967 return NULL;
15968 }
15969
15970
15971 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
15972 PyObject *resultobj;
15973 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15974 bool result;
15975 PyObject * obj0 = 0 ;
15976 char *kwnames[] = {
15977 (char *) "self", NULL
15978 };
15979
15980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
15981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15982 if (SWIG_arg_fail(1)) SWIG_fail;
15983 {
15984 PyThreadState* __tstate = wxPyBeginAllowThreads();
15985 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
15986
15987 wxPyEndAllowThreads(__tstate);
15988 if (PyErr_Occurred()) SWIG_fail;
15989 }
15990 {
15991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15992 }
15993 return resultobj;
15994 fail:
15995 return NULL;
15996 }
15997
15998
15999 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16000 PyObject *resultobj;
16001 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16002 bool result;
16003 PyObject * obj0 = 0 ;
16004 char *kwnames[] = {
16005 (char *) "self", NULL
16006 };
16007
16008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16010 if (SWIG_arg_fail(1)) SWIG_fail;
16011 {
16012 PyThreadState* __tstate = wxPyBeginAllowThreads();
16013 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16014
16015 wxPyEndAllowThreads(__tstate);
16016 if (PyErr_Occurred()) SWIG_fail;
16017 }
16018 {
16019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16020 }
16021 return resultobj;
16022 fail:
16023 return NULL;
16024 }
16025
16026
16027 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16028 PyObject *resultobj;
16029 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16030 bool result;
16031 PyObject * obj0 = 0 ;
16032 char *kwnames[] = {
16033 (char *) "self", NULL
16034 };
16035
16036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16038 if (SWIG_arg_fail(1)) SWIG_fail;
16039 {
16040 PyThreadState* __tstate = wxPyBeginAllowThreads();
16041 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16042
16043 wxPyEndAllowThreads(__tstate);
16044 if (PyErr_Occurred()) SWIG_fail;
16045 }
16046 {
16047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16048 }
16049 return resultobj;
16050 fail:
16051 return NULL;
16052 }
16053
16054
16055 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16056 PyObject *resultobj;
16057 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16058 bool result;
16059 PyObject * obj0 = 0 ;
16060 char *kwnames[] = {
16061 (char *) "self", NULL
16062 };
16063
16064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16066 if (SWIG_arg_fail(1)) SWIG_fail;
16067 {
16068 PyThreadState* __tstate = wxPyBeginAllowThreads();
16069 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16070
16071 wxPyEndAllowThreads(__tstate);
16072 if (PyErr_Occurred()) SWIG_fail;
16073 }
16074 {
16075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16076 }
16077 return resultobj;
16078 fail:
16079 return NULL;
16080 }
16081
16082
16083 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16084 PyObject *resultobj;
16085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16086 bool result;
16087 PyObject * obj0 = 0 ;
16088 char *kwnames[] = {
16089 (char *) "self", NULL
16090 };
16091
16092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16094 if (SWIG_arg_fail(1)) SWIG_fail;
16095 {
16096 PyThreadState* __tstate = wxPyBeginAllowThreads();
16097 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16098
16099 wxPyEndAllowThreads(__tstate);
16100 if (PyErr_Occurred()) SWIG_fail;
16101 }
16102 {
16103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16104 }
16105 return resultobj;
16106 fail:
16107 return NULL;
16108 }
16109
16110
16111 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16112 PyObject *resultobj;
16113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16114 bool result;
16115 PyObject * obj0 = 0 ;
16116 char *kwnames[] = {
16117 (char *) "self", NULL
16118 };
16119
16120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16122 if (SWIG_arg_fail(1)) SWIG_fail;
16123 {
16124 PyThreadState* __tstate = wxPyBeginAllowThreads();
16125 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16126
16127 wxPyEndAllowThreads(__tstate);
16128 if (PyErr_Occurred()) SWIG_fail;
16129 }
16130 {
16131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16132 }
16133 return resultobj;
16134 fail:
16135 return NULL;
16136 }
16137
16138
16139 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16140 PyObject *resultobj;
16141 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16142 bool result;
16143 PyObject * obj0 = 0 ;
16144 char *kwnames[] = {
16145 (char *) "self", NULL
16146 };
16147
16148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16150 if (SWIG_arg_fail(1)) SWIG_fail;
16151 {
16152 PyThreadState* __tstate = wxPyBeginAllowThreads();
16153 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16154
16155 wxPyEndAllowThreads(__tstate);
16156 if (PyErr_Occurred()) SWIG_fail;
16157 }
16158 {
16159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16160 }
16161 return resultobj;
16162 fail:
16163 return NULL;
16164 }
16165
16166
16167 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16168 PyObject *resultobj;
16169 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16170 bool result;
16171 PyObject * obj0 = 0 ;
16172 char *kwnames[] = {
16173 (char *) "self", NULL
16174 };
16175
16176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16178 if (SWIG_arg_fail(1)) SWIG_fail;
16179 {
16180 PyThreadState* __tstate = wxPyBeginAllowThreads();
16181 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16182
16183 wxPyEndAllowThreads(__tstate);
16184 if (PyErr_Occurred()) SWIG_fail;
16185 }
16186 {
16187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16188 }
16189 return resultobj;
16190 fail:
16191 return NULL;
16192 }
16193
16194
16195 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16196 PyObject *resultobj;
16197 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16198 bool result;
16199 PyObject * obj0 = 0 ;
16200 char *kwnames[] = {
16201 (char *) "self", NULL
16202 };
16203
16204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16206 if (SWIG_arg_fail(1)) SWIG_fail;
16207 {
16208 PyThreadState* __tstate = wxPyBeginAllowThreads();
16209 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16210
16211 wxPyEndAllowThreads(__tstate);
16212 if (PyErr_Occurred()) SWIG_fail;
16213 }
16214 {
16215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16216 }
16217 return resultobj;
16218 fail:
16219 return NULL;
16220 }
16221
16222
16223 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16224 PyObject *resultobj;
16225 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16226 bool result;
16227 PyObject * obj0 = 0 ;
16228 char *kwnames[] = {
16229 (char *) "self", NULL
16230 };
16231
16232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16234 if (SWIG_arg_fail(1)) SWIG_fail;
16235 {
16236 PyThreadState* __tstate = wxPyBeginAllowThreads();
16237 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16238
16239 wxPyEndAllowThreads(__tstate);
16240 if (PyErr_Occurred()) SWIG_fail;
16241 }
16242 {
16243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16244 }
16245 return resultobj;
16246 fail:
16247 return NULL;
16248 }
16249
16250
16251 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16252 PyObject *resultobj;
16253 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16254 bool result;
16255 PyObject * obj0 = 0 ;
16256 char *kwnames[] = {
16257 (char *) "self", NULL
16258 };
16259
16260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16262 if (SWIG_arg_fail(1)) SWIG_fail;
16263 {
16264 PyThreadState* __tstate = wxPyBeginAllowThreads();
16265 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16266
16267 wxPyEndAllowThreads(__tstate);
16268 if (PyErr_Occurred()) SWIG_fail;
16269 }
16270 {
16271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16272 }
16273 return resultobj;
16274 fail:
16275 return NULL;
16276 }
16277
16278
16279 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj;
16281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16282 bool result;
16283 PyObject * obj0 = 0 ;
16284 char *kwnames[] = {
16285 (char *) "self", NULL
16286 };
16287
16288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16290 if (SWIG_arg_fail(1)) SWIG_fail;
16291 {
16292 PyThreadState* __tstate = wxPyBeginAllowThreads();
16293 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16294
16295 wxPyEndAllowThreads(__tstate);
16296 if (PyErr_Occurred()) SWIG_fail;
16297 }
16298 {
16299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16300 }
16301 return resultobj;
16302 fail:
16303 return NULL;
16304 }
16305
16306
16307 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16308 PyObject *resultobj;
16309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16310 bool result;
16311 PyObject * obj0 = 0 ;
16312 char *kwnames[] = {
16313 (char *) "self", NULL
16314 };
16315
16316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16318 if (SWIG_arg_fail(1)) SWIG_fail;
16319 {
16320 PyThreadState* __tstate = wxPyBeginAllowThreads();
16321 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16322
16323 wxPyEndAllowThreads(__tstate);
16324 if (PyErr_Occurred()) SWIG_fail;
16325 }
16326 {
16327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16328 }
16329 return resultobj;
16330 fail:
16331 return NULL;
16332 }
16333
16334
16335 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16336 PyObject *resultobj;
16337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16338 bool result;
16339 PyObject * obj0 = 0 ;
16340 char *kwnames[] = {
16341 (char *) "self", NULL
16342 };
16343
16344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16346 if (SWIG_arg_fail(1)) SWIG_fail;
16347 {
16348 PyThreadState* __tstate = wxPyBeginAllowThreads();
16349 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16350
16351 wxPyEndAllowThreads(__tstate);
16352 if (PyErr_Occurred()) SWIG_fail;
16353 }
16354 {
16355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16356 }
16357 return resultobj;
16358 fail:
16359 return NULL;
16360 }
16361
16362
16363 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16364 PyObject *resultobj;
16365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16366 bool result;
16367 PyObject * obj0 = 0 ;
16368 char *kwnames[] = {
16369 (char *) "self", NULL
16370 };
16371
16372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16374 if (SWIG_arg_fail(1)) SWIG_fail;
16375 {
16376 PyThreadState* __tstate = wxPyBeginAllowThreads();
16377 result = (bool)(arg1)->LeftIsDown();
16378
16379 wxPyEndAllowThreads(__tstate);
16380 if (PyErr_Occurred()) SWIG_fail;
16381 }
16382 {
16383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16384 }
16385 return resultobj;
16386 fail:
16387 return NULL;
16388 }
16389
16390
16391 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16392 PyObject *resultobj;
16393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16394 bool result;
16395 PyObject * obj0 = 0 ;
16396 char *kwnames[] = {
16397 (char *) "self", NULL
16398 };
16399
16400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16402 if (SWIG_arg_fail(1)) SWIG_fail;
16403 {
16404 PyThreadState* __tstate = wxPyBeginAllowThreads();
16405 result = (bool)(arg1)->MiddleIsDown();
16406
16407 wxPyEndAllowThreads(__tstate);
16408 if (PyErr_Occurred()) SWIG_fail;
16409 }
16410 {
16411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16412 }
16413 return resultobj;
16414 fail:
16415 return NULL;
16416 }
16417
16418
16419 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16420 PyObject *resultobj;
16421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16422 bool result;
16423 PyObject * obj0 = 0 ;
16424 char *kwnames[] = {
16425 (char *) "self", NULL
16426 };
16427
16428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16430 if (SWIG_arg_fail(1)) SWIG_fail;
16431 {
16432 PyThreadState* __tstate = wxPyBeginAllowThreads();
16433 result = (bool)(arg1)->RightIsDown();
16434
16435 wxPyEndAllowThreads(__tstate);
16436 if (PyErr_Occurred()) SWIG_fail;
16437 }
16438 {
16439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16440 }
16441 return resultobj;
16442 fail:
16443 return NULL;
16444 }
16445
16446
16447 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16448 PyObject *resultobj;
16449 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16450 bool result;
16451 PyObject * obj0 = 0 ;
16452 char *kwnames[] = {
16453 (char *) "self", NULL
16454 };
16455
16456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16458 if (SWIG_arg_fail(1)) SWIG_fail;
16459 {
16460 PyThreadState* __tstate = wxPyBeginAllowThreads();
16461 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16462
16463 wxPyEndAllowThreads(__tstate);
16464 if (PyErr_Occurred()) SWIG_fail;
16465 }
16466 {
16467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16468 }
16469 return resultobj;
16470 fail:
16471 return NULL;
16472 }
16473
16474
16475 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16476 PyObject *resultobj;
16477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16478 bool result;
16479 PyObject * obj0 = 0 ;
16480 char *kwnames[] = {
16481 (char *) "self", NULL
16482 };
16483
16484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16486 if (SWIG_arg_fail(1)) SWIG_fail;
16487 {
16488 PyThreadState* __tstate = wxPyBeginAllowThreads();
16489 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16490
16491 wxPyEndAllowThreads(__tstate);
16492 if (PyErr_Occurred()) SWIG_fail;
16493 }
16494 {
16495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16496 }
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj;
16505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16506 bool result;
16507 PyObject * obj0 = 0 ;
16508 char *kwnames[] = {
16509 (char *) "self", NULL
16510 };
16511
16512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16514 if (SWIG_arg_fail(1)) SWIG_fail;
16515 {
16516 PyThreadState* __tstate = wxPyBeginAllowThreads();
16517 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16518
16519 wxPyEndAllowThreads(__tstate);
16520 if (PyErr_Occurred()) SWIG_fail;
16521 }
16522 {
16523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16524 }
16525 return resultobj;
16526 fail:
16527 return NULL;
16528 }
16529
16530
16531 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16532 PyObject *resultobj;
16533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16534 bool result;
16535 PyObject * obj0 = 0 ;
16536 char *kwnames[] = {
16537 (char *) "self", NULL
16538 };
16539
16540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16542 if (SWIG_arg_fail(1)) SWIG_fail;
16543 {
16544 PyThreadState* __tstate = wxPyBeginAllowThreads();
16545 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16546
16547 wxPyEndAllowThreads(__tstate);
16548 if (PyErr_Occurred()) SWIG_fail;
16549 }
16550 {
16551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16552 }
16553 return resultobj;
16554 fail:
16555 return NULL;
16556 }
16557
16558
16559 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16560 PyObject *resultobj;
16561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16562 wxPoint result;
16563 PyObject * obj0 = 0 ;
16564 char *kwnames[] = {
16565 (char *) "self", NULL
16566 };
16567
16568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16570 if (SWIG_arg_fail(1)) SWIG_fail;
16571 {
16572 PyThreadState* __tstate = wxPyBeginAllowThreads();
16573 result = (arg1)->GetPosition();
16574
16575 wxPyEndAllowThreads(__tstate);
16576 if (PyErr_Occurred()) SWIG_fail;
16577 }
16578 {
16579 wxPoint * resultptr;
16580 resultptr = new wxPoint((wxPoint &)(result));
16581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16582 }
16583 return resultobj;
16584 fail:
16585 return NULL;
16586 }
16587
16588
16589 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16590 PyObject *resultobj;
16591 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16592 long *arg2 = (long *) 0 ;
16593 long *arg3 = (long *) 0 ;
16594 long temp2 ;
16595 int res2 = 0 ;
16596 long temp3 ;
16597 int res3 = 0 ;
16598 PyObject * obj0 = 0 ;
16599 char *kwnames[] = {
16600 (char *) "self", NULL
16601 };
16602
16603 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16604 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16607 if (SWIG_arg_fail(1)) SWIG_fail;
16608 {
16609 PyThreadState* __tstate = wxPyBeginAllowThreads();
16610 (arg1)->GetPosition(arg2,arg3);
16611
16612 wxPyEndAllowThreads(__tstate);
16613 if (PyErr_Occurred()) SWIG_fail;
16614 }
16615 Py_INCREF(Py_None); resultobj = Py_None;
16616 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16617 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16618 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16619 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16620 return resultobj;
16621 fail:
16622 return NULL;
16623 }
16624
16625
16626 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16627 PyObject *resultobj;
16628 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16629 wxDC *arg2 = 0 ;
16630 wxPoint result;
16631 PyObject * obj0 = 0 ;
16632 PyObject * obj1 = 0 ;
16633 char *kwnames[] = {
16634 (char *) "self",(char *) "dc", NULL
16635 };
16636
16637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16639 if (SWIG_arg_fail(1)) SWIG_fail;
16640 {
16641 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16642 if (SWIG_arg_fail(2)) SWIG_fail;
16643 if (arg2 == NULL) {
16644 SWIG_null_ref("wxDC");
16645 }
16646 if (SWIG_arg_fail(2)) SWIG_fail;
16647 }
16648 {
16649 PyThreadState* __tstate = wxPyBeginAllowThreads();
16650 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16651
16652 wxPyEndAllowThreads(__tstate);
16653 if (PyErr_Occurred()) SWIG_fail;
16654 }
16655 {
16656 wxPoint * resultptr;
16657 resultptr = new wxPoint((wxPoint &)(result));
16658 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16659 }
16660 return resultobj;
16661 fail:
16662 return NULL;
16663 }
16664
16665
16666 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16667 PyObject *resultobj;
16668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16669 int result;
16670 PyObject * obj0 = 0 ;
16671 char *kwnames[] = {
16672 (char *) "self", NULL
16673 };
16674
16675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16677 if (SWIG_arg_fail(1)) SWIG_fail;
16678 {
16679 PyThreadState* __tstate = wxPyBeginAllowThreads();
16680 result = (int)((wxMouseEvent const *)arg1)->GetX();
16681
16682 wxPyEndAllowThreads(__tstate);
16683 if (PyErr_Occurred()) SWIG_fail;
16684 }
16685 {
16686 resultobj = SWIG_From_int((int)(result));
16687 }
16688 return resultobj;
16689 fail:
16690 return NULL;
16691 }
16692
16693
16694 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16695 PyObject *resultobj;
16696 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16697 int result;
16698 PyObject * obj0 = 0 ;
16699 char *kwnames[] = {
16700 (char *) "self", NULL
16701 };
16702
16703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16705 if (SWIG_arg_fail(1)) SWIG_fail;
16706 {
16707 PyThreadState* __tstate = wxPyBeginAllowThreads();
16708 result = (int)((wxMouseEvent const *)arg1)->GetY();
16709
16710 wxPyEndAllowThreads(__tstate);
16711 if (PyErr_Occurred()) SWIG_fail;
16712 }
16713 {
16714 resultobj = SWIG_From_int((int)(result));
16715 }
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj;
16724 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16725 int result;
16726 PyObject * obj0 = 0 ;
16727 char *kwnames[] = {
16728 (char *) "self", NULL
16729 };
16730
16731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16733 if (SWIG_arg_fail(1)) SWIG_fail;
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16737
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 {
16742 resultobj = SWIG_From_int((int)(result));
16743 }
16744 return resultobj;
16745 fail:
16746 return NULL;
16747 }
16748
16749
16750 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16751 PyObject *resultobj;
16752 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16753 int result;
16754 PyObject * obj0 = 0 ;
16755 char *kwnames[] = {
16756 (char *) "self", NULL
16757 };
16758
16759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16761 if (SWIG_arg_fail(1)) SWIG_fail;
16762 {
16763 PyThreadState* __tstate = wxPyBeginAllowThreads();
16764 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16765
16766 wxPyEndAllowThreads(__tstate);
16767 if (PyErr_Occurred()) SWIG_fail;
16768 }
16769 {
16770 resultobj = SWIG_From_int((int)(result));
16771 }
16772 return resultobj;
16773 fail:
16774 return NULL;
16775 }
16776
16777
16778 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16779 PyObject *resultobj;
16780 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16781 int result;
16782 PyObject * obj0 = 0 ;
16783 char *kwnames[] = {
16784 (char *) "self", NULL
16785 };
16786
16787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16789 if (SWIG_arg_fail(1)) SWIG_fail;
16790 {
16791 PyThreadState* __tstate = wxPyBeginAllowThreads();
16792 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16793
16794 wxPyEndAllowThreads(__tstate);
16795 if (PyErr_Occurred()) SWIG_fail;
16796 }
16797 {
16798 resultobj = SWIG_From_int((int)(result));
16799 }
16800 return resultobj;
16801 fail:
16802 return NULL;
16803 }
16804
16805
16806 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
16807 PyObject *resultobj;
16808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16809 bool result;
16810 PyObject * obj0 = 0 ;
16811 char *kwnames[] = {
16812 (char *) "self", NULL
16813 };
16814
16815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
16816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16817 if (SWIG_arg_fail(1)) SWIG_fail;
16818 {
16819 PyThreadState* __tstate = wxPyBeginAllowThreads();
16820 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
16821
16822 wxPyEndAllowThreads(__tstate);
16823 if (PyErr_Occurred()) SWIG_fail;
16824 }
16825 {
16826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16827 }
16828 return resultobj;
16829 fail:
16830 return NULL;
16831 }
16832
16833
16834 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
16835 PyObject *resultobj;
16836 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16837 int arg2 ;
16838 PyObject * obj0 = 0 ;
16839 PyObject * obj1 = 0 ;
16840 char *kwnames[] = {
16841 (char *) "self",(char *) "m_x", NULL
16842 };
16843
16844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
16845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16846 if (SWIG_arg_fail(1)) SWIG_fail;
16847 {
16848 arg2 = (int)(SWIG_As_int(obj1));
16849 if (SWIG_arg_fail(2)) SWIG_fail;
16850 }
16851 if (arg1) (arg1)->m_x = arg2;
16852
16853 Py_INCREF(Py_None); resultobj = Py_None;
16854 return resultobj;
16855 fail:
16856 return NULL;
16857 }
16858
16859
16860 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
16861 PyObject *resultobj;
16862 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16863 int result;
16864 PyObject * obj0 = 0 ;
16865 char *kwnames[] = {
16866 (char *) "self", NULL
16867 };
16868
16869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
16870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16871 if (SWIG_arg_fail(1)) SWIG_fail;
16872 result = (int) ((arg1)->m_x);
16873
16874 {
16875 resultobj = SWIG_From_int((int)(result));
16876 }
16877 return resultobj;
16878 fail:
16879 return NULL;
16880 }
16881
16882
16883 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
16884 PyObject *resultobj;
16885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16886 int arg2 ;
16887 PyObject * obj0 = 0 ;
16888 PyObject * obj1 = 0 ;
16889 char *kwnames[] = {
16890 (char *) "self",(char *) "m_y", NULL
16891 };
16892
16893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
16894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16895 if (SWIG_arg_fail(1)) SWIG_fail;
16896 {
16897 arg2 = (int)(SWIG_As_int(obj1));
16898 if (SWIG_arg_fail(2)) SWIG_fail;
16899 }
16900 if (arg1) (arg1)->m_y = arg2;
16901
16902 Py_INCREF(Py_None); resultobj = Py_None;
16903 return resultobj;
16904 fail:
16905 return NULL;
16906 }
16907
16908
16909 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
16910 PyObject *resultobj;
16911 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16912 int result;
16913 PyObject * obj0 = 0 ;
16914 char *kwnames[] = {
16915 (char *) "self", NULL
16916 };
16917
16918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
16919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16920 if (SWIG_arg_fail(1)) SWIG_fail;
16921 result = (int) ((arg1)->m_y);
16922
16923 {
16924 resultobj = SWIG_From_int((int)(result));
16925 }
16926 return resultobj;
16927 fail:
16928 return NULL;
16929 }
16930
16931
16932 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16933 PyObject *resultobj;
16934 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16935 bool arg2 ;
16936 PyObject * obj0 = 0 ;
16937 PyObject * obj1 = 0 ;
16938 char *kwnames[] = {
16939 (char *) "self",(char *) "m_leftDown", NULL
16940 };
16941
16942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
16943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16944 if (SWIG_arg_fail(1)) SWIG_fail;
16945 {
16946 arg2 = (bool)(SWIG_As_bool(obj1));
16947 if (SWIG_arg_fail(2)) SWIG_fail;
16948 }
16949 if (arg1) (arg1)->m_leftDown = arg2;
16950
16951 Py_INCREF(Py_None); resultobj = Py_None;
16952 return resultobj;
16953 fail:
16954 return NULL;
16955 }
16956
16957
16958 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
16959 PyObject *resultobj;
16960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16961 bool result;
16962 PyObject * obj0 = 0 ;
16963 char *kwnames[] = {
16964 (char *) "self", NULL
16965 };
16966
16967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
16968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16969 if (SWIG_arg_fail(1)) SWIG_fail;
16970 result = (bool) ((arg1)->m_leftDown);
16971
16972 {
16973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16974 }
16975 return resultobj;
16976 fail:
16977 return NULL;
16978 }
16979
16980
16981 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16982 PyObject *resultobj;
16983 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16984 bool arg2 ;
16985 PyObject * obj0 = 0 ;
16986 PyObject * obj1 = 0 ;
16987 char *kwnames[] = {
16988 (char *) "self",(char *) "m_middleDown", NULL
16989 };
16990
16991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
16992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16993 if (SWIG_arg_fail(1)) SWIG_fail;
16994 {
16995 arg2 = (bool)(SWIG_As_bool(obj1));
16996 if (SWIG_arg_fail(2)) SWIG_fail;
16997 }
16998 if (arg1) (arg1)->m_middleDown = arg2;
16999
17000 Py_INCREF(Py_None); resultobj = Py_None;
17001 return resultobj;
17002 fail:
17003 return NULL;
17004 }
17005
17006
17007 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17008 PyObject *resultobj;
17009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17010 bool result;
17011 PyObject * obj0 = 0 ;
17012 char *kwnames[] = {
17013 (char *) "self", NULL
17014 };
17015
17016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17018 if (SWIG_arg_fail(1)) SWIG_fail;
17019 result = (bool) ((arg1)->m_middleDown);
17020
17021 {
17022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17023 }
17024 return resultobj;
17025 fail:
17026 return NULL;
17027 }
17028
17029
17030 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17031 PyObject *resultobj;
17032 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17033 bool arg2 ;
17034 PyObject * obj0 = 0 ;
17035 PyObject * obj1 = 0 ;
17036 char *kwnames[] = {
17037 (char *) "self",(char *) "m_rightDown", NULL
17038 };
17039
17040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17042 if (SWIG_arg_fail(1)) SWIG_fail;
17043 {
17044 arg2 = (bool)(SWIG_As_bool(obj1));
17045 if (SWIG_arg_fail(2)) SWIG_fail;
17046 }
17047 if (arg1) (arg1)->m_rightDown = arg2;
17048
17049 Py_INCREF(Py_None); resultobj = Py_None;
17050 return resultobj;
17051 fail:
17052 return NULL;
17053 }
17054
17055
17056 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17057 PyObject *resultobj;
17058 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17059 bool result;
17060 PyObject * obj0 = 0 ;
17061 char *kwnames[] = {
17062 (char *) "self", NULL
17063 };
17064
17065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17067 if (SWIG_arg_fail(1)) SWIG_fail;
17068 result = (bool) ((arg1)->m_rightDown);
17069
17070 {
17071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17072 }
17073 return resultobj;
17074 fail:
17075 return NULL;
17076 }
17077
17078
17079 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17080 PyObject *resultobj;
17081 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17082 bool arg2 ;
17083 PyObject * obj0 = 0 ;
17084 PyObject * obj1 = 0 ;
17085 char *kwnames[] = {
17086 (char *) "self",(char *) "m_controlDown", NULL
17087 };
17088
17089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17091 if (SWIG_arg_fail(1)) SWIG_fail;
17092 {
17093 arg2 = (bool)(SWIG_As_bool(obj1));
17094 if (SWIG_arg_fail(2)) SWIG_fail;
17095 }
17096 if (arg1) (arg1)->m_controlDown = arg2;
17097
17098 Py_INCREF(Py_None); resultobj = Py_None;
17099 return resultobj;
17100 fail:
17101 return NULL;
17102 }
17103
17104
17105 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17106 PyObject *resultobj;
17107 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17108 bool result;
17109 PyObject * obj0 = 0 ;
17110 char *kwnames[] = {
17111 (char *) "self", NULL
17112 };
17113
17114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17116 if (SWIG_arg_fail(1)) SWIG_fail;
17117 result = (bool) ((arg1)->m_controlDown);
17118
17119 {
17120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17121 }
17122 return resultobj;
17123 fail:
17124 return NULL;
17125 }
17126
17127
17128 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17129 PyObject *resultobj;
17130 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17131 bool arg2 ;
17132 PyObject * obj0 = 0 ;
17133 PyObject * obj1 = 0 ;
17134 char *kwnames[] = {
17135 (char *) "self",(char *) "m_shiftDown", NULL
17136 };
17137
17138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17140 if (SWIG_arg_fail(1)) SWIG_fail;
17141 {
17142 arg2 = (bool)(SWIG_As_bool(obj1));
17143 if (SWIG_arg_fail(2)) SWIG_fail;
17144 }
17145 if (arg1) (arg1)->m_shiftDown = arg2;
17146
17147 Py_INCREF(Py_None); resultobj = Py_None;
17148 return resultobj;
17149 fail:
17150 return NULL;
17151 }
17152
17153
17154 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17155 PyObject *resultobj;
17156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17157 bool result;
17158 PyObject * obj0 = 0 ;
17159 char *kwnames[] = {
17160 (char *) "self", NULL
17161 };
17162
17163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17165 if (SWIG_arg_fail(1)) SWIG_fail;
17166 result = (bool) ((arg1)->m_shiftDown);
17167
17168 {
17169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17170 }
17171 return resultobj;
17172 fail:
17173 return NULL;
17174 }
17175
17176
17177 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17178 PyObject *resultobj;
17179 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17180 bool arg2 ;
17181 PyObject * obj0 = 0 ;
17182 PyObject * obj1 = 0 ;
17183 char *kwnames[] = {
17184 (char *) "self",(char *) "m_altDown", NULL
17185 };
17186
17187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17189 if (SWIG_arg_fail(1)) SWIG_fail;
17190 {
17191 arg2 = (bool)(SWIG_As_bool(obj1));
17192 if (SWIG_arg_fail(2)) SWIG_fail;
17193 }
17194 if (arg1) (arg1)->m_altDown = arg2;
17195
17196 Py_INCREF(Py_None); resultobj = Py_None;
17197 return resultobj;
17198 fail:
17199 return NULL;
17200 }
17201
17202
17203 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17204 PyObject *resultobj;
17205 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17206 bool result;
17207 PyObject * obj0 = 0 ;
17208 char *kwnames[] = {
17209 (char *) "self", NULL
17210 };
17211
17212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17214 if (SWIG_arg_fail(1)) SWIG_fail;
17215 result = (bool) ((arg1)->m_altDown);
17216
17217 {
17218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17219 }
17220 return resultobj;
17221 fail:
17222 return NULL;
17223 }
17224
17225
17226 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17227 PyObject *resultobj;
17228 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17229 bool arg2 ;
17230 PyObject * obj0 = 0 ;
17231 PyObject * obj1 = 0 ;
17232 char *kwnames[] = {
17233 (char *) "self",(char *) "m_metaDown", NULL
17234 };
17235
17236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17238 if (SWIG_arg_fail(1)) SWIG_fail;
17239 {
17240 arg2 = (bool)(SWIG_As_bool(obj1));
17241 if (SWIG_arg_fail(2)) SWIG_fail;
17242 }
17243 if (arg1) (arg1)->m_metaDown = arg2;
17244
17245 Py_INCREF(Py_None); resultobj = Py_None;
17246 return resultobj;
17247 fail:
17248 return NULL;
17249 }
17250
17251
17252 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17253 PyObject *resultobj;
17254 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17255 bool result;
17256 PyObject * obj0 = 0 ;
17257 char *kwnames[] = {
17258 (char *) "self", NULL
17259 };
17260
17261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17263 if (SWIG_arg_fail(1)) SWIG_fail;
17264 result = (bool) ((arg1)->m_metaDown);
17265
17266 {
17267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17268 }
17269 return resultobj;
17270 fail:
17271 return NULL;
17272 }
17273
17274
17275 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17276 PyObject *resultobj;
17277 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17278 int arg2 ;
17279 PyObject * obj0 = 0 ;
17280 PyObject * obj1 = 0 ;
17281 char *kwnames[] = {
17282 (char *) "self",(char *) "m_wheelRotation", NULL
17283 };
17284
17285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17287 if (SWIG_arg_fail(1)) SWIG_fail;
17288 {
17289 arg2 = (int)(SWIG_As_int(obj1));
17290 if (SWIG_arg_fail(2)) SWIG_fail;
17291 }
17292 if (arg1) (arg1)->m_wheelRotation = arg2;
17293
17294 Py_INCREF(Py_None); resultobj = Py_None;
17295 return resultobj;
17296 fail:
17297 return NULL;
17298 }
17299
17300
17301 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17302 PyObject *resultobj;
17303 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17304 int result;
17305 PyObject * obj0 = 0 ;
17306 char *kwnames[] = {
17307 (char *) "self", NULL
17308 };
17309
17310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17312 if (SWIG_arg_fail(1)) SWIG_fail;
17313 result = (int) ((arg1)->m_wheelRotation);
17314
17315 {
17316 resultobj = SWIG_From_int((int)(result));
17317 }
17318 return resultobj;
17319 fail:
17320 return NULL;
17321 }
17322
17323
17324 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17325 PyObject *resultobj;
17326 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17327 int arg2 ;
17328 PyObject * obj0 = 0 ;
17329 PyObject * obj1 = 0 ;
17330 char *kwnames[] = {
17331 (char *) "self",(char *) "m_wheelDelta", NULL
17332 };
17333
17334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17336 if (SWIG_arg_fail(1)) SWIG_fail;
17337 {
17338 arg2 = (int)(SWIG_As_int(obj1));
17339 if (SWIG_arg_fail(2)) SWIG_fail;
17340 }
17341 if (arg1) (arg1)->m_wheelDelta = arg2;
17342
17343 Py_INCREF(Py_None); resultobj = Py_None;
17344 return resultobj;
17345 fail:
17346 return NULL;
17347 }
17348
17349
17350 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17351 PyObject *resultobj;
17352 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17353 int result;
17354 PyObject * obj0 = 0 ;
17355 char *kwnames[] = {
17356 (char *) "self", NULL
17357 };
17358
17359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17361 if (SWIG_arg_fail(1)) SWIG_fail;
17362 result = (int) ((arg1)->m_wheelDelta);
17363
17364 {
17365 resultobj = SWIG_From_int((int)(result));
17366 }
17367 return resultobj;
17368 fail:
17369 return NULL;
17370 }
17371
17372
17373 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj;
17375 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17376 int arg2 ;
17377 PyObject * obj0 = 0 ;
17378 PyObject * obj1 = 0 ;
17379 char *kwnames[] = {
17380 (char *) "self",(char *) "m_linesPerAction", NULL
17381 };
17382
17383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17385 if (SWIG_arg_fail(1)) SWIG_fail;
17386 {
17387 arg2 = (int)(SWIG_As_int(obj1));
17388 if (SWIG_arg_fail(2)) SWIG_fail;
17389 }
17390 if (arg1) (arg1)->m_linesPerAction = arg2;
17391
17392 Py_INCREF(Py_None); resultobj = Py_None;
17393 return resultobj;
17394 fail:
17395 return NULL;
17396 }
17397
17398
17399 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17400 PyObject *resultobj;
17401 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17402 int result;
17403 PyObject * obj0 = 0 ;
17404 char *kwnames[] = {
17405 (char *) "self", NULL
17406 };
17407
17408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17410 if (SWIG_arg_fail(1)) SWIG_fail;
17411 result = (int) ((arg1)->m_linesPerAction);
17412
17413 {
17414 resultobj = SWIG_From_int((int)(result));
17415 }
17416 return resultobj;
17417 fail:
17418 return NULL;
17419 }
17420
17421
17422 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17423 PyObject *obj;
17424 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17425 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17426 Py_INCREF(obj);
17427 return Py_BuildValue((char *)"");
17428 }
17429 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17430 PyObject *resultobj;
17431 int arg1 = (int) 0 ;
17432 int arg2 = (int) 0 ;
17433 wxSetCursorEvent *result;
17434 PyObject * obj0 = 0 ;
17435 PyObject * obj1 = 0 ;
17436 char *kwnames[] = {
17437 (char *) "x",(char *) "y", NULL
17438 };
17439
17440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17441 if (obj0) {
17442 {
17443 arg1 = (int)(SWIG_As_int(obj0));
17444 if (SWIG_arg_fail(1)) SWIG_fail;
17445 }
17446 }
17447 if (obj1) {
17448 {
17449 arg2 = (int)(SWIG_As_int(obj1));
17450 if (SWIG_arg_fail(2)) SWIG_fail;
17451 }
17452 }
17453 {
17454 PyThreadState* __tstate = wxPyBeginAllowThreads();
17455 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17456
17457 wxPyEndAllowThreads(__tstate);
17458 if (PyErr_Occurred()) SWIG_fail;
17459 }
17460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17461 return resultobj;
17462 fail:
17463 return NULL;
17464 }
17465
17466
17467 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17468 PyObject *resultobj;
17469 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17470 int result;
17471 PyObject * obj0 = 0 ;
17472 char *kwnames[] = {
17473 (char *) "self", NULL
17474 };
17475
17476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17478 if (SWIG_arg_fail(1)) SWIG_fail;
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17482
17483 wxPyEndAllowThreads(__tstate);
17484 if (PyErr_Occurred()) SWIG_fail;
17485 }
17486 {
17487 resultobj = SWIG_From_int((int)(result));
17488 }
17489 return resultobj;
17490 fail:
17491 return NULL;
17492 }
17493
17494
17495 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17496 PyObject *resultobj;
17497 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17498 int result;
17499 PyObject * obj0 = 0 ;
17500 char *kwnames[] = {
17501 (char *) "self", NULL
17502 };
17503
17504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17506 if (SWIG_arg_fail(1)) SWIG_fail;
17507 {
17508 PyThreadState* __tstate = wxPyBeginAllowThreads();
17509 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17510
17511 wxPyEndAllowThreads(__tstate);
17512 if (PyErr_Occurred()) SWIG_fail;
17513 }
17514 {
17515 resultobj = SWIG_From_int((int)(result));
17516 }
17517 return resultobj;
17518 fail:
17519 return NULL;
17520 }
17521
17522
17523 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17524 PyObject *resultobj;
17525 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17526 wxCursor *arg2 = 0 ;
17527 PyObject * obj0 = 0 ;
17528 PyObject * obj1 = 0 ;
17529 char *kwnames[] = {
17530 (char *) "self",(char *) "cursor", NULL
17531 };
17532
17533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17535 if (SWIG_arg_fail(1)) SWIG_fail;
17536 {
17537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17538 if (SWIG_arg_fail(2)) SWIG_fail;
17539 if (arg2 == NULL) {
17540 SWIG_null_ref("wxCursor");
17541 }
17542 if (SWIG_arg_fail(2)) SWIG_fail;
17543 }
17544 {
17545 PyThreadState* __tstate = wxPyBeginAllowThreads();
17546 (arg1)->SetCursor((wxCursor const &)*arg2);
17547
17548 wxPyEndAllowThreads(__tstate);
17549 if (PyErr_Occurred()) SWIG_fail;
17550 }
17551 Py_INCREF(Py_None); resultobj = Py_None;
17552 return resultobj;
17553 fail:
17554 return NULL;
17555 }
17556
17557
17558 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17559 PyObject *resultobj;
17560 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17561 wxCursor *result;
17562 PyObject * obj0 = 0 ;
17563 char *kwnames[] = {
17564 (char *) "self", NULL
17565 };
17566
17567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17569 if (SWIG_arg_fail(1)) SWIG_fail;
17570 {
17571 PyThreadState* __tstate = wxPyBeginAllowThreads();
17572 {
17573 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17574 result = (wxCursor *) &_result_ref;
17575 }
17576
17577 wxPyEndAllowThreads(__tstate);
17578 if (PyErr_Occurred()) SWIG_fail;
17579 }
17580 {
17581 wxCursor* resultptr = new wxCursor(*result);
17582 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17583 }
17584 return resultobj;
17585 fail:
17586 return NULL;
17587 }
17588
17589
17590 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17591 PyObject *resultobj;
17592 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17593 bool result;
17594 PyObject * obj0 = 0 ;
17595 char *kwnames[] = {
17596 (char *) "self", NULL
17597 };
17598
17599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17601 if (SWIG_arg_fail(1)) SWIG_fail;
17602 {
17603 PyThreadState* __tstate = wxPyBeginAllowThreads();
17604 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17605
17606 wxPyEndAllowThreads(__tstate);
17607 if (PyErr_Occurred()) SWIG_fail;
17608 }
17609 {
17610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17611 }
17612 return resultobj;
17613 fail:
17614 return NULL;
17615 }
17616
17617
17618 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17619 PyObject *obj;
17620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17621 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17622 Py_INCREF(obj);
17623 return Py_BuildValue((char *)"");
17624 }
17625 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17626 PyObject *resultobj;
17627 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17628 wxKeyEvent *result;
17629 PyObject * obj0 = 0 ;
17630 char *kwnames[] = {
17631 (char *) "keyType", NULL
17632 };
17633
17634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17635 if (obj0) {
17636 {
17637 arg1 = (wxEventType)(SWIG_As_int(obj0));
17638 if (SWIG_arg_fail(1)) SWIG_fail;
17639 }
17640 }
17641 {
17642 PyThreadState* __tstate = wxPyBeginAllowThreads();
17643 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17644
17645 wxPyEndAllowThreads(__tstate);
17646 if (PyErr_Occurred()) SWIG_fail;
17647 }
17648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17649 return resultobj;
17650 fail:
17651 return NULL;
17652 }
17653
17654
17655 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17656 PyObject *resultobj;
17657 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17658 bool result;
17659 PyObject * obj0 = 0 ;
17660 char *kwnames[] = {
17661 (char *) "self", NULL
17662 };
17663
17664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17666 if (SWIG_arg_fail(1)) SWIG_fail;
17667 {
17668 PyThreadState* __tstate = wxPyBeginAllowThreads();
17669 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17670
17671 wxPyEndAllowThreads(__tstate);
17672 if (PyErr_Occurred()) SWIG_fail;
17673 }
17674 {
17675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17676 }
17677 return resultobj;
17678 fail:
17679 return NULL;
17680 }
17681
17682
17683 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17684 PyObject *resultobj;
17685 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17686 bool result;
17687 PyObject * obj0 = 0 ;
17688 char *kwnames[] = {
17689 (char *) "self", NULL
17690 };
17691
17692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17694 if (SWIG_arg_fail(1)) SWIG_fail;
17695 {
17696 PyThreadState* __tstate = wxPyBeginAllowThreads();
17697 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17698
17699 wxPyEndAllowThreads(__tstate);
17700 if (PyErr_Occurred()) SWIG_fail;
17701 }
17702 {
17703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17704 }
17705 return resultobj;
17706 fail:
17707 return NULL;
17708 }
17709
17710
17711 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17712 PyObject *resultobj;
17713 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17714 bool result;
17715 PyObject * obj0 = 0 ;
17716 char *kwnames[] = {
17717 (char *) "self", NULL
17718 };
17719
17720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17722 if (SWIG_arg_fail(1)) SWIG_fail;
17723 {
17724 PyThreadState* __tstate = wxPyBeginAllowThreads();
17725 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17726
17727 wxPyEndAllowThreads(__tstate);
17728 if (PyErr_Occurred()) SWIG_fail;
17729 }
17730 {
17731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17732 }
17733 return resultobj;
17734 fail:
17735 return NULL;
17736 }
17737
17738
17739 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17740 PyObject *resultobj;
17741 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17742 bool result;
17743 PyObject * obj0 = 0 ;
17744 char *kwnames[] = {
17745 (char *) "self", NULL
17746 };
17747
17748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17750 if (SWIG_arg_fail(1)) SWIG_fail;
17751 {
17752 PyThreadState* __tstate = wxPyBeginAllowThreads();
17753 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17754
17755 wxPyEndAllowThreads(__tstate);
17756 if (PyErr_Occurred()) SWIG_fail;
17757 }
17758 {
17759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17760 }
17761 return resultobj;
17762 fail:
17763 return NULL;
17764 }
17765
17766
17767 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17768 PyObject *resultobj;
17769 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17770 bool result;
17771 PyObject * obj0 = 0 ;
17772 char *kwnames[] = {
17773 (char *) "self", NULL
17774 };
17775
17776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17778 if (SWIG_arg_fail(1)) SWIG_fail;
17779 {
17780 PyThreadState* __tstate = wxPyBeginAllowThreads();
17781 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17782
17783 wxPyEndAllowThreads(__tstate);
17784 if (PyErr_Occurred()) SWIG_fail;
17785 }
17786 {
17787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17788 }
17789 return resultobj;
17790 fail:
17791 return NULL;
17792 }
17793
17794
17795 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17796 PyObject *resultobj;
17797 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17798 bool result;
17799 PyObject * obj0 = 0 ;
17800 char *kwnames[] = {
17801 (char *) "self", NULL
17802 };
17803
17804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17806 if (SWIG_arg_fail(1)) SWIG_fail;
17807 {
17808 PyThreadState* __tstate = wxPyBeginAllowThreads();
17809 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
17810
17811 wxPyEndAllowThreads(__tstate);
17812 if (PyErr_Occurred()) SWIG_fail;
17813 }
17814 {
17815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17816 }
17817 return resultobj;
17818 fail:
17819 return NULL;
17820 }
17821
17822
17823 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17824 PyObject *resultobj;
17825 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17826 int result;
17827 PyObject * obj0 = 0 ;
17828 char *kwnames[] = {
17829 (char *) "self", NULL
17830 };
17831
17832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
17833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17834 if (SWIG_arg_fail(1)) SWIG_fail;
17835 {
17836 PyThreadState* __tstate = wxPyBeginAllowThreads();
17837 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
17838
17839 wxPyEndAllowThreads(__tstate);
17840 if (PyErr_Occurred()) SWIG_fail;
17841 }
17842 {
17843 resultobj = SWIG_From_int((int)(result));
17844 }
17845 return resultobj;
17846 fail:
17847 return NULL;
17848 }
17849
17850
17851 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
17852 PyObject *resultobj;
17853 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17854 int result;
17855 PyObject * obj0 = 0 ;
17856 char *kwnames[] = {
17857 (char *) "self", NULL
17858 };
17859
17860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
17861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17862 if (SWIG_arg_fail(1)) SWIG_fail;
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
17866
17867 wxPyEndAllowThreads(__tstate);
17868 if (PyErr_Occurred()) SWIG_fail;
17869 }
17870 {
17871 resultobj = SWIG_From_int((int)(result));
17872 }
17873 return resultobj;
17874 fail:
17875 return NULL;
17876 }
17877
17878
17879 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17880 PyObject *resultobj;
17881 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17882 unsigned int result;
17883 PyObject * obj0 = 0 ;
17884 char *kwnames[] = {
17885 (char *) "self", NULL
17886 };
17887
17888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
17889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17890 if (SWIG_arg_fail(1)) SWIG_fail;
17891 {
17892 PyThreadState* __tstate = wxPyBeginAllowThreads();
17893 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
17894
17895 wxPyEndAllowThreads(__tstate);
17896 if (PyErr_Occurred()) SWIG_fail;
17897 }
17898 {
17899 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17900 }
17901 return resultobj;
17902 fail:
17903 return NULL;
17904 }
17905
17906
17907 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
17908 PyObject *resultobj;
17909 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17910 unsigned int result;
17911 PyObject * obj0 = 0 ;
17912 char *kwnames[] = {
17913 (char *) "self", NULL
17914 };
17915
17916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
17917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17918 if (SWIG_arg_fail(1)) SWIG_fail;
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
17922
17923 wxPyEndAllowThreads(__tstate);
17924 if (PyErr_Occurred()) SWIG_fail;
17925 }
17926 {
17927 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17928 }
17929 return resultobj;
17930 fail:
17931 return NULL;
17932 }
17933
17934
17935 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17936 PyObject *resultobj;
17937 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17938 wxPoint result;
17939 PyObject * obj0 = 0 ;
17940 char *kwnames[] = {
17941 (char *) "self", NULL
17942 };
17943
17944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
17945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17946 if (SWIG_arg_fail(1)) SWIG_fail;
17947 {
17948 PyThreadState* __tstate = wxPyBeginAllowThreads();
17949 result = (arg1)->GetPosition();
17950
17951 wxPyEndAllowThreads(__tstate);
17952 if (PyErr_Occurred()) SWIG_fail;
17953 }
17954 {
17955 wxPoint * resultptr;
17956 resultptr = new wxPoint((wxPoint &)(result));
17957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17958 }
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17966 PyObject *resultobj;
17967 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17968 long *arg2 = (long *) 0 ;
17969 long *arg3 = (long *) 0 ;
17970 long temp2 ;
17971 int res2 = 0 ;
17972 long temp3 ;
17973 int res3 = 0 ;
17974 PyObject * obj0 = 0 ;
17975 char *kwnames[] = {
17976 (char *) "self", NULL
17977 };
17978
17979 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17980 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17983 if (SWIG_arg_fail(1)) SWIG_fail;
17984 {
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 (arg1)->GetPosition(arg2,arg3);
17987
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 Py_INCREF(Py_None); resultobj = Py_None;
17992 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17993 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17994 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17995 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17996 return resultobj;
17997 fail:
17998 return NULL;
17999 }
18000
18001
18002 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18003 PyObject *resultobj;
18004 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18005 int result;
18006 PyObject * obj0 = 0 ;
18007 char *kwnames[] = {
18008 (char *) "self", NULL
18009 };
18010
18011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18013 if (SWIG_arg_fail(1)) SWIG_fail;
18014 {
18015 PyThreadState* __tstate = wxPyBeginAllowThreads();
18016 result = (int)((wxKeyEvent const *)arg1)->GetX();
18017
18018 wxPyEndAllowThreads(__tstate);
18019 if (PyErr_Occurred()) SWIG_fail;
18020 }
18021 {
18022 resultobj = SWIG_From_int((int)(result));
18023 }
18024 return resultobj;
18025 fail:
18026 return NULL;
18027 }
18028
18029
18030 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18031 PyObject *resultobj;
18032 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18033 int result;
18034 PyObject * obj0 = 0 ;
18035 char *kwnames[] = {
18036 (char *) "self", NULL
18037 };
18038
18039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18041 if (SWIG_arg_fail(1)) SWIG_fail;
18042 {
18043 PyThreadState* __tstate = wxPyBeginAllowThreads();
18044 result = (int)((wxKeyEvent const *)arg1)->GetY();
18045
18046 wxPyEndAllowThreads(__tstate);
18047 if (PyErr_Occurred()) SWIG_fail;
18048 }
18049 {
18050 resultobj = SWIG_From_int((int)(result));
18051 }
18052 return resultobj;
18053 fail:
18054 return NULL;
18055 }
18056
18057
18058 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18059 PyObject *resultobj;
18060 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18061 int arg2 ;
18062 PyObject * obj0 = 0 ;
18063 PyObject * obj1 = 0 ;
18064 char *kwnames[] = {
18065 (char *) "self",(char *) "m_x", NULL
18066 };
18067
18068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18070 if (SWIG_arg_fail(1)) SWIG_fail;
18071 {
18072 arg2 = (int)(SWIG_As_int(obj1));
18073 if (SWIG_arg_fail(2)) SWIG_fail;
18074 }
18075 if (arg1) (arg1)->m_x = arg2;
18076
18077 Py_INCREF(Py_None); resultobj = Py_None;
18078 return resultobj;
18079 fail:
18080 return NULL;
18081 }
18082
18083
18084 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18085 PyObject *resultobj;
18086 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18087 int result;
18088 PyObject * obj0 = 0 ;
18089 char *kwnames[] = {
18090 (char *) "self", NULL
18091 };
18092
18093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18095 if (SWIG_arg_fail(1)) SWIG_fail;
18096 result = (int) ((arg1)->m_x);
18097
18098 {
18099 resultobj = SWIG_From_int((int)(result));
18100 }
18101 return resultobj;
18102 fail:
18103 return NULL;
18104 }
18105
18106
18107 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18108 PyObject *resultobj;
18109 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18110 int arg2 ;
18111 PyObject * obj0 = 0 ;
18112 PyObject * obj1 = 0 ;
18113 char *kwnames[] = {
18114 (char *) "self",(char *) "m_y", NULL
18115 };
18116
18117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18119 if (SWIG_arg_fail(1)) SWIG_fail;
18120 {
18121 arg2 = (int)(SWIG_As_int(obj1));
18122 if (SWIG_arg_fail(2)) SWIG_fail;
18123 }
18124 if (arg1) (arg1)->m_y = arg2;
18125
18126 Py_INCREF(Py_None); resultobj = Py_None;
18127 return resultobj;
18128 fail:
18129 return NULL;
18130 }
18131
18132
18133 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18134 PyObject *resultobj;
18135 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18136 int result;
18137 PyObject * obj0 = 0 ;
18138 char *kwnames[] = {
18139 (char *) "self", NULL
18140 };
18141
18142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18144 if (SWIG_arg_fail(1)) SWIG_fail;
18145 result = (int) ((arg1)->m_y);
18146
18147 {
18148 resultobj = SWIG_From_int((int)(result));
18149 }
18150 return resultobj;
18151 fail:
18152 return NULL;
18153 }
18154
18155
18156 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18157 PyObject *resultobj;
18158 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18159 long arg2 ;
18160 PyObject * obj0 = 0 ;
18161 PyObject * obj1 = 0 ;
18162 char *kwnames[] = {
18163 (char *) "self",(char *) "m_keyCode", NULL
18164 };
18165
18166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18168 if (SWIG_arg_fail(1)) SWIG_fail;
18169 {
18170 arg2 = (long)(SWIG_As_long(obj1));
18171 if (SWIG_arg_fail(2)) SWIG_fail;
18172 }
18173 if (arg1) (arg1)->m_keyCode = arg2;
18174
18175 Py_INCREF(Py_None); resultobj = Py_None;
18176 return resultobj;
18177 fail:
18178 return NULL;
18179 }
18180
18181
18182 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18183 PyObject *resultobj;
18184 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18185 long result;
18186 PyObject * obj0 = 0 ;
18187 char *kwnames[] = {
18188 (char *) "self", NULL
18189 };
18190
18191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18193 if (SWIG_arg_fail(1)) SWIG_fail;
18194 result = (long) ((arg1)->m_keyCode);
18195
18196 {
18197 resultobj = SWIG_From_long((long)(result));
18198 }
18199 return resultobj;
18200 fail:
18201 return NULL;
18202 }
18203
18204
18205 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18206 PyObject *resultobj;
18207 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18208 bool arg2 ;
18209 PyObject * obj0 = 0 ;
18210 PyObject * obj1 = 0 ;
18211 char *kwnames[] = {
18212 (char *) "self",(char *) "m_controlDown", NULL
18213 };
18214
18215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18217 if (SWIG_arg_fail(1)) SWIG_fail;
18218 {
18219 arg2 = (bool)(SWIG_As_bool(obj1));
18220 if (SWIG_arg_fail(2)) SWIG_fail;
18221 }
18222 if (arg1) (arg1)->m_controlDown = arg2;
18223
18224 Py_INCREF(Py_None); resultobj = Py_None;
18225 return resultobj;
18226 fail:
18227 return NULL;
18228 }
18229
18230
18231 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18232 PyObject *resultobj;
18233 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18234 bool result;
18235 PyObject * obj0 = 0 ;
18236 char *kwnames[] = {
18237 (char *) "self", NULL
18238 };
18239
18240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18242 if (SWIG_arg_fail(1)) SWIG_fail;
18243 result = (bool) ((arg1)->m_controlDown);
18244
18245 {
18246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18247 }
18248 return resultobj;
18249 fail:
18250 return NULL;
18251 }
18252
18253
18254 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18255 PyObject *resultobj;
18256 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18257 bool arg2 ;
18258 PyObject * obj0 = 0 ;
18259 PyObject * obj1 = 0 ;
18260 char *kwnames[] = {
18261 (char *) "self",(char *) "m_shiftDown", NULL
18262 };
18263
18264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18266 if (SWIG_arg_fail(1)) SWIG_fail;
18267 {
18268 arg2 = (bool)(SWIG_As_bool(obj1));
18269 if (SWIG_arg_fail(2)) SWIG_fail;
18270 }
18271 if (arg1) (arg1)->m_shiftDown = arg2;
18272
18273 Py_INCREF(Py_None); resultobj = Py_None;
18274 return resultobj;
18275 fail:
18276 return NULL;
18277 }
18278
18279
18280 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18281 PyObject *resultobj;
18282 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18283 bool result;
18284 PyObject * obj0 = 0 ;
18285 char *kwnames[] = {
18286 (char *) "self", NULL
18287 };
18288
18289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18291 if (SWIG_arg_fail(1)) SWIG_fail;
18292 result = (bool) ((arg1)->m_shiftDown);
18293
18294 {
18295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18296 }
18297 return resultobj;
18298 fail:
18299 return NULL;
18300 }
18301
18302
18303 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18304 PyObject *resultobj;
18305 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18306 bool arg2 ;
18307 PyObject * obj0 = 0 ;
18308 PyObject * obj1 = 0 ;
18309 char *kwnames[] = {
18310 (char *) "self",(char *) "m_altDown", NULL
18311 };
18312
18313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18315 if (SWIG_arg_fail(1)) SWIG_fail;
18316 {
18317 arg2 = (bool)(SWIG_As_bool(obj1));
18318 if (SWIG_arg_fail(2)) SWIG_fail;
18319 }
18320 if (arg1) (arg1)->m_altDown = arg2;
18321
18322 Py_INCREF(Py_None); resultobj = Py_None;
18323 return resultobj;
18324 fail:
18325 return NULL;
18326 }
18327
18328
18329 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18330 PyObject *resultobj;
18331 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18332 bool result;
18333 PyObject * obj0 = 0 ;
18334 char *kwnames[] = {
18335 (char *) "self", NULL
18336 };
18337
18338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18340 if (SWIG_arg_fail(1)) SWIG_fail;
18341 result = (bool) ((arg1)->m_altDown);
18342
18343 {
18344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18345 }
18346 return resultobj;
18347 fail:
18348 return NULL;
18349 }
18350
18351
18352 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18353 PyObject *resultobj;
18354 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18355 bool arg2 ;
18356 PyObject * obj0 = 0 ;
18357 PyObject * obj1 = 0 ;
18358 char *kwnames[] = {
18359 (char *) "self",(char *) "m_metaDown", NULL
18360 };
18361
18362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18364 if (SWIG_arg_fail(1)) SWIG_fail;
18365 {
18366 arg2 = (bool)(SWIG_As_bool(obj1));
18367 if (SWIG_arg_fail(2)) SWIG_fail;
18368 }
18369 if (arg1) (arg1)->m_metaDown = arg2;
18370
18371 Py_INCREF(Py_None); resultobj = Py_None;
18372 return resultobj;
18373 fail:
18374 return NULL;
18375 }
18376
18377
18378 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18379 PyObject *resultobj;
18380 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18381 bool result;
18382 PyObject * obj0 = 0 ;
18383 char *kwnames[] = {
18384 (char *) "self", NULL
18385 };
18386
18387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18389 if (SWIG_arg_fail(1)) SWIG_fail;
18390 result = (bool) ((arg1)->m_metaDown);
18391
18392 {
18393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18394 }
18395 return resultobj;
18396 fail:
18397 return NULL;
18398 }
18399
18400
18401 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18402 PyObject *resultobj;
18403 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18404 bool arg2 ;
18405 PyObject * obj0 = 0 ;
18406 PyObject * obj1 = 0 ;
18407 char *kwnames[] = {
18408 (char *) "self",(char *) "m_scanCode", NULL
18409 };
18410
18411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18413 if (SWIG_arg_fail(1)) SWIG_fail;
18414 {
18415 arg2 = (bool)(SWIG_As_bool(obj1));
18416 if (SWIG_arg_fail(2)) SWIG_fail;
18417 }
18418 if (arg1) (arg1)->m_scanCode = arg2;
18419
18420 Py_INCREF(Py_None); resultobj = Py_None;
18421 return resultobj;
18422 fail:
18423 return NULL;
18424 }
18425
18426
18427 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18428 PyObject *resultobj;
18429 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18430 bool result;
18431 PyObject * obj0 = 0 ;
18432 char *kwnames[] = {
18433 (char *) "self", NULL
18434 };
18435
18436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18438 if (SWIG_arg_fail(1)) SWIG_fail;
18439 result = (bool) ((arg1)->m_scanCode);
18440
18441 {
18442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18443 }
18444 return resultobj;
18445 fail:
18446 return NULL;
18447 }
18448
18449
18450 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18451 PyObject *resultobj;
18452 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18453 unsigned int arg2 ;
18454 PyObject * obj0 = 0 ;
18455 PyObject * obj1 = 0 ;
18456 char *kwnames[] = {
18457 (char *) "self",(char *) "m_rawCode", NULL
18458 };
18459
18460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18462 if (SWIG_arg_fail(1)) SWIG_fail;
18463 {
18464 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18465 if (SWIG_arg_fail(2)) SWIG_fail;
18466 }
18467 if (arg1) (arg1)->m_rawCode = arg2;
18468
18469 Py_INCREF(Py_None); resultobj = Py_None;
18470 return resultobj;
18471 fail:
18472 return NULL;
18473 }
18474
18475
18476 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18477 PyObject *resultobj;
18478 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18479 unsigned int result;
18480 PyObject * obj0 = 0 ;
18481 char *kwnames[] = {
18482 (char *) "self", NULL
18483 };
18484
18485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18487 if (SWIG_arg_fail(1)) SWIG_fail;
18488 result = (unsigned int) ((arg1)->m_rawCode);
18489
18490 {
18491 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18492 }
18493 return resultobj;
18494 fail:
18495 return NULL;
18496 }
18497
18498
18499 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18500 PyObject *resultobj;
18501 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18502 unsigned int arg2 ;
18503 PyObject * obj0 = 0 ;
18504 PyObject * obj1 = 0 ;
18505 char *kwnames[] = {
18506 (char *) "self",(char *) "m_rawFlags", NULL
18507 };
18508
18509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18511 if (SWIG_arg_fail(1)) SWIG_fail;
18512 {
18513 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18514 if (SWIG_arg_fail(2)) SWIG_fail;
18515 }
18516 if (arg1) (arg1)->m_rawFlags = arg2;
18517
18518 Py_INCREF(Py_None); resultobj = Py_None;
18519 return resultobj;
18520 fail:
18521 return NULL;
18522 }
18523
18524
18525 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18526 PyObject *resultobj;
18527 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18528 unsigned int result;
18529 PyObject * obj0 = 0 ;
18530 char *kwnames[] = {
18531 (char *) "self", NULL
18532 };
18533
18534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18536 if (SWIG_arg_fail(1)) SWIG_fail;
18537 result = (unsigned int) ((arg1)->m_rawFlags);
18538
18539 {
18540 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18541 }
18542 return resultobj;
18543 fail:
18544 return NULL;
18545 }
18546
18547
18548 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18549 PyObject *obj;
18550 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18551 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18552 Py_INCREF(obj);
18553 return Py_BuildValue((char *)"");
18554 }
18555 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18556 PyObject *resultobj;
18557 wxSize const &arg1_defvalue = wxDefaultSize ;
18558 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18559 int arg2 = (int) 0 ;
18560 wxSizeEvent *result;
18561 wxSize temp1 ;
18562 PyObject * obj0 = 0 ;
18563 PyObject * obj1 = 0 ;
18564 char *kwnames[] = {
18565 (char *) "sz",(char *) "winid", NULL
18566 };
18567
18568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18569 if (obj0) {
18570 {
18571 arg1 = &temp1;
18572 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18573 }
18574 }
18575 if (obj1) {
18576 {
18577 arg2 = (int)(SWIG_As_int(obj1));
18578 if (SWIG_arg_fail(2)) SWIG_fail;
18579 }
18580 }
18581 {
18582 PyThreadState* __tstate = wxPyBeginAllowThreads();
18583 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18584
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18589 return resultobj;
18590 fail:
18591 return NULL;
18592 }
18593
18594
18595 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18596 PyObject *resultobj;
18597 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18598 wxSize result;
18599 PyObject * obj0 = 0 ;
18600 char *kwnames[] = {
18601 (char *) "self", NULL
18602 };
18603
18604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18606 if (SWIG_arg_fail(1)) SWIG_fail;
18607 {
18608 PyThreadState* __tstate = wxPyBeginAllowThreads();
18609 result = ((wxSizeEvent const *)arg1)->GetSize();
18610
18611 wxPyEndAllowThreads(__tstate);
18612 if (PyErr_Occurred()) SWIG_fail;
18613 }
18614 {
18615 wxSize * resultptr;
18616 resultptr = new wxSize((wxSize &)(result));
18617 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18618 }
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18626 PyObject *resultobj;
18627 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18628 wxRect result;
18629 PyObject * obj0 = 0 ;
18630 char *kwnames[] = {
18631 (char *) "self", NULL
18632 };
18633
18634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18636 if (SWIG_arg_fail(1)) SWIG_fail;
18637 {
18638 PyThreadState* __tstate = wxPyBeginAllowThreads();
18639 result = ((wxSizeEvent const *)arg1)->GetRect();
18640
18641 wxPyEndAllowThreads(__tstate);
18642 if (PyErr_Occurred()) SWIG_fail;
18643 }
18644 {
18645 wxRect * resultptr;
18646 resultptr = new wxRect((wxRect &)(result));
18647 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18648 }
18649 return resultobj;
18650 fail:
18651 return NULL;
18652 }
18653
18654
18655 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18656 PyObject *resultobj;
18657 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18658 wxRect arg2 ;
18659 PyObject * obj0 = 0 ;
18660 PyObject * obj1 = 0 ;
18661 char *kwnames[] = {
18662 (char *) "self",(char *) "rect", NULL
18663 };
18664
18665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18667 if (SWIG_arg_fail(1)) SWIG_fail;
18668 {
18669 wxRect * argp;
18670 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18671 if (SWIG_arg_fail(2)) SWIG_fail;
18672 if (argp == NULL) {
18673 SWIG_null_ref("wxRect");
18674 }
18675 if (SWIG_arg_fail(2)) SWIG_fail;
18676 arg2 = *argp;
18677 }
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 (arg1)->SetRect(arg2);
18681
18682 wxPyEndAllowThreads(__tstate);
18683 if (PyErr_Occurred()) SWIG_fail;
18684 }
18685 Py_INCREF(Py_None); resultobj = Py_None;
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj;
18694 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18695 wxSize arg2 ;
18696 PyObject * obj0 = 0 ;
18697 PyObject * obj1 = 0 ;
18698 char *kwnames[] = {
18699 (char *) "self",(char *) "size", NULL
18700 };
18701
18702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18704 if (SWIG_arg_fail(1)) SWIG_fail;
18705 {
18706 wxSize * argp;
18707 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18708 if (SWIG_arg_fail(2)) SWIG_fail;
18709 if (argp == NULL) {
18710 SWIG_null_ref("wxSize");
18711 }
18712 if (SWIG_arg_fail(2)) SWIG_fail;
18713 arg2 = *argp;
18714 }
18715 {
18716 PyThreadState* __tstate = wxPyBeginAllowThreads();
18717 wxSizeEvent_SetSize(arg1,arg2);
18718
18719 wxPyEndAllowThreads(__tstate);
18720 if (PyErr_Occurred()) SWIG_fail;
18721 }
18722 Py_INCREF(Py_None); resultobj = Py_None;
18723 return resultobj;
18724 fail:
18725 return NULL;
18726 }
18727
18728
18729 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18730 PyObject *resultobj;
18731 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18732 wxSize *arg2 = (wxSize *) 0 ;
18733 PyObject * obj0 = 0 ;
18734 PyObject * obj1 = 0 ;
18735 char *kwnames[] = {
18736 (char *) "self",(char *) "m_size", NULL
18737 };
18738
18739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18741 if (SWIG_arg_fail(1)) SWIG_fail;
18742 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18743 if (SWIG_arg_fail(2)) SWIG_fail;
18744 if (arg1) (arg1)->m_size = *arg2;
18745
18746 Py_INCREF(Py_None); resultobj = Py_None;
18747 return resultobj;
18748 fail:
18749 return NULL;
18750 }
18751
18752
18753 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18754 PyObject *resultobj;
18755 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18756 wxSize *result;
18757 PyObject * obj0 = 0 ;
18758 char *kwnames[] = {
18759 (char *) "self", NULL
18760 };
18761
18762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18764 if (SWIG_arg_fail(1)) SWIG_fail;
18765 result = (wxSize *)& ((arg1)->m_size);
18766
18767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18768 return resultobj;
18769 fail:
18770 return NULL;
18771 }
18772
18773
18774 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18775 PyObject *resultobj;
18776 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18777 wxRect *arg2 = (wxRect *) 0 ;
18778 PyObject * obj0 = 0 ;
18779 PyObject * obj1 = 0 ;
18780 char *kwnames[] = {
18781 (char *) "self",(char *) "m_rect", NULL
18782 };
18783
18784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18786 if (SWIG_arg_fail(1)) SWIG_fail;
18787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18788 if (SWIG_arg_fail(2)) SWIG_fail;
18789 if (arg1) (arg1)->m_rect = *arg2;
18790
18791 Py_INCREF(Py_None); resultobj = Py_None;
18792 return resultobj;
18793 fail:
18794 return NULL;
18795 }
18796
18797
18798 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18799 PyObject *resultobj;
18800 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18801 wxRect *result;
18802 PyObject * obj0 = 0 ;
18803 char *kwnames[] = {
18804 (char *) "self", NULL
18805 };
18806
18807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
18808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18809 if (SWIG_arg_fail(1)) SWIG_fail;
18810 result = (wxRect *)& ((arg1)->m_rect);
18811
18812 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
18813 return resultobj;
18814 fail:
18815 return NULL;
18816 }
18817
18818
18819 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
18820 PyObject *obj;
18821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18822 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
18823 Py_INCREF(obj);
18824 return Py_BuildValue((char *)"");
18825 }
18826 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18827 PyObject *resultobj;
18828 wxPoint const &arg1_defvalue = wxDefaultPosition ;
18829 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
18830 int arg2 = (int) 0 ;
18831 wxMoveEvent *result;
18832 wxPoint temp1 ;
18833 PyObject * obj0 = 0 ;
18834 PyObject * obj1 = 0 ;
18835 char *kwnames[] = {
18836 (char *) "pos",(char *) "winid", NULL
18837 };
18838
18839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
18840 if (obj0) {
18841 {
18842 arg1 = &temp1;
18843 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
18844 }
18845 }
18846 if (obj1) {
18847 {
18848 arg2 = (int)(SWIG_As_int(obj1));
18849 if (SWIG_arg_fail(2)) SWIG_fail;
18850 }
18851 }
18852 {
18853 PyThreadState* __tstate = wxPyBeginAllowThreads();
18854 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
18855
18856 wxPyEndAllowThreads(__tstate);
18857 if (PyErr_Occurred()) SWIG_fail;
18858 }
18859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
18860 return resultobj;
18861 fail:
18862 return NULL;
18863 }
18864
18865
18866 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18867 PyObject *resultobj;
18868 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18869 wxPoint result;
18870 PyObject * obj0 = 0 ;
18871 char *kwnames[] = {
18872 (char *) "self", NULL
18873 };
18874
18875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
18876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18877 if (SWIG_arg_fail(1)) SWIG_fail;
18878 {
18879 PyThreadState* __tstate = wxPyBeginAllowThreads();
18880 result = ((wxMoveEvent const *)arg1)->GetPosition();
18881
18882 wxPyEndAllowThreads(__tstate);
18883 if (PyErr_Occurred()) SWIG_fail;
18884 }
18885 {
18886 wxPoint * resultptr;
18887 resultptr = new wxPoint((wxPoint &)(result));
18888 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18889 }
18890 return resultobj;
18891 fail:
18892 return NULL;
18893 }
18894
18895
18896 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18897 PyObject *resultobj;
18898 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18899 wxRect result;
18900 PyObject * obj0 = 0 ;
18901 char *kwnames[] = {
18902 (char *) "self", NULL
18903 };
18904
18905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
18906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18907 if (SWIG_arg_fail(1)) SWIG_fail;
18908 {
18909 PyThreadState* __tstate = wxPyBeginAllowThreads();
18910 result = ((wxMoveEvent const *)arg1)->GetRect();
18911
18912 wxPyEndAllowThreads(__tstate);
18913 if (PyErr_Occurred()) SWIG_fail;
18914 }
18915 {
18916 wxRect * resultptr;
18917 resultptr = new wxRect((wxRect &)(result));
18918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18919 }
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18927 PyObject *resultobj;
18928 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18929 wxRect arg2 ;
18930 PyObject * obj0 = 0 ;
18931 PyObject * obj1 = 0 ;
18932 char *kwnames[] = {
18933 (char *) "self",(char *) "rect", NULL
18934 };
18935
18936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18938 if (SWIG_arg_fail(1)) SWIG_fail;
18939 {
18940 wxRect * argp;
18941 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18942 if (SWIG_arg_fail(2)) SWIG_fail;
18943 if (argp == NULL) {
18944 SWIG_null_ref("wxRect");
18945 }
18946 if (SWIG_arg_fail(2)) SWIG_fail;
18947 arg2 = *argp;
18948 }
18949 {
18950 PyThreadState* __tstate = wxPyBeginAllowThreads();
18951 (arg1)->SetRect(arg2);
18952
18953 wxPyEndAllowThreads(__tstate);
18954 if (PyErr_Occurred()) SWIG_fail;
18955 }
18956 Py_INCREF(Py_None); resultobj = Py_None;
18957 return resultobj;
18958 fail:
18959 return NULL;
18960 }
18961
18962
18963 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18964 PyObject *resultobj;
18965 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18966 wxPoint arg2 ;
18967 PyObject * obj0 = 0 ;
18968 PyObject * obj1 = 0 ;
18969 char *kwnames[] = {
18970 (char *) "self",(char *) "pos", NULL
18971 };
18972
18973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
18974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18975 if (SWIG_arg_fail(1)) SWIG_fail;
18976 {
18977 wxPoint * argp;
18978 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
18979 if (SWIG_arg_fail(2)) SWIG_fail;
18980 if (argp == NULL) {
18981 SWIG_null_ref("wxPoint");
18982 }
18983 if (SWIG_arg_fail(2)) SWIG_fail;
18984 arg2 = *argp;
18985 }
18986 {
18987 PyThreadState* __tstate = wxPyBeginAllowThreads();
18988 wxMoveEvent_SetPosition(arg1,arg2);
18989
18990 wxPyEndAllowThreads(__tstate);
18991 if (PyErr_Occurred()) SWIG_fail;
18992 }
18993 Py_INCREF(Py_None); resultobj = Py_None;
18994 return resultobj;
18995 fail:
18996 return NULL;
18997 }
18998
18999
19000 static PyObject *_wrap_MoveEvent_m_pos_set(PyObject *, PyObject *args, PyObject *kwargs) {
19001 PyObject *resultobj;
19002 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19003 wxPoint *arg2 = (wxPoint *) 0 ;
19004 PyObject * obj0 = 0 ;
19005 PyObject * obj1 = 0 ;
19006 char *kwnames[] = {
19007 (char *) "self",(char *) "m_pos", NULL
19008 };
19009
19010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_m_pos_set",kwnames,&obj0,&obj1)) goto fail;
19011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19012 if (SWIG_arg_fail(1)) SWIG_fail;
19013 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
19014 if (SWIG_arg_fail(2)) SWIG_fail;
19015 if (arg1) (arg1)->m_pos = *arg2;
19016
19017 Py_INCREF(Py_None); resultobj = Py_None;
19018 return resultobj;
19019 fail:
19020 return NULL;
19021 }
19022
19023
19024 static PyObject *_wrap_MoveEvent_m_pos_get(PyObject *, PyObject *args, PyObject *kwargs) {
19025 PyObject *resultobj;
19026 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19027 wxPoint *result;
19028 PyObject * obj0 = 0 ;
19029 char *kwnames[] = {
19030 (char *) "self", NULL
19031 };
19032
19033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_m_pos_get",kwnames,&obj0)) goto fail;
19034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19035 if (SWIG_arg_fail(1)) SWIG_fail;
19036 result = (wxPoint *)& ((arg1)->m_pos);
19037
19038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
19039 return resultobj;
19040 fail:
19041 return NULL;
19042 }
19043
19044
19045 static PyObject *_wrap_MoveEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19046 PyObject *resultobj;
19047 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19048 wxRect *arg2 = (wxRect *) 0 ;
19049 PyObject * obj0 = 0 ;
19050 PyObject * obj1 = 0 ;
19051 char *kwnames[] = {
19052 (char *) "self",(char *) "m_rect", NULL
19053 };
19054
19055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19057 if (SWIG_arg_fail(1)) SWIG_fail;
19058 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19059 if (SWIG_arg_fail(2)) SWIG_fail;
19060 if (arg1) (arg1)->m_rect = *arg2;
19061
19062 Py_INCREF(Py_None); resultobj = Py_None;
19063 return resultobj;
19064 fail:
19065 return NULL;
19066 }
19067
19068
19069 static PyObject *_wrap_MoveEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19070 PyObject *resultobj;
19071 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19072 wxRect *result;
19073 PyObject * obj0 = 0 ;
19074 char *kwnames[] = {
19075 (char *) "self", NULL
19076 };
19077
19078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_m_rect_get",kwnames,&obj0)) goto fail;
19079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19080 if (SWIG_arg_fail(1)) SWIG_fail;
19081 result = (wxRect *)& ((arg1)->m_rect);
19082
19083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19084 return resultobj;
19085 fail:
19086 return NULL;
19087 }
19088
19089
19090 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19091 PyObject *obj;
19092 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19093 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19094 Py_INCREF(obj);
19095 return Py_BuildValue((char *)"");
19096 }
19097 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19098 PyObject *resultobj;
19099 int arg1 = (int) 0 ;
19100 wxPaintEvent *result;
19101 PyObject * obj0 = 0 ;
19102 char *kwnames[] = {
19103 (char *) "Id", NULL
19104 };
19105
19106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19107 if (obj0) {
19108 {
19109 arg1 = (int)(SWIG_As_int(obj0));
19110 if (SWIG_arg_fail(1)) SWIG_fail;
19111 }
19112 }
19113 {
19114 PyThreadState* __tstate = wxPyBeginAllowThreads();
19115 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19116
19117 wxPyEndAllowThreads(__tstate);
19118 if (PyErr_Occurred()) SWIG_fail;
19119 }
19120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19121 return resultobj;
19122 fail:
19123 return NULL;
19124 }
19125
19126
19127 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19128 PyObject *obj;
19129 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19130 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19131 Py_INCREF(obj);
19132 return Py_BuildValue((char *)"");
19133 }
19134 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19135 PyObject *resultobj;
19136 int arg1 = (int) 0 ;
19137 wxNcPaintEvent *result;
19138 PyObject * obj0 = 0 ;
19139 char *kwnames[] = {
19140 (char *) "winid", NULL
19141 };
19142
19143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19144 if (obj0) {
19145 {
19146 arg1 = (int)(SWIG_As_int(obj0));
19147 if (SWIG_arg_fail(1)) SWIG_fail;
19148 }
19149 }
19150 {
19151 PyThreadState* __tstate = wxPyBeginAllowThreads();
19152 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19153
19154 wxPyEndAllowThreads(__tstate);
19155 if (PyErr_Occurred()) SWIG_fail;
19156 }
19157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19158 return resultobj;
19159 fail:
19160 return NULL;
19161 }
19162
19163
19164 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19165 PyObject *obj;
19166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19167 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19168 Py_INCREF(obj);
19169 return Py_BuildValue((char *)"");
19170 }
19171 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19172 PyObject *resultobj;
19173 int arg1 = (int) 0 ;
19174 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19175 wxEraseEvent *result;
19176 PyObject * obj0 = 0 ;
19177 PyObject * obj1 = 0 ;
19178 char *kwnames[] = {
19179 (char *) "Id",(char *) "dc", NULL
19180 };
19181
19182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19183 if (obj0) {
19184 {
19185 arg1 = (int)(SWIG_As_int(obj0));
19186 if (SWIG_arg_fail(1)) SWIG_fail;
19187 }
19188 }
19189 if (obj1) {
19190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19191 if (SWIG_arg_fail(2)) SWIG_fail;
19192 }
19193 {
19194 PyThreadState* __tstate = wxPyBeginAllowThreads();
19195 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19196
19197 wxPyEndAllowThreads(__tstate);
19198 if (PyErr_Occurred()) SWIG_fail;
19199 }
19200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19201 return resultobj;
19202 fail:
19203 return NULL;
19204 }
19205
19206
19207 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19208 PyObject *resultobj;
19209 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19210 wxDC *result;
19211 PyObject * obj0 = 0 ;
19212 char *kwnames[] = {
19213 (char *) "self", NULL
19214 };
19215
19216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19218 if (SWIG_arg_fail(1)) SWIG_fail;
19219 {
19220 PyThreadState* __tstate = wxPyBeginAllowThreads();
19221 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19222
19223 wxPyEndAllowThreads(__tstate);
19224 if (PyErr_Occurred()) SWIG_fail;
19225 }
19226 {
19227 resultobj = wxPyMake_wxObject(result, 0);
19228 }
19229 return resultobj;
19230 fail:
19231 return NULL;
19232 }
19233
19234
19235 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19236 PyObject *obj;
19237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19238 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19239 Py_INCREF(obj);
19240 return Py_BuildValue((char *)"");
19241 }
19242 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19243 PyObject *resultobj;
19244 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19245 int arg2 = (int) 0 ;
19246 wxFocusEvent *result;
19247 PyObject * obj0 = 0 ;
19248 PyObject * obj1 = 0 ;
19249 char *kwnames[] = {
19250 (char *) "type",(char *) "winid", NULL
19251 };
19252
19253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19254 if (obj0) {
19255 {
19256 arg1 = (wxEventType)(SWIG_As_int(obj0));
19257 if (SWIG_arg_fail(1)) SWIG_fail;
19258 }
19259 }
19260 if (obj1) {
19261 {
19262 arg2 = (int)(SWIG_As_int(obj1));
19263 if (SWIG_arg_fail(2)) SWIG_fail;
19264 }
19265 }
19266 {
19267 PyThreadState* __tstate = wxPyBeginAllowThreads();
19268 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19269
19270 wxPyEndAllowThreads(__tstate);
19271 if (PyErr_Occurred()) SWIG_fail;
19272 }
19273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19274 return resultobj;
19275 fail:
19276 return NULL;
19277 }
19278
19279
19280 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19281 PyObject *resultobj;
19282 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19283 wxWindow *result;
19284 PyObject * obj0 = 0 ;
19285 char *kwnames[] = {
19286 (char *) "self", NULL
19287 };
19288
19289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19291 if (SWIG_arg_fail(1)) SWIG_fail;
19292 {
19293 PyThreadState* __tstate = wxPyBeginAllowThreads();
19294 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19295
19296 wxPyEndAllowThreads(__tstate);
19297 if (PyErr_Occurred()) SWIG_fail;
19298 }
19299 {
19300 resultobj = wxPyMake_wxObject(result, 0);
19301 }
19302 return resultobj;
19303 fail:
19304 return NULL;
19305 }
19306
19307
19308 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19309 PyObject *resultobj;
19310 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19311 wxWindow *arg2 = (wxWindow *) 0 ;
19312 PyObject * obj0 = 0 ;
19313 PyObject * obj1 = 0 ;
19314 char *kwnames[] = {
19315 (char *) "self",(char *) "win", NULL
19316 };
19317
19318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19320 if (SWIG_arg_fail(1)) SWIG_fail;
19321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19322 if (SWIG_arg_fail(2)) SWIG_fail;
19323 {
19324 PyThreadState* __tstate = wxPyBeginAllowThreads();
19325 (arg1)->SetWindow(arg2);
19326
19327 wxPyEndAllowThreads(__tstate);
19328 if (PyErr_Occurred()) SWIG_fail;
19329 }
19330 Py_INCREF(Py_None); resultobj = Py_None;
19331 return resultobj;
19332 fail:
19333 return NULL;
19334 }
19335
19336
19337 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19338 PyObject *obj;
19339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19340 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19341 Py_INCREF(obj);
19342 return Py_BuildValue((char *)"");
19343 }
19344 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19345 PyObject *resultobj;
19346 wxWindow *arg1 = (wxWindow *) NULL ;
19347 wxChildFocusEvent *result;
19348 PyObject * obj0 = 0 ;
19349 char *kwnames[] = {
19350 (char *) "win", NULL
19351 };
19352
19353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19354 if (obj0) {
19355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19356 if (SWIG_arg_fail(1)) SWIG_fail;
19357 }
19358 {
19359 PyThreadState* __tstate = wxPyBeginAllowThreads();
19360 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19361
19362 wxPyEndAllowThreads(__tstate);
19363 if (PyErr_Occurred()) SWIG_fail;
19364 }
19365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19366 return resultobj;
19367 fail:
19368 return NULL;
19369 }
19370
19371
19372 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19373 PyObject *resultobj;
19374 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19375 wxWindow *result;
19376 PyObject * obj0 = 0 ;
19377 char *kwnames[] = {
19378 (char *) "self", NULL
19379 };
19380
19381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19383 if (SWIG_arg_fail(1)) SWIG_fail;
19384 {
19385 PyThreadState* __tstate = wxPyBeginAllowThreads();
19386 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19387
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 {
19392 resultobj = wxPyMake_wxObject(result, 0);
19393 }
19394 return resultobj;
19395 fail:
19396 return NULL;
19397 }
19398
19399
19400 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19401 PyObject *obj;
19402 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19403 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19404 Py_INCREF(obj);
19405 return Py_BuildValue((char *)"");
19406 }
19407 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19408 PyObject *resultobj;
19409 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19410 bool arg2 = (bool) true ;
19411 int arg3 = (int) 0 ;
19412 wxActivateEvent *result;
19413 PyObject * obj0 = 0 ;
19414 PyObject * obj1 = 0 ;
19415 PyObject * obj2 = 0 ;
19416 char *kwnames[] = {
19417 (char *) "type",(char *) "active",(char *) "Id", NULL
19418 };
19419
19420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19421 if (obj0) {
19422 {
19423 arg1 = (wxEventType)(SWIG_As_int(obj0));
19424 if (SWIG_arg_fail(1)) SWIG_fail;
19425 }
19426 }
19427 if (obj1) {
19428 {
19429 arg2 = (bool)(SWIG_As_bool(obj1));
19430 if (SWIG_arg_fail(2)) SWIG_fail;
19431 }
19432 }
19433 if (obj2) {
19434 {
19435 arg3 = (int)(SWIG_As_int(obj2));
19436 if (SWIG_arg_fail(3)) SWIG_fail;
19437 }
19438 }
19439 {
19440 PyThreadState* __tstate = wxPyBeginAllowThreads();
19441 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19442
19443 wxPyEndAllowThreads(__tstate);
19444 if (PyErr_Occurred()) SWIG_fail;
19445 }
19446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19447 return resultobj;
19448 fail:
19449 return NULL;
19450 }
19451
19452
19453 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19454 PyObject *resultobj;
19455 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19456 bool result;
19457 PyObject * obj0 = 0 ;
19458 char *kwnames[] = {
19459 (char *) "self", NULL
19460 };
19461
19462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19464 if (SWIG_arg_fail(1)) SWIG_fail;
19465 {
19466 PyThreadState* __tstate = wxPyBeginAllowThreads();
19467 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19468
19469 wxPyEndAllowThreads(__tstate);
19470 if (PyErr_Occurred()) SWIG_fail;
19471 }
19472 {
19473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19474 }
19475 return resultobj;
19476 fail:
19477 return NULL;
19478 }
19479
19480
19481 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19482 PyObject *obj;
19483 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19484 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19485 Py_INCREF(obj);
19486 return Py_BuildValue((char *)"");
19487 }
19488 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19489 PyObject *resultobj;
19490 int arg1 = (int) 0 ;
19491 wxInitDialogEvent *result;
19492 PyObject * obj0 = 0 ;
19493 char *kwnames[] = {
19494 (char *) "Id", NULL
19495 };
19496
19497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19498 if (obj0) {
19499 {
19500 arg1 = (int)(SWIG_As_int(obj0));
19501 if (SWIG_arg_fail(1)) SWIG_fail;
19502 }
19503 }
19504 {
19505 PyThreadState* __tstate = wxPyBeginAllowThreads();
19506 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19507
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19512 return resultobj;
19513 fail:
19514 return NULL;
19515 }
19516
19517
19518 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19519 PyObject *obj;
19520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19521 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19522 Py_INCREF(obj);
19523 return Py_BuildValue((char *)"");
19524 }
19525 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19526 PyObject *resultobj;
19527 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19528 int arg2 = (int) 0 ;
19529 wxMenu *arg3 = (wxMenu *) NULL ;
19530 wxMenuEvent *result;
19531 PyObject * obj0 = 0 ;
19532 PyObject * obj1 = 0 ;
19533 PyObject * obj2 = 0 ;
19534 char *kwnames[] = {
19535 (char *) "type",(char *) "winid",(char *) "menu", NULL
19536 };
19537
19538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19539 if (obj0) {
19540 {
19541 arg1 = (wxEventType)(SWIG_As_int(obj0));
19542 if (SWIG_arg_fail(1)) SWIG_fail;
19543 }
19544 }
19545 if (obj1) {
19546 {
19547 arg2 = (int)(SWIG_As_int(obj1));
19548 if (SWIG_arg_fail(2)) SWIG_fail;
19549 }
19550 }
19551 if (obj2) {
19552 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19553 if (SWIG_arg_fail(3)) SWIG_fail;
19554 }
19555 {
19556 PyThreadState* __tstate = wxPyBeginAllowThreads();
19557 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19558
19559 wxPyEndAllowThreads(__tstate);
19560 if (PyErr_Occurred()) SWIG_fail;
19561 }
19562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19563 return resultobj;
19564 fail:
19565 return NULL;
19566 }
19567
19568
19569 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19570 PyObject *resultobj;
19571 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19572 int result;
19573 PyObject * obj0 = 0 ;
19574 char *kwnames[] = {
19575 (char *) "self", NULL
19576 };
19577
19578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19580 if (SWIG_arg_fail(1)) SWIG_fail;
19581 {
19582 PyThreadState* __tstate = wxPyBeginAllowThreads();
19583 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19584
19585 wxPyEndAllowThreads(__tstate);
19586 if (PyErr_Occurred()) SWIG_fail;
19587 }
19588 {
19589 resultobj = SWIG_From_int((int)(result));
19590 }
19591 return resultobj;
19592 fail:
19593 return NULL;
19594 }
19595
19596
19597 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19598 PyObject *resultobj;
19599 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19600 bool result;
19601 PyObject * obj0 = 0 ;
19602 char *kwnames[] = {
19603 (char *) "self", NULL
19604 };
19605
19606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19608 if (SWIG_arg_fail(1)) SWIG_fail;
19609 {
19610 PyThreadState* __tstate = wxPyBeginAllowThreads();
19611 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19612
19613 wxPyEndAllowThreads(__tstate);
19614 if (PyErr_Occurred()) SWIG_fail;
19615 }
19616 {
19617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19618 }
19619 return resultobj;
19620 fail:
19621 return NULL;
19622 }
19623
19624
19625 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19626 PyObject *resultobj;
19627 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19628 wxMenu *result;
19629 PyObject * obj0 = 0 ;
19630 char *kwnames[] = {
19631 (char *) "self", NULL
19632 };
19633
19634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19636 if (SWIG_arg_fail(1)) SWIG_fail;
19637 {
19638 PyThreadState* __tstate = wxPyBeginAllowThreads();
19639 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19640
19641 wxPyEndAllowThreads(__tstate);
19642 if (PyErr_Occurred()) SWIG_fail;
19643 }
19644 {
19645 resultobj = wxPyMake_wxObject(result, 0);
19646 }
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19654 PyObject *obj;
19655 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19656 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19657 Py_INCREF(obj);
19658 return Py_BuildValue((char *)"");
19659 }
19660 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19661 PyObject *resultobj;
19662 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19663 int arg2 = (int) 0 ;
19664 wxCloseEvent *result;
19665 PyObject * obj0 = 0 ;
19666 PyObject * obj1 = 0 ;
19667 char *kwnames[] = {
19668 (char *) "type",(char *) "winid", NULL
19669 };
19670
19671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19672 if (obj0) {
19673 {
19674 arg1 = (wxEventType)(SWIG_As_int(obj0));
19675 if (SWIG_arg_fail(1)) SWIG_fail;
19676 }
19677 }
19678 if (obj1) {
19679 {
19680 arg2 = (int)(SWIG_As_int(obj1));
19681 if (SWIG_arg_fail(2)) SWIG_fail;
19682 }
19683 }
19684 {
19685 PyThreadState* __tstate = wxPyBeginAllowThreads();
19686 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19687
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19692 return resultobj;
19693 fail:
19694 return NULL;
19695 }
19696
19697
19698 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19699 PyObject *resultobj;
19700 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19701 bool arg2 ;
19702 PyObject * obj0 = 0 ;
19703 PyObject * obj1 = 0 ;
19704 char *kwnames[] = {
19705 (char *) "self",(char *) "logOff", NULL
19706 };
19707
19708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19710 if (SWIG_arg_fail(1)) SWIG_fail;
19711 {
19712 arg2 = (bool)(SWIG_As_bool(obj1));
19713 if (SWIG_arg_fail(2)) SWIG_fail;
19714 }
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 (arg1)->SetLoggingOff(arg2);
19718
19719 wxPyEndAllowThreads(__tstate);
19720 if (PyErr_Occurred()) SWIG_fail;
19721 }
19722 Py_INCREF(Py_None); resultobj = Py_None;
19723 return resultobj;
19724 fail:
19725 return NULL;
19726 }
19727
19728
19729 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19730 PyObject *resultobj;
19731 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19732 bool result;
19733 PyObject * obj0 = 0 ;
19734 char *kwnames[] = {
19735 (char *) "self", NULL
19736 };
19737
19738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19740 if (SWIG_arg_fail(1)) SWIG_fail;
19741 {
19742 PyThreadState* __tstate = wxPyBeginAllowThreads();
19743 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19744
19745 wxPyEndAllowThreads(__tstate);
19746 if (PyErr_Occurred()) SWIG_fail;
19747 }
19748 {
19749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19750 }
19751 return resultobj;
19752 fail:
19753 return NULL;
19754 }
19755
19756
19757 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19758 PyObject *resultobj;
19759 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19760 bool arg2 = (bool) true ;
19761 PyObject * obj0 = 0 ;
19762 PyObject * obj1 = 0 ;
19763 char *kwnames[] = {
19764 (char *) "self",(char *) "veto", NULL
19765 };
19766
19767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19769 if (SWIG_arg_fail(1)) SWIG_fail;
19770 if (obj1) {
19771 {
19772 arg2 = (bool)(SWIG_As_bool(obj1));
19773 if (SWIG_arg_fail(2)) SWIG_fail;
19774 }
19775 }
19776 {
19777 PyThreadState* __tstate = wxPyBeginAllowThreads();
19778 (arg1)->Veto(arg2);
19779
19780 wxPyEndAllowThreads(__tstate);
19781 if (PyErr_Occurred()) SWIG_fail;
19782 }
19783 Py_INCREF(Py_None); resultobj = Py_None;
19784 return resultobj;
19785 fail:
19786 return NULL;
19787 }
19788
19789
19790 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19791 PyObject *resultobj;
19792 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19793 bool arg2 ;
19794 PyObject * obj0 = 0 ;
19795 PyObject * obj1 = 0 ;
19796 char *kwnames[] = {
19797 (char *) "self",(char *) "canVeto", NULL
19798 };
19799
19800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19802 if (SWIG_arg_fail(1)) SWIG_fail;
19803 {
19804 arg2 = (bool)(SWIG_As_bool(obj1));
19805 if (SWIG_arg_fail(2)) SWIG_fail;
19806 }
19807 {
19808 PyThreadState* __tstate = wxPyBeginAllowThreads();
19809 (arg1)->SetCanVeto(arg2);
19810
19811 wxPyEndAllowThreads(__tstate);
19812 if (PyErr_Occurred()) SWIG_fail;
19813 }
19814 Py_INCREF(Py_None); resultobj = Py_None;
19815 return resultobj;
19816 fail:
19817 return NULL;
19818 }
19819
19820
19821 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19822 PyObject *resultobj;
19823 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19824 bool result;
19825 PyObject * obj0 = 0 ;
19826 char *kwnames[] = {
19827 (char *) "self", NULL
19828 };
19829
19830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19832 if (SWIG_arg_fail(1)) SWIG_fail;
19833 {
19834 PyThreadState* __tstate = wxPyBeginAllowThreads();
19835 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19836
19837 wxPyEndAllowThreads(__tstate);
19838 if (PyErr_Occurred()) SWIG_fail;
19839 }
19840 {
19841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19842 }
19843 return resultobj;
19844 fail:
19845 return NULL;
19846 }
19847
19848
19849 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19850 PyObject *resultobj;
19851 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19852 bool result;
19853 PyObject * obj0 = 0 ;
19854 char *kwnames[] = {
19855 (char *) "self", NULL
19856 };
19857
19858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19860 if (SWIG_arg_fail(1)) SWIG_fail;
19861 {
19862 PyThreadState* __tstate = wxPyBeginAllowThreads();
19863 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19864
19865 wxPyEndAllowThreads(__tstate);
19866 if (PyErr_Occurred()) SWIG_fail;
19867 }
19868 {
19869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19870 }
19871 return resultobj;
19872 fail:
19873 return NULL;
19874 }
19875
19876
19877 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19878 PyObject *obj;
19879 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19880 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19881 Py_INCREF(obj);
19882 return Py_BuildValue((char *)"");
19883 }
19884 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19885 PyObject *resultobj;
19886 int arg1 = (int) 0 ;
19887 bool arg2 = (bool) false ;
19888 wxShowEvent *result;
19889 PyObject * obj0 = 0 ;
19890 PyObject * obj1 = 0 ;
19891 char *kwnames[] = {
19892 (char *) "winid",(char *) "show", NULL
19893 };
19894
19895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19896 if (obj0) {
19897 {
19898 arg1 = (int)(SWIG_As_int(obj0));
19899 if (SWIG_arg_fail(1)) SWIG_fail;
19900 }
19901 }
19902 if (obj1) {
19903 {
19904 arg2 = (bool)(SWIG_As_bool(obj1));
19905 if (SWIG_arg_fail(2)) SWIG_fail;
19906 }
19907 }
19908 {
19909 PyThreadState* __tstate = wxPyBeginAllowThreads();
19910 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
19911
19912 wxPyEndAllowThreads(__tstate);
19913 if (PyErr_Occurred()) SWIG_fail;
19914 }
19915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
19916 return resultobj;
19917 fail:
19918 return NULL;
19919 }
19920
19921
19922 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19923 PyObject *resultobj;
19924 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19925 bool arg2 ;
19926 PyObject * obj0 = 0 ;
19927 PyObject * obj1 = 0 ;
19928 char *kwnames[] = {
19929 (char *) "self",(char *) "show", NULL
19930 };
19931
19932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
19933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19934 if (SWIG_arg_fail(1)) SWIG_fail;
19935 {
19936 arg2 = (bool)(SWIG_As_bool(obj1));
19937 if (SWIG_arg_fail(2)) SWIG_fail;
19938 }
19939 {
19940 PyThreadState* __tstate = wxPyBeginAllowThreads();
19941 (arg1)->SetShow(arg2);
19942
19943 wxPyEndAllowThreads(__tstate);
19944 if (PyErr_Occurred()) SWIG_fail;
19945 }
19946 Py_INCREF(Py_None); resultobj = Py_None;
19947 return resultobj;
19948 fail:
19949 return NULL;
19950 }
19951
19952
19953 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19954 PyObject *resultobj;
19955 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19956 bool result;
19957 PyObject * obj0 = 0 ;
19958 char *kwnames[] = {
19959 (char *) "self", NULL
19960 };
19961
19962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
19963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19964 if (SWIG_arg_fail(1)) SWIG_fail;
19965 {
19966 PyThreadState* __tstate = wxPyBeginAllowThreads();
19967 result = (bool)((wxShowEvent const *)arg1)->GetShow();
19968
19969 wxPyEndAllowThreads(__tstate);
19970 if (PyErr_Occurred()) SWIG_fail;
19971 }
19972 {
19973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19974 }
19975 return resultobj;
19976 fail:
19977 return NULL;
19978 }
19979
19980
19981 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
19982 PyObject *obj;
19983 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19984 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
19985 Py_INCREF(obj);
19986 return Py_BuildValue((char *)"");
19987 }
19988 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19989 PyObject *resultobj;
19990 int arg1 = (int) 0 ;
19991 bool arg2 = (bool) true ;
19992 wxIconizeEvent *result;
19993 PyObject * obj0 = 0 ;
19994 PyObject * obj1 = 0 ;
19995 char *kwnames[] = {
19996 (char *) "id",(char *) "iconized", NULL
19997 };
19998
19999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20000 if (obj0) {
20001 {
20002 arg1 = (int)(SWIG_As_int(obj0));
20003 if (SWIG_arg_fail(1)) SWIG_fail;
20004 }
20005 }
20006 if (obj1) {
20007 {
20008 arg2 = (bool)(SWIG_As_bool(obj1));
20009 if (SWIG_arg_fail(2)) SWIG_fail;
20010 }
20011 }
20012 {
20013 PyThreadState* __tstate = wxPyBeginAllowThreads();
20014 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20015
20016 wxPyEndAllowThreads(__tstate);
20017 if (PyErr_Occurred()) SWIG_fail;
20018 }
20019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20020 return resultobj;
20021 fail:
20022 return NULL;
20023 }
20024
20025
20026 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20027 PyObject *resultobj;
20028 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20029 bool result;
20030 PyObject * obj0 = 0 ;
20031 char *kwnames[] = {
20032 (char *) "self", NULL
20033 };
20034
20035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20037 if (SWIG_arg_fail(1)) SWIG_fail;
20038 {
20039 PyThreadState* __tstate = wxPyBeginAllowThreads();
20040 result = (bool)(arg1)->Iconized();
20041
20042 wxPyEndAllowThreads(__tstate);
20043 if (PyErr_Occurred()) SWIG_fail;
20044 }
20045 {
20046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20047 }
20048 return resultobj;
20049 fail:
20050 return NULL;
20051 }
20052
20053
20054 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20055 PyObject *obj;
20056 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20057 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20058 Py_INCREF(obj);
20059 return Py_BuildValue((char *)"");
20060 }
20061 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20062 PyObject *resultobj;
20063 int arg1 = (int) 0 ;
20064 wxMaximizeEvent *result;
20065 PyObject * obj0 = 0 ;
20066 char *kwnames[] = {
20067 (char *) "id", NULL
20068 };
20069
20070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20071 if (obj0) {
20072 {
20073 arg1 = (int)(SWIG_As_int(obj0));
20074 if (SWIG_arg_fail(1)) SWIG_fail;
20075 }
20076 }
20077 {
20078 PyThreadState* __tstate = wxPyBeginAllowThreads();
20079 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20080
20081 wxPyEndAllowThreads(__tstate);
20082 if (PyErr_Occurred()) SWIG_fail;
20083 }
20084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20085 return resultobj;
20086 fail:
20087 return NULL;
20088 }
20089
20090
20091 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20092 PyObject *obj;
20093 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20094 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20095 Py_INCREF(obj);
20096 return Py_BuildValue((char *)"");
20097 }
20098 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20099 PyObject *resultobj;
20100 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20101 wxPoint result;
20102 PyObject * obj0 = 0 ;
20103 char *kwnames[] = {
20104 (char *) "self", NULL
20105 };
20106
20107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20109 if (SWIG_arg_fail(1)) SWIG_fail;
20110 {
20111 PyThreadState* __tstate = wxPyBeginAllowThreads();
20112 result = (arg1)->GetPosition();
20113
20114 wxPyEndAllowThreads(__tstate);
20115 if (PyErr_Occurred()) SWIG_fail;
20116 }
20117 {
20118 wxPoint * resultptr;
20119 resultptr = new wxPoint((wxPoint &)(result));
20120 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20121 }
20122 return resultobj;
20123 fail:
20124 return NULL;
20125 }
20126
20127
20128 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20129 PyObject *resultobj;
20130 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20131 int result;
20132 PyObject * obj0 = 0 ;
20133 char *kwnames[] = {
20134 (char *) "self", NULL
20135 };
20136
20137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20139 if (SWIG_arg_fail(1)) SWIG_fail;
20140 {
20141 PyThreadState* __tstate = wxPyBeginAllowThreads();
20142 result = (int)(arg1)->GetNumberOfFiles();
20143
20144 wxPyEndAllowThreads(__tstate);
20145 if (PyErr_Occurred()) SWIG_fail;
20146 }
20147 {
20148 resultobj = SWIG_From_int((int)(result));
20149 }
20150 return resultobj;
20151 fail:
20152 return NULL;
20153 }
20154
20155
20156 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20157 PyObject *resultobj;
20158 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20159 PyObject *result;
20160 PyObject * obj0 = 0 ;
20161 char *kwnames[] = {
20162 (char *) "self", NULL
20163 };
20164
20165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20167 if (SWIG_arg_fail(1)) SWIG_fail;
20168 {
20169 PyThreadState* __tstate = wxPyBeginAllowThreads();
20170 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20171
20172 wxPyEndAllowThreads(__tstate);
20173 if (PyErr_Occurred()) SWIG_fail;
20174 }
20175 resultobj = result;
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20183 PyObject *obj;
20184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20185 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20186 Py_INCREF(obj);
20187 return Py_BuildValue((char *)"");
20188 }
20189 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20190 PyObject *resultobj;
20191 int arg1 = (int) 0 ;
20192 wxUpdateUIEvent *result;
20193 PyObject * obj0 = 0 ;
20194 char *kwnames[] = {
20195 (char *) "commandId", NULL
20196 };
20197
20198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20199 if (obj0) {
20200 {
20201 arg1 = (int)(SWIG_As_int(obj0));
20202 if (SWIG_arg_fail(1)) SWIG_fail;
20203 }
20204 }
20205 {
20206 PyThreadState* __tstate = wxPyBeginAllowThreads();
20207 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20208
20209 wxPyEndAllowThreads(__tstate);
20210 if (PyErr_Occurred()) SWIG_fail;
20211 }
20212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20213 return resultobj;
20214 fail:
20215 return NULL;
20216 }
20217
20218
20219 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20220 PyObject *resultobj;
20221 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20222 bool result;
20223 PyObject * obj0 = 0 ;
20224 char *kwnames[] = {
20225 (char *) "self", NULL
20226 };
20227
20228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20230 if (SWIG_arg_fail(1)) SWIG_fail;
20231 {
20232 PyThreadState* __tstate = wxPyBeginAllowThreads();
20233 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20234
20235 wxPyEndAllowThreads(__tstate);
20236 if (PyErr_Occurred()) SWIG_fail;
20237 }
20238 {
20239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20240 }
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20248 PyObject *resultobj;
20249 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20250 bool result;
20251 PyObject * obj0 = 0 ;
20252 char *kwnames[] = {
20253 (char *) "self", NULL
20254 };
20255
20256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20258 if (SWIG_arg_fail(1)) SWIG_fail;
20259 {
20260 PyThreadState* __tstate = wxPyBeginAllowThreads();
20261 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20262
20263 wxPyEndAllowThreads(__tstate);
20264 if (PyErr_Occurred()) SWIG_fail;
20265 }
20266 {
20267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20268 }
20269 return resultobj;
20270 fail:
20271 return NULL;
20272 }
20273
20274
20275 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20276 PyObject *resultobj;
20277 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20278 wxString result;
20279 PyObject * obj0 = 0 ;
20280 char *kwnames[] = {
20281 (char *) "self", NULL
20282 };
20283
20284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20286 if (SWIG_arg_fail(1)) SWIG_fail;
20287 {
20288 PyThreadState* __tstate = wxPyBeginAllowThreads();
20289 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20290
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 {
20295 #if wxUSE_UNICODE
20296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20297 #else
20298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20299 #endif
20300 }
20301 return resultobj;
20302 fail:
20303 return NULL;
20304 }
20305
20306
20307 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20308 PyObject *resultobj;
20309 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20310 bool result;
20311 PyObject * obj0 = 0 ;
20312 char *kwnames[] = {
20313 (char *) "self", NULL
20314 };
20315
20316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20318 if (SWIG_arg_fail(1)) SWIG_fail;
20319 {
20320 PyThreadState* __tstate = wxPyBeginAllowThreads();
20321 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20322
20323 wxPyEndAllowThreads(__tstate);
20324 if (PyErr_Occurred()) SWIG_fail;
20325 }
20326 {
20327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20328 }
20329 return resultobj;
20330 fail:
20331 return NULL;
20332 }
20333
20334
20335 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20336 PyObject *resultobj;
20337 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20338 bool result;
20339 PyObject * obj0 = 0 ;
20340 char *kwnames[] = {
20341 (char *) "self", NULL
20342 };
20343
20344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20346 if (SWIG_arg_fail(1)) SWIG_fail;
20347 {
20348 PyThreadState* __tstate = wxPyBeginAllowThreads();
20349 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20350
20351 wxPyEndAllowThreads(__tstate);
20352 if (PyErr_Occurred()) SWIG_fail;
20353 }
20354 {
20355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20356 }
20357 return resultobj;
20358 fail:
20359 return NULL;
20360 }
20361
20362
20363 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20364 PyObject *resultobj;
20365 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20366 bool result;
20367 PyObject * obj0 = 0 ;
20368 char *kwnames[] = {
20369 (char *) "self", NULL
20370 };
20371
20372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20374 if (SWIG_arg_fail(1)) SWIG_fail;
20375 {
20376 PyThreadState* __tstate = wxPyBeginAllowThreads();
20377 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20378
20379 wxPyEndAllowThreads(__tstate);
20380 if (PyErr_Occurred()) SWIG_fail;
20381 }
20382 {
20383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20384 }
20385 return resultobj;
20386 fail:
20387 return NULL;
20388 }
20389
20390
20391 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20392 PyObject *resultobj;
20393 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20394 bool arg2 ;
20395 PyObject * obj0 = 0 ;
20396 PyObject * obj1 = 0 ;
20397 char *kwnames[] = {
20398 (char *) "self",(char *) "check", NULL
20399 };
20400
20401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20403 if (SWIG_arg_fail(1)) SWIG_fail;
20404 {
20405 arg2 = (bool)(SWIG_As_bool(obj1));
20406 if (SWIG_arg_fail(2)) SWIG_fail;
20407 }
20408 {
20409 PyThreadState* __tstate = wxPyBeginAllowThreads();
20410 (arg1)->Check(arg2);
20411
20412 wxPyEndAllowThreads(__tstate);
20413 if (PyErr_Occurred()) SWIG_fail;
20414 }
20415 Py_INCREF(Py_None); resultobj = Py_None;
20416 return resultobj;
20417 fail:
20418 return NULL;
20419 }
20420
20421
20422 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20423 PyObject *resultobj;
20424 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20425 bool arg2 ;
20426 PyObject * obj0 = 0 ;
20427 PyObject * obj1 = 0 ;
20428 char *kwnames[] = {
20429 (char *) "self",(char *) "enable", NULL
20430 };
20431
20432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20434 if (SWIG_arg_fail(1)) SWIG_fail;
20435 {
20436 arg2 = (bool)(SWIG_As_bool(obj1));
20437 if (SWIG_arg_fail(2)) SWIG_fail;
20438 }
20439 {
20440 PyThreadState* __tstate = wxPyBeginAllowThreads();
20441 (arg1)->Enable(arg2);
20442
20443 wxPyEndAllowThreads(__tstate);
20444 if (PyErr_Occurred()) SWIG_fail;
20445 }
20446 Py_INCREF(Py_None); resultobj = Py_None;
20447 return resultobj;
20448 fail:
20449 return NULL;
20450 }
20451
20452
20453 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20454 PyObject *resultobj;
20455 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20456 wxString *arg2 = 0 ;
20457 bool temp2 = false ;
20458 PyObject * obj0 = 0 ;
20459 PyObject * obj1 = 0 ;
20460 char *kwnames[] = {
20461 (char *) "self",(char *) "text", NULL
20462 };
20463
20464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20466 if (SWIG_arg_fail(1)) SWIG_fail;
20467 {
20468 arg2 = wxString_in_helper(obj1);
20469 if (arg2 == NULL) SWIG_fail;
20470 temp2 = true;
20471 }
20472 {
20473 PyThreadState* __tstate = wxPyBeginAllowThreads();
20474 (arg1)->SetText((wxString const &)*arg2);
20475
20476 wxPyEndAllowThreads(__tstate);
20477 if (PyErr_Occurred()) SWIG_fail;
20478 }
20479 Py_INCREF(Py_None); resultobj = Py_None;
20480 {
20481 if (temp2)
20482 delete arg2;
20483 }
20484 return resultobj;
20485 fail:
20486 {
20487 if (temp2)
20488 delete arg2;
20489 }
20490 return NULL;
20491 }
20492
20493
20494 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20495 PyObject *resultobj;
20496 long arg1 ;
20497 PyObject * obj0 = 0 ;
20498 char *kwnames[] = {
20499 (char *) "updateInterval", NULL
20500 };
20501
20502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20503 {
20504 arg1 = (long)(SWIG_As_long(obj0));
20505 if (SWIG_arg_fail(1)) SWIG_fail;
20506 }
20507 {
20508 PyThreadState* __tstate = wxPyBeginAllowThreads();
20509 wxUpdateUIEvent::SetUpdateInterval(arg1);
20510
20511 wxPyEndAllowThreads(__tstate);
20512 if (PyErr_Occurred()) SWIG_fail;
20513 }
20514 Py_INCREF(Py_None); resultobj = Py_None;
20515 return resultobj;
20516 fail:
20517 return NULL;
20518 }
20519
20520
20521 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20522 PyObject *resultobj;
20523 long result;
20524 char *kwnames[] = {
20525 NULL
20526 };
20527
20528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20529 {
20530 PyThreadState* __tstate = wxPyBeginAllowThreads();
20531 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20532
20533 wxPyEndAllowThreads(__tstate);
20534 if (PyErr_Occurred()) SWIG_fail;
20535 }
20536 {
20537 resultobj = SWIG_From_long((long)(result));
20538 }
20539 return resultobj;
20540 fail:
20541 return NULL;
20542 }
20543
20544
20545 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20546 PyObject *resultobj;
20547 wxWindow *arg1 = (wxWindow *) 0 ;
20548 bool result;
20549 PyObject * obj0 = 0 ;
20550 char *kwnames[] = {
20551 (char *) "win", NULL
20552 };
20553
20554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20556 if (SWIG_arg_fail(1)) SWIG_fail;
20557 {
20558 PyThreadState* __tstate = wxPyBeginAllowThreads();
20559 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20560
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 {
20565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20566 }
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20574 PyObject *resultobj;
20575 char *kwnames[] = {
20576 NULL
20577 };
20578
20579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20580 {
20581 PyThreadState* __tstate = wxPyBeginAllowThreads();
20582 wxUpdateUIEvent::ResetUpdateTime();
20583
20584 wxPyEndAllowThreads(__tstate);
20585 if (PyErr_Occurred()) SWIG_fail;
20586 }
20587 Py_INCREF(Py_None); resultobj = Py_None;
20588 return resultobj;
20589 fail:
20590 return NULL;
20591 }
20592
20593
20594 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20595 PyObject *resultobj;
20596 wxUpdateUIMode arg1 ;
20597 PyObject * obj0 = 0 ;
20598 char *kwnames[] = {
20599 (char *) "mode", NULL
20600 };
20601
20602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20603 {
20604 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20605 if (SWIG_arg_fail(1)) SWIG_fail;
20606 }
20607 {
20608 PyThreadState* __tstate = wxPyBeginAllowThreads();
20609 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20610
20611 wxPyEndAllowThreads(__tstate);
20612 if (PyErr_Occurred()) SWIG_fail;
20613 }
20614 Py_INCREF(Py_None); resultobj = Py_None;
20615 return resultobj;
20616 fail:
20617 return NULL;
20618 }
20619
20620
20621 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20622 PyObject *resultobj;
20623 wxUpdateUIMode result;
20624 char *kwnames[] = {
20625 NULL
20626 };
20627
20628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20632
20633 wxPyEndAllowThreads(__tstate);
20634 if (PyErr_Occurred()) SWIG_fail;
20635 }
20636 resultobj = SWIG_From_int((result));
20637 return resultobj;
20638 fail:
20639 return NULL;
20640 }
20641
20642
20643 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20644 PyObject *obj;
20645 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20646 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20647 Py_INCREF(obj);
20648 return Py_BuildValue((char *)"");
20649 }
20650 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20651 PyObject *resultobj;
20652 wxSysColourChangedEvent *result;
20653 char *kwnames[] = {
20654 NULL
20655 };
20656
20657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20658 {
20659 PyThreadState* __tstate = wxPyBeginAllowThreads();
20660 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20661
20662 wxPyEndAllowThreads(__tstate);
20663 if (PyErr_Occurred()) SWIG_fail;
20664 }
20665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20666 return resultobj;
20667 fail:
20668 return NULL;
20669 }
20670
20671
20672 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20673 PyObject *obj;
20674 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20675 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20676 Py_INCREF(obj);
20677 return Py_BuildValue((char *)"");
20678 }
20679 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20680 PyObject *resultobj;
20681 int arg1 = (int) 0 ;
20682 wxWindow *arg2 = (wxWindow *) NULL ;
20683 wxMouseCaptureChangedEvent *result;
20684 PyObject * obj0 = 0 ;
20685 PyObject * obj1 = 0 ;
20686 char *kwnames[] = {
20687 (char *) "winid",(char *) "gainedCapture", NULL
20688 };
20689
20690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20691 if (obj0) {
20692 {
20693 arg1 = (int)(SWIG_As_int(obj0));
20694 if (SWIG_arg_fail(1)) SWIG_fail;
20695 }
20696 }
20697 if (obj1) {
20698 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20699 if (SWIG_arg_fail(2)) SWIG_fail;
20700 }
20701 {
20702 PyThreadState* __tstate = wxPyBeginAllowThreads();
20703 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20704
20705 wxPyEndAllowThreads(__tstate);
20706 if (PyErr_Occurred()) SWIG_fail;
20707 }
20708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20709 return resultobj;
20710 fail:
20711 return NULL;
20712 }
20713
20714
20715 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20716 PyObject *resultobj;
20717 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20718 wxWindow *result;
20719 PyObject * obj0 = 0 ;
20720 char *kwnames[] = {
20721 (char *) "self", NULL
20722 };
20723
20724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20726 if (SWIG_arg_fail(1)) SWIG_fail;
20727 {
20728 PyThreadState* __tstate = wxPyBeginAllowThreads();
20729 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20730
20731 wxPyEndAllowThreads(__tstate);
20732 if (PyErr_Occurred()) SWIG_fail;
20733 }
20734 {
20735 resultobj = wxPyMake_wxObject(result, 0);
20736 }
20737 return resultobj;
20738 fail:
20739 return NULL;
20740 }
20741
20742
20743 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20744 PyObject *obj;
20745 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20746 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20747 Py_INCREF(obj);
20748 return Py_BuildValue((char *)"");
20749 }
20750 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20751 PyObject *resultobj;
20752 wxDisplayChangedEvent *result;
20753 char *kwnames[] = {
20754 NULL
20755 };
20756
20757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20758 {
20759 PyThreadState* __tstate = wxPyBeginAllowThreads();
20760 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20761
20762 wxPyEndAllowThreads(__tstate);
20763 if (PyErr_Occurred()) SWIG_fail;
20764 }
20765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20766 return resultobj;
20767 fail:
20768 return NULL;
20769 }
20770
20771
20772 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20773 PyObject *obj;
20774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20775 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20776 Py_INCREF(obj);
20777 return Py_BuildValue((char *)"");
20778 }
20779 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20780 PyObject *resultobj;
20781 int arg1 = (int) 0 ;
20782 wxPaletteChangedEvent *result;
20783 PyObject * obj0 = 0 ;
20784 char *kwnames[] = {
20785 (char *) "id", NULL
20786 };
20787
20788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20789 if (obj0) {
20790 {
20791 arg1 = (int)(SWIG_As_int(obj0));
20792 if (SWIG_arg_fail(1)) SWIG_fail;
20793 }
20794 }
20795 {
20796 PyThreadState* __tstate = wxPyBeginAllowThreads();
20797 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20798
20799 wxPyEndAllowThreads(__tstate);
20800 if (PyErr_Occurred()) SWIG_fail;
20801 }
20802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20803 return resultobj;
20804 fail:
20805 return NULL;
20806 }
20807
20808
20809 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20810 PyObject *resultobj;
20811 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20812 wxWindow *arg2 = (wxWindow *) 0 ;
20813 PyObject * obj0 = 0 ;
20814 PyObject * obj1 = 0 ;
20815 char *kwnames[] = {
20816 (char *) "self",(char *) "win", NULL
20817 };
20818
20819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20821 if (SWIG_arg_fail(1)) SWIG_fail;
20822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20823 if (SWIG_arg_fail(2)) SWIG_fail;
20824 {
20825 PyThreadState* __tstate = wxPyBeginAllowThreads();
20826 (arg1)->SetChangedWindow(arg2);
20827
20828 wxPyEndAllowThreads(__tstate);
20829 if (PyErr_Occurred()) SWIG_fail;
20830 }
20831 Py_INCREF(Py_None); resultobj = Py_None;
20832 return resultobj;
20833 fail:
20834 return NULL;
20835 }
20836
20837
20838 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20839 PyObject *resultobj;
20840 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20841 wxWindow *result;
20842 PyObject * obj0 = 0 ;
20843 char *kwnames[] = {
20844 (char *) "self", NULL
20845 };
20846
20847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20849 if (SWIG_arg_fail(1)) SWIG_fail;
20850 {
20851 PyThreadState* __tstate = wxPyBeginAllowThreads();
20852 result = (wxWindow *)(arg1)->GetChangedWindow();
20853
20854 wxPyEndAllowThreads(__tstate);
20855 if (PyErr_Occurred()) SWIG_fail;
20856 }
20857 {
20858 resultobj = wxPyMake_wxObject(result, 0);
20859 }
20860 return resultobj;
20861 fail:
20862 return NULL;
20863 }
20864
20865
20866 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20867 PyObject *obj;
20868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20869 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20870 Py_INCREF(obj);
20871 return Py_BuildValue((char *)"");
20872 }
20873 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20874 PyObject *resultobj;
20875 int arg1 = (int) 0 ;
20876 wxQueryNewPaletteEvent *result;
20877 PyObject * obj0 = 0 ;
20878 char *kwnames[] = {
20879 (char *) "winid", NULL
20880 };
20881
20882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20883 if (obj0) {
20884 {
20885 arg1 = (int)(SWIG_As_int(obj0));
20886 if (SWIG_arg_fail(1)) SWIG_fail;
20887 }
20888 }
20889 {
20890 PyThreadState* __tstate = wxPyBeginAllowThreads();
20891 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20892
20893 wxPyEndAllowThreads(__tstate);
20894 if (PyErr_Occurred()) SWIG_fail;
20895 }
20896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20897 return resultobj;
20898 fail:
20899 return NULL;
20900 }
20901
20902
20903 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20904 PyObject *resultobj;
20905 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20906 bool arg2 ;
20907 PyObject * obj0 = 0 ;
20908 PyObject * obj1 = 0 ;
20909 char *kwnames[] = {
20910 (char *) "self",(char *) "realized", NULL
20911 };
20912
20913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
20914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20915 if (SWIG_arg_fail(1)) SWIG_fail;
20916 {
20917 arg2 = (bool)(SWIG_As_bool(obj1));
20918 if (SWIG_arg_fail(2)) SWIG_fail;
20919 }
20920 {
20921 PyThreadState* __tstate = wxPyBeginAllowThreads();
20922 (arg1)->SetPaletteRealized(arg2);
20923
20924 wxPyEndAllowThreads(__tstate);
20925 if (PyErr_Occurred()) SWIG_fail;
20926 }
20927 Py_INCREF(Py_None); resultobj = Py_None;
20928 return resultobj;
20929 fail:
20930 return NULL;
20931 }
20932
20933
20934 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20935 PyObject *resultobj;
20936 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20937 bool result;
20938 PyObject * obj0 = 0 ;
20939 char *kwnames[] = {
20940 (char *) "self", NULL
20941 };
20942
20943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
20944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20945 if (SWIG_arg_fail(1)) SWIG_fail;
20946 {
20947 PyThreadState* __tstate = wxPyBeginAllowThreads();
20948 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
20949
20950 wxPyEndAllowThreads(__tstate);
20951 if (PyErr_Occurred()) SWIG_fail;
20952 }
20953 {
20954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20955 }
20956 return resultobj;
20957 fail:
20958 return NULL;
20959 }
20960
20961
20962 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
20963 PyObject *obj;
20964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20965 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
20966 Py_INCREF(obj);
20967 return Py_BuildValue((char *)"");
20968 }
20969 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20970 PyObject *resultobj;
20971 wxNavigationKeyEvent *result;
20972 char *kwnames[] = {
20973 NULL
20974 };
20975
20976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
20977 {
20978 PyThreadState* __tstate = wxPyBeginAllowThreads();
20979 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
20980
20981 wxPyEndAllowThreads(__tstate);
20982 if (PyErr_Occurred()) SWIG_fail;
20983 }
20984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
20985 return resultobj;
20986 fail:
20987 return NULL;
20988 }
20989
20990
20991 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
20992 PyObject *resultobj;
20993 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20994 bool result;
20995 PyObject * obj0 = 0 ;
20996 char *kwnames[] = {
20997 (char *) "self", NULL
20998 };
20999
21000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21002 if (SWIG_arg_fail(1)) SWIG_fail;
21003 {
21004 PyThreadState* __tstate = wxPyBeginAllowThreads();
21005 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21006
21007 wxPyEndAllowThreads(__tstate);
21008 if (PyErr_Occurred()) SWIG_fail;
21009 }
21010 {
21011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21012 }
21013 return resultobj;
21014 fail:
21015 return NULL;
21016 }
21017
21018
21019 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21020 PyObject *resultobj;
21021 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21022 bool arg2 ;
21023 PyObject * obj0 = 0 ;
21024 PyObject * obj1 = 0 ;
21025 char *kwnames[] = {
21026 (char *) "self",(char *) "forward", NULL
21027 };
21028
21029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21031 if (SWIG_arg_fail(1)) SWIG_fail;
21032 {
21033 arg2 = (bool)(SWIG_As_bool(obj1));
21034 if (SWIG_arg_fail(2)) SWIG_fail;
21035 }
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 (arg1)->SetDirection(arg2);
21039
21040 wxPyEndAllowThreads(__tstate);
21041 if (PyErr_Occurred()) SWIG_fail;
21042 }
21043 Py_INCREF(Py_None); resultobj = Py_None;
21044 return resultobj;
21045 fail:
21046 return NULL;
21047 }
21048
21049
21050 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21051 PyObject *resultobj;
21052 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21053 bool result;
21054 PyObject * obj0 = 0 ;
21055 char *kwnames[] = {
21056 (char *) "self", NULL
21057 };
21058
21059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21061 if (SWIG_arg_fail(1)) SWIG_fail;
21062 {
21063 PyThreadState* __tstate = wxPyBeginAllowThreads();
21064 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21065
21066 wxPyEndAllowThreads(__tstate);
21067 if (PyErr_Occurred()) SWIG_fail;
21068 }
21069 {
21070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21071 }
21072 return resultobj;
21073 fail:
21074 return NULL;
21075 }
21076
21077
21078 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21079 PyObject *resultobj;
21080 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21081 bool arg2 ;
21082 PyObject * obj0 = 0 ;
21083 PyObject * obj1 = 0 ;
21084 char *kwnames[] = {
21085 (char *) "self",(char *) "ischange", NULL
21086 };
21087
21088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21090 if (SWIG_arg_fail(1)) SWIG_fail;
21091 {
21092 arg2 = (bool)(SWIG_As_bool(obj1));
21093 if (SWIG_arg_fail(2)) SWIG_fail;
21094 }
21095 {
21096 PyThreadState* __tstate = wxPyBeginAllowThreads();
21097 (arg1)->SetWindowChange(arg2);
21098
21099 wxPyEndAllowThreads(__tstate);
21100 if (PyErr_Occurred()) SWIG_fail;
21101 }
21102 Py_INCREF(Py_None); resultobj = Py_None;
21103 return resultobj;
21104 fail:
21105 return NULL;
21106 }
21107
21108
21109 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21110 PyObject *resultobj;
21111 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21112 long arg2 ;
21113 PyObject * obj0 = 0 ;
21114 PyObject * obj1 = 0 ;
21115 char *kwnames[] = {
21116 (char *) "self",(char *) "flags", NULL
21117 };
21118
21119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21121 if (SWIG_arg_fail(1)) SWIG_fail;
21122 {
21123 arg2 = (long)(SWIG_As_long(obj1));
21124 if (SWIG_arg_fail(2)) SWIG_fail;
21125 }
21126 {
21127 PyThreadState* __tstate = wxPyBeginAllowThreads();
21128 (arg1)->SetFlags(arg2);
21129
21130 wxPyEndAllowThreads(__tstate);
21131 if (PyErr_Occurred()) SWIG_fail;
21132 }
21133 Py_INCREF(Py_None); resultobj = Py_None;
21134 return resultobj;
21135 fail:
21136 return NULL;
21137 }
21138
21139
21140 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21141 PyObject *resultobj;
21142 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21143 wxWindow *result;
21144 PyObject * obj0 = 0 ;
21145 char *kwnames[] = {
21146 (char *) "self", NULL
21147 };
21148
21149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21151 if (SWIG_arg_fail(1)) SWIG_fail;
21152 {
21153 PyThreadState* __tstate = wxPyBeginAllowThreads();
21154 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21155
21156 wxPyEndAllowThreads(__tstate);
21157 if (PyErr_Occurred()) SWIG_fail;
21158 }
21159 {
21160 resultobj = wxPyMake_wxObject(result, 0);
21161 }
21162 return resultobj;
21163 fail:
21164 return NULL;
21165 }
21166
21167
21168 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21169 PyObject *resultobj;
21170 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21171 wxWindow *arg2 = (wxWindow *) 0 ;
21172 PyObject * obj0 = 0 ;
21173 PyObject * obj1 = 0 ;
21174 char *kwnames[] = {
21175 (char *) "self",(char *) "win", NULL
21176 };
21177
21178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21180 if (SWIG_arg_fail(1)) SWIG_fail;
21181 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21182 if (SWIG_arg_fail(2)) SWIG_fail;
21183 {
21184 PyThreadState* __tstate = wxPyBeginAllowThreads();
21185 (arg1)->SetCurrentFocus(arg2);
21186
21187 wxPyEndAllowThreads(__tstate);
21188 if (PyErr_Occurred()) SWIG_fail;
21189 }
21190 Py_INCREF(Py_None); resultobj = Py_None;
21191 return resultobj;
21192 fail:
21193 return NULL;
21194 }
21195
21196
21197 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21198 PyObject *obj;
21199 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21200 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21201 Py_INCREF(obj);
21202 return Py_BuildValue((char *)"");
21203 }
21204 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21205 PyObject *resultobj;
21206 wxWindow *arg1 = (wxWindow *) NULL ;
21207 wxWindowCreateEvent *result;
21208 PyObject * obj0 = 0 ;
21209 char *kwnames[] = {
21210 (char *) "win", NULL
21211 };
21212
21213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21214 if (obj0) {
21215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21216 if (SWIG_arg_fail(1)) SWIG_fail;
21217 }
21218 {
21219 PyThreadState* __tstate = wxPyBeginAllowThreads();
21220 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21221
21222 wxPyEndAllowThreads(__tstate);
21223 if (PyErr_Occurred()) SWIG_fail;
21224 }
21225 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21226 return resultobj;
21227 fail:
21228 return NULL;
21229 }
21230
21231
21232 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21233 PyObject *resultobj;
21234 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21235 wxWindow *result;
21236 PyObject * obj0 = 0 ;
21237 char *kwnames[] = {
21238 (char *) "self", NULL
21239 };
21240
21241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21243 if (SWIG_arg_fail(1)) SWIG_fail;
21244 {
21245 PyThreadState* __tstate = wxPyBeginAllowThreads();
21246 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21247
21248 wxPyEndAllowThreads(__tstate);
21249 if (PyErr_Occurred()) SWIG_fail;
21250 }
21251 {
21252 resultobj = wxPyMake_wxObject(result, 0);
21253 }
21254 return resultobj;
21255 fail:
21256 return NULL;
21257 }
21258
21259
21260 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21261 PyObject *obj;
21262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21263 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21264 Py_INCREF(obj);
21265 return Py_BuildValue((char *)"");
21266 }
21267 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21268 PyObject *resultobj;
21269 wxWindow *arg1 = (wxWindow *) NULL ;
21270 wxWindowDestroyEvent *result;
21271 PyObject * obj0 = 0 ;
21272 char *kwnames[] = {
21273 (char *) "win", NULL
21274 };
21275
21276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21277 if (obj0) {
21278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21279 if (SWIG_arg_fail(1)) SWIG_fail;
21280 }
21281 {
21282 PyThreadState* __tstate = wxPyBeginAllowThreads();
21283 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21284
21285 wxPyEndAllowThreads(__tstate);
21286 if (PyErr_Occurred()) SWIG_fail;
21287 }
21288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21289 return resultobj;
21290 fail:
21291 return NULL;
21292 }
21293
21294
21295 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21296 PyObject *resultobj;
21297 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21298 wxWindow *result;
21299 PyObject * obj0 = 0 ;
21300 char *kwnames[] = {
21301 (char *) "self", NULL
21302 };
21303
21304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21306 if (SWIG_arg_fail(1)) SWIG_fail;
21307 {
21308 PyThreadState* __tstate = wxPyBeginAllowThreads();
21309 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21310
21311 wxPyEndAllowThreads(__tstate);
21312 if (PyErr_Occurred()) SWIG_fail;
21313 }
21314 {
21315 resultobj = wxPyMake_wxObject(result, 0);
21316 }
21317 return resultobj;
21318 fail:
21319 return NULL;
21320 }
21321
21322
21323 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21324 PyObject *obj;
21325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21326 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21327 Py_INCREF(obj);
21328 return Py_BuildValue((char *)"");
21329 }
21330 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21331 PyObject *resultobj;
21332 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21333 int arg2 = (int) 0 ;
21334 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21335 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21336 wxContextMenuEvent *result;
21337 wxPoint temp3 ;
21338 PyObject * obj0 = 0 ;
21339 PyObject * obj1 = 0 ;
21340 PyObject * obj2 = 0 ;
21341 char *kwnames[] = {
21342 (char *) "type",(char *) "winid",(char *) "pt", NULL
21343 };
21344
21345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21346 if (obj0) {
21347 {
21348 arg1 = (wxEventType)(SWIG_As_int(obj0));
21349 if (SWIG_arg_fail(1)) SWIG_fail;
21350 }
21351 }
21352 if (obj1) {
21353 {
21354 arg2 = (int)(SWIG_As_int(obj1));
21355 if (SWIG_arg_fail(2)) SWIG_fail;
21356 }
21357 }
21358 if (obj2) {
21359 {
21360 arg3 = &temp3;
21361 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21362 }
21363 }
21364 {
21365 PyThreadState* __tstate = wxPyBeginAllowThreads();
21366 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21367
21368 wxPyEndAllowThreads(__tstate);
21369 if (PyErr_Occurred()) SWIG_fail;
21370 }
21371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21372 return resultobj;
21373 fail:
21374 return NULL;
21375 }
21376
21377
21378 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21379 PyObject *resultobj;
21380 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21381 wxPoint *result;
21382 PyObject * obj0 = 0 ;
21383 char *kwnames[] = {
21384 (char *) "self", NULL
21385 };
21386
21387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21389 if (SWIG_arg_fail(1)) SWIG_fail;
21390 {
21391 PyThreadState* __tstate = wxPyBeginAllowThreads();
21392 {
21393 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21394 result = (wxPoint *) &_result_ref;
21395 }
21396
21397 wxPyEndAllowThreads(__tstate);
21398 if (PyErr_Occurred()) SWIG_fail;
21399 }
21400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21401 return resultobj;
21402 fail:
21403 return NULL;
21404 }
21405
21406
21407 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21408 PyObject *resultobj;
21409 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21410 wxPoint *arg2 = 0 ;
21411 wxPoint temp2 ;
21412 PyObject * obj0 = 0 ;
21413 PyObject * obj1 = 0 ;
21414 char *kwnames[] = {
21415 (char *) "self",(char *) "pos", NULL
21416 };
21417
21418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21420 if (SWIG_arg_fail(1)) SWIG_fail;
21421 {
21422 arg2 = &temp2;
21423 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21424 }
21425 {
21426 PyThreadState* __tstate = wxPyBeginAllowThreads();
21427 (arg1)->SetPosition((wxPoint const &)*arg2);
21428
21429 wxPyEndAllowThreads(__tstate);
21430 if (PyErr_Occurred()) SWIG_fail;
21431 }
21432 Py_INCREF(Py_None); resultobj = Py_None;
21433 return resultobj;
21434 fail:
21435 return NULL;
21436 }
21437
21438
21439 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21440 PyObject *obj;
21441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21442 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21443 Py_INCREF(obj);
21444 return Py_BuildValue((char *)"");
21445 }
21446 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21447 PyObject *resultobj;
21448 wxIdleEvent *result;
21449 char *kwnames[] = {
21450 NULL
21451 };
21452
21453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21454 {
21455 PyThreadState* __tstate = wxPyBeginAllowThreads();
21456 result = (wxIdleEvent *)new wxIdleEvent();
21457
21458 wxPyEndAllowThreads(__tstate);
21459 if (PyErr_Occurred()) SWIG_fail;
21460 }
21461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21462 return resultobj;
21463 fail:
21464 return NULL;
21465 }
21466
21467
21468 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21469 PyObject *resultobj;
21470 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21471 bool arg2 = (bool) true ;
21472 PyObject * obj0 = 0 ;
21473 PyObject * obj1 = 0 ;
21474 char *kwnames[] = {
21475 (char *) "self",(char *) "needMore", NULL
21476 };
21477
21478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21480 if (SWIG_arg_fail(1)) SWIG_fail;
21481 if (obj1) {
21482 {
21483 arg2 = (bool)(SWIG_As_bool(obj1));
21484 if (SWIG_arg_fail(2)) SWIG_fail;
21485 }
21486 }
21487 {
21488 PyThreadState* __tstate = wxPyBeginAllowThreads();
21489 (arg1)->RequestMore(arg2);
21490
21491 wxPyEndAllowThreads(__tstate);
21492 if (PyErr_Occurred()) SWIG_fail;
21493 }
21494 Py_INCREF(Py_None); resultobj = Py_None;
21495 return resultobj;
21496 fail:
21497 return NULL;
21498 }
21499
21500
21501 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21502 PyObject *resultobj;
21503 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21504 bool result;
21505 PyObject * obj0 = 0 ;
21506 char *kwnames[] = {
21507 (char *) "self", NULL
21508 };
21509
21510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21512 if (SWIG_arg_fail(1)) SWIG_fail;
21513 {
21514 PyThreadState* __tstate = wxPyBeginAllowThreads();
21515 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21516
21517 wxPyEndAllowThreads(__tstate);
21518 if (PyErr_Occurred()) SWIG_fail;
21519 }
21520 {
21521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21522 }
21523 return resultobj;
21524 fail:
21525 return NULL;
21526 }
21527
21528
21529 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21530 PyObject *resultobj;
21531 wxIdleMode arg1 ;
21532 PyObject * obj0 = 0 ;
21533 char *kwnames[] = {
21534 (char *) "mode", NULL
21535 };
21536
21537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21538 {
21539 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21540 if (SWIG_arg_fail(1)) SWIG_fail;
21541 }
21542 {
21543 PyThreadState* __tstate = wxPyBeginAllowThreads();
21544 wxIdleEvent::SetMode((wxIdleMode )arg1);
21545
21546 wxPyEndAllowThreads(__tstate);
21547 if (PyErr_Occurred()) SWIG_fail;
21548 }
21549 Py_INCREF(Py_None); resultobj = Py_None;
21550 return resultobj;
21551 fail:
21552 return NULL;
21553 }
21554
21555
21556 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21557 PyObject *resultobj;
21558 wxIdleMode result;
21559 char *kwnames[] = {
21560 NULL
21561 };
21562
21563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21564 {
21565 PyThreadState* __tstate = wxPyBeginAllowThreads();
21566 result = (wxIdleMode)wxIdleEvent::GetMode();
21567
21568 wxPyEndAllowThreads(__tstate);
21569 if (PyErr_Occurred()) SWIG_fail;
21570 }
21571 resultobj = SWIG_From_int((result));
21572 return resultobj;
21573 fail:
21574 return NULL;
21575 }
21576
21577
21578 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21579 PyObject *resultobj;
21580 wxWindow *arg1 = (wxWindow *) 0 ;
21581 bool result;
21582 PyObject * obj0 = 0 ;
21583 char *kwnames[] = {
21584 (char *) "win", NULL
21585 };
21586
21587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21589 if (SWIG_arg_fail(1)) SWIG_fail;
21590 {
21591 PyThreadState* __tstate = wxPyBeginAllowThreads();
21592 result = (bool)wxIdleEvent::CanSend(arg1);
21593
21594 wxPyEndAllowThreads(__tstate);
21595 if (PyErr_Occurred()) SWIG_fail;
21596 }
21597 {
21598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21599 }
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21607 PyObject *obj;
21608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21609 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21610 Py_INCREF(obj);
21611 return Py_BuildValue((char *)"");
21612 }
21613 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21614 PyObject *resultobj;
21615 int arg1 = (int) 0 ;
21616 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21617 wxPyEvent *result;
21618 PyObject * obj0 = 0 ;
21619 PyObject * obj1 = 0 ;
21620 char *kwnames[] = {
21621 (char *) "winid",(char *) "commandType", NULL
21622 };
21623
21624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21625 if (obj0) {
21626 {
21627 arg1 = (int)(SWIG_As_int(obj0));
21628 if (SWIG_arg_fail(1)) SWIG_fail;
21629 }
21630 }
21631 if (obj1) {
21632 {
21633 arg2 = (wxEventType)(SWIG_As_int(obj1));
21634 if (SWIG_arg_fail(2)) SWIG_fail;
21635 }
21636 }
21637 {
21638 PyThreadState* __tstate = wxPyBeginAllowThreads();
21639 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21640
21641 wxPyEndAllowThreads(__tstate);
21642 if (PyErr_Occurred()) SWIG_fail;
21643 }
21644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21645 return resultobj;
21646 fail:
21647 return NULL;
21648 }
21649
21650
21651 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21652 PyObject *resultobj;
21653 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21654 PyObject * obj0 = 0 ;
21655 char *kwnames[] = {
21656 (char *) "self", NULL
21657 };
21658
21659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21661 if (SWIG_arg_fail(1)) SWIG_fail;
21662 {
21663 PyThreadState* __tstate = wxPyBeginAllowThreads();
21664 delete arg1;
21665
21666 wxPyEndAllowThreads(__tstate);
21667 if (PyErr_Occurred()) SWIG_fail;
21668 }
21669 Py_INCREF(Py_None); resultobj = Py_None;
21670 return resultobj;
21671 fail:
21672 return NULL;
21673 }
21674
21675
21676 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21677 PyObject *resultobj;
21678 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21679 PyObject *arg2 = (PyObject *) 0 ;
21680 PyObject * obj0 = 0 ;
21681 PyObject * obj1 = 0 ;
21682 char *kwnames[] = {
21683 (char *) "self",(char *) "self", NULL
21684 };
21685
21686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21688 if (SWIG_arg_fail(1)) SWIG_fail;
21689 arg2 = obj1;
21690 {
21691 PyThreadState* __tstate = wxPyBeginAllowThreads();
21692 (arg1)->SetSelf(arg2);
21693
21694 wxPyEndAllowThreads(__tstate);
21695 if (PyErr_Occurred()) SWIG_fail;
21696 }
21697 Py_INCREF(Py_None); resultobj = Py_None;
21698 return resultobj;
21699 fail:
21700 return NULL;
21701 }
21702
21703
21704 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21705 PyObject *resultobj;
21706 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21707 PyObject *result;
21708 PyObject * obj0 = 0 ;
21709 char *kwnames[] = {
21710 (char *) "self", NULL
21711 };
21712
21713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21715 if (SWIG_arg_fail(1)) SWIG_fail;
21716 {
21717 PyThreadState* __tstate = wxPyBeginAllowThreads();
21718 result = (PyObject *)(arg1)->GetSelf();
21719
21720 wxPyEndAllowThreads(__tstate);
21721 if (PyErr_Occurred()) SWIG_fail;
21722 }
21723 resultobj = result;
21724 return resultobj;
21725 fail:
21726 return NULL;
21727 }
21728
21729
21730 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21731 PyObject *obj;
21732 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21733 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21734 Py_INCREF(obj);
21735 return Py_BuildValue((char *)"");
21736 }
21737 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21738 PyObject *resultobj;
21739 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21740 int arg2 = (int) 0 ;
21741 wxPyCommandEvent *result;
21742 PyObject * obj0 = 0 ;
21743 PyObject * obj1 = 0 ;
21744 char *kwnames[] = {
21745 (char *) "commandType",(char *) "id", NULL
21746 };
21747
21748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21749 if (obj0) {
21750 {
21751 arg1 = (wxEventType)(SWIG_As_int(obj0));
21752 if (SWIG_arg_fail(1)) SWIG_fail;
21753 }
21754 }
21755 if (obj1) {
21756 {
21757 arg2 = (int)(SWIG_As_int(obj1));
21758 if (SWIG_arg_fail(2)) SWIG_fail;
21759 }
21760 }
21761 {
21762 PyThreadState* __tstate = wxPyBeginAllowThreads();
21763 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21764
21765 wxPyEndAllowThreads(__tstate);
21766 if (PyErr_Occurred()) SWIG_fail;
21767 }
21768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21769 return resultobj;
21770 fail:
21771 return NULL;
21772 }
21773
21774
21775 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21776 PyObject *resultobj;
21777 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21778 PyObject * obj0 = 0 ;
21779 char *kwnames[] = {
21780 (char *) "self", NULL
21781 };
21782
21783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21785 if (SWIG_arg_fail(1)) SWIG_fail;
21786 {
21787 PyThreadState* __tstate = wxPyBeginAllowThreads();
21788 delete arg1;
21789
21790 wxPyEndAllowThreads(__tstate);
21791 if (PyErr_Occurred()) SWIG_fail;
21792 }
21793 Py_INCREF(Py_None); resultobj = Py_None;
21794 return resultobj;
21795 fail:
21796 return NULL;
21797 }
21798
21799
21800 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21801 PyObject *resultobj;
21802 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21803 PyObject *arg2 = (PyObject *) 0 ;
21804 PyObject * obj0 = 0 ;
21805 PyObject * obj1 = 0 ;
21806 char *kwnames[] = {
21807 (char *) "self",(char *) "self", NULL
21808 };
21809
21810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21812 if (SWIG_arg_fail(1)) SWIG_fail;
21813 arg2 = obj1;
21814 {
21815 PyThreadState* __tstate = wxPyBeginAllowThreads();
21816 (arg1)->SetSelf(arg2);
21817
21818 wxPyEndAllowThreads(__tstate);
21819 if (PyErr_Occurred()) SWIG_fail;
21820 }
21821 Py_INCREF(Py_None); resultobj = Py_None;
21822 return resultobj;
21823 fail:
21824 return NULL;
21825 }
21826
21827
21828 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21829 PyObject *resultobj;
21830 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21831 PyObject *result;
21832 PyObject * obj0 = 0 ;
21833 char *kwnames[] = {
21834 (char *) "self", NULL
21835 };
21836
21837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21839 if (SWIG_arg_fail(1)) SWIG_fail;
21840 {
21841 PyThreadState* __tstate = wxPyBeginAllowThreads();
21842 result = (PyObject *)(arg1)->GetSelf();
21843
21844 wxPyEndAllowThreads(__tstate);
21845 if (PyErr_Occurred()) SWIG_fail;
21846 }
21847 resultobj = result;
21848 return resultobj;
21849 fail:
21850 return NULL;
21851 }
21852
21853
21854 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
21855 PyObject *obj;
21856 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21857 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
21858 Py_INCREF(obj);
21859 return Py_BuildValue((char *)"");
21860 }
21861 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21862 PyObject *resultobj;
21863 wxPyApp *result;
21864 char *kwnames[] = {
21865 NULL
21866 };
21867
21868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
21869 {
21870 PyThreadState* __tstate = wxPyBeginAllowThreads();
21871 result = (wxPyApp *)new_wxPyApp();
21872
21873 wxPyEndAllowThreads(__tstate);
21874 if (PyErr_Occurred()) SWIG_fail;
21875 }
21876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
21877 return resultobj;
21878 fail:
21879 return NULL;
21880 }
21881
21882
21883 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21884 PyObject *resultobj;
21885 wxPyApp *arg1 = (wxPyApp *) 0 ;
21886 PyObject * obj0 = 0 ;
21887 char *kwnames[] = {
21888 (char *) "self", NULL
21889 };
21890
21891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
21892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21893 if (SWIG_arg_fail(1)) SWIG_fail;
21894 {
21895 PyThreadState* __tstate = wxPyBeginAllowThreads();
21896 delete arg1;
21897
21898 wxPyEndAllowThreads(__tstate);
21899 if (PyErr_Occurred()) SWIG_fail;
21900 }
21901 Py_INCREF(Py_None); resultobj = Py_None;
21902 return resultobj;
21903 fail:
21904 return NULL;
21905 }
21906
21907
21908 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
21909 PyObject *resultobj;
21910 wxPyApp *arg1 = (wxPyApp *) 0 ;
21911 PyObject *arg2 = (PyObject *) 0 ;
21912 PyObject *arg3 = (PyObject *) 0 ;
21913 PyObject * obj0 = 0 ;
21914 PyObject * obj1 = 0 ;
21915 PyObject * obj2 = 0 ;
21916 char *kwnames[] = {
21917 (char *) "self",(char *) "self",(char *) "_class", NULL
21918 };
21919
21920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21922 if (SWIG_arg_fail(1)) SWIG_fail;
21923 arg2 = obj1;
21924 arg3 = obj2;
21925 {
21926 PyThreadState* __tstate = wxPyBeginAllowThreads();
21927 (arg1)->_setCallbackInfo(arg2,arg3);
21928
21929 wxPyEndAllowThreads(__tstate);
21930 if (PyErr_Occurred()) SWIG_fail;
21931 }
21932 Py_INCREF(Py_None); resultobj = Py_None;
21933 return resultobj;
21934 fail:
21935 return NULL;
21936 }
21937
21938
21939 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21940 PyObject *resultobj;
21941 wxPyApp *arg1 = (wxPyApp *) 0 ;
21942 wxString result;
21943 PyObject * obj0 = 0 ;
21944 char *kwnames[] = {
21945 (char *) "self", NULL
21946 };
21947
21948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
21949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21950 if (SWIG_arg_fail(1)) SWIG_fail;
21951 {
21952 PyThreadState* __tstate = wxPyBeginAllowThreads();
21953 result = ((wxPyApp const *)arg1)->GetAppName();
21954
21955 wxPyEndAllowThreads(__tstate);
21956 if (PyErr_Occurred()) SWIG_fail;
21957 }
21958 {
21959 #if wxUSE_UNICODE
21960 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21961 #else
21962 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21963 #endif
21964 }
21965 return resultobj;
21966 fail:
21967 return NULL;
21968 }
21969
21970
21971 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21972 PyObject *resultobj;
21973 wxPyApp *arg1 = (wxPyApp *) 0 ;
21974 wxString *arg2 = 0 ;
21975 bool temp2 = false ;
21976 PyObject * obj0 = 0 ;
21977 PyObject * obj1 = 0 ;
21978 char *kwnames[] = {
21979 (char *) "self",(char *) "name", NULL
21980 };
21981
21982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
21983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21984 if (SWIG_arg_fail(1)) SWIG_fail;
21985 {
21986 arg2 = wxString_in_helper(obj1);
21987 if (arg2 == NULL) SWIG_fail;
21988 temp2 = true;
21989 }
21990 {
21991 PyThreadState* __tstate = wxPyBeginAllowThreads();
21992 (arg1)->SetAppName((wxString const &)*arg2);
21993
21994 wxPyEndAllowThreads(__tstate);
21995 if (PyErr_Occurred()) SWIG_fail;
21996 }
21997 Py_INCREF(Py_None); resultobj = Py_None;
21998 {
21999 if (temp2)
22000 delete arg2;
22001 }
22002 return resultobj;
22003 fail:
22004 {
22005 if (temp2)
22006 delete arg2;
22007 }
22008 return NULL;
22009 }
22010
22011
22012 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22013 PyObject *resultobj;
22014 wxPyApp *arg1 = (wxPyApp *) 0 ;
22015 wxString result;
22016 PyObject * obj0 = 0 ;
22017 char *kwnames[] = {
22018 (char *) "self", NULL
22019 };
22020
22021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22023 if (SWIG_arg_fail(1)) SWIG_fail;
22024 {
22025 PyThreadState* __tstate = wxPyBeginAllowThreads();
22026 result = ((wxPyApp const *)arg1)->GetClassName();
22027
22028 wxPyEndAllowThreads(__tstate);
22029 if (PyErr_Occurred()) SWIG_fail;
22030 }
22031 {
22032 #if wxUSE_UNICODE
22033 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22034 #else
22035 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22036 #endif
22037 }
22038 return resultobj;
22039 fail:
22040 return NULL;
22041 }
22042
22043
22044 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22045 PyObject *resultobj;
22046 wxPyApp *arg1 = (wxPyApp *) 0 ;
22047 wxString *arg2 = 0 ;
22048 bool temp2 = false ;
22049 PyObject * obj0 = 0 ;
22050 PyObject * obj1 = 0 ;
22051 char *kwnames[] = {
22052 (char *) "self",(char *) "name", NULL
22053 };
22054
22055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22057 if (SWIG_arg_fail(1)) SWIG_fail;
22058 {
22059 arg2 = wxString_in_helper(obj1);
22060 if (arg2 == NULL) SWIG_fail;
22061 temp2 = true;
22062 }
22063 {
22064 PyThreadState* __tstate = wxPyBeginAllowThreads();
22065 (arg1)->SetClassName((wxString const &)*arg2);
22066
22067 wxPyEndAllowThreads(__tstate);
22068 if (PyErr_Occurred()) SWIG_fail;
22069 }
22070 Py_INCREF(Py_None); resultobj = Py_None;
22071 {
22072 if (temp2)
22073 delete arg2;
22074 }
22075 return resultobj;
22076 fail:
22077 {
22078 if (temp2)
22079 delete arg2;
22080 }
22081 return NULL;
22082 }
22083
22084
22085 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22086 PyObject *resultobj;
22087 wxPyApp *arg1 = (wxPyApp *) 0 ;
22088 wxString *result;
22089 PyObject * obj0 = 0 ;
22090 char *kwnames[] = {
22091 (char *) "self", NULL
22092 };
22093
22094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22096 if (SWIG_arg_fail(1)) SWIG_fail;
22097 {
22098 PyThreadState* __tstate = wxPyBeginAllowThreads();
22099 {
22100 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22101 result = (wxString *) &_result_ref;
22102 }
22103
22104 wxPyEndAllowThreads(__tstate);
22105 if (PyErr_Occurred()) SWIG_fail;
22106 }
22107 {
22108 #if wxUSE_UNICODE
22109 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22110 #else
22111 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22112 #endif
22113 }
22114 return resultobj;
22115 fail:
22116 return NULL;
22117 }
22118
22119
22120 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22121 PyObject *resultobj;
22122 wxPyApp *arg1 = (wxPyApp *) 0 ;
22123 wxString *arg2 = 0 ;
22124 bool temp2 = false ;
22125 PyObject * obj0 = 0 ;
22126 PyObject * obj1 = 0 ;
22127 char *kwnames[] = {
22128 (char *) "self",(char *) "name", NULL
22129 };
22130
22131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22133 if (SWIG_arg_fail(1)) SWIG_fail;
22134 {
22135 arg2 = wxString_in_helper(obj1);
22136 if (arg2 == NULL) SWIG_fail;
22137 temp2 = true;
22138 }
22139 {
22140 PyThreadState* __tstate = wxPyBeginAllowThreads();
22141 (arg1)->SetVendorName((wxString const &)*arg2);
22142
22143 wxPyEndAllowThreads(__tstate);
22144 if (PyErr_Occurred()) SWIG_fail;
22145 }
22146 Py_INCREF(Py_None); resultobj = Py_None;
22147 {
22148 if (temp2)
22149 delete arg2;
22150 }
22151 return resultobj;
22152 fail:
22153 {
22154 if (temp2)
22155 delete arg2;
22156 }
22157 return NULL;
22158 }
22159
22160
22161 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22162 PyObject *resultobj;
22163 wxPyApp *arg1 = (wxPyApp *) 0 ;
22164 wxAppTraits *result;
22165 PyObject * obj0 = 0 ;
22166 char *kwnames[] = {
22167 (char *) "self", NULL
22168 };
22169
22170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22172 if (SWIG_arg_fail(1)) SWIG_fail;
22173 {
22174 PyThreadState* __tstate = wxPyBeginAllowThreads();
22175 result = (wxAppTraits *)(arg1)->GetTraits();
22176
22177 wxPyEndAllowThreads(__tstate);
22178 if (PyErr_Occurred()) SWIG_fail;
22179 }
22180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22181 return resultobj;
22182 fail:
22183 return NULL;
22184 }
22185
22186
22187 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22188 PyObject *resultobj;
22189 wxPyApp *arg1 = (wxPyApp *) 0 ;
22190 PyObject * obj0 = 0 ;
22191 char *kwnames[] = {
22192 (char *) "self", NULL
22193 };
22194
22195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22197 if (SWIG_arg_fail(1)) SWIG_fail;
22198 {
22199 PyThreadState* __tstate = wxPyBeginAllowThreads();
22200 (arg1)->ProcessPendingEvents();
22201
22202 wxPyEndAllowThreads(__tstate);
22203 if (PyErr_Occurred()) SWIG_fail;
22204 }
22205 Py_INCREF(Py_None); resultobj = Py_None;
22206 return resultobj;
22207 fail:
22208 return NULL;
22209 }
22210
22211
22212 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22213 PyObject *resultobj;
22214 wxPyApp *arg1 = (wxPyApp *) 0 ;
22215 bool arg2 = (bool) false ;
22216 bool result;
22217 PyObject * obj0 = 0 ;
22218 PyObject * obj1 = 0 ;
22219 char *kwnames[] = {
22220 (char *) "self",(char *) "onlyIfNeeded", NULL
22221 };
22222
22223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22225 if (SWIG_arg_fail(1)) SWIG_fail;
22226 if (obj1) {
22227 {
22228 arg2 = (bool)(SWIG_As_bool(obj1));
22229 if (SWIG_arg_fail(2)) SWIG_fail;
22230 }
22231 }
22232 {
22233 PyThreadState* __tstate = wxPyBeginAllowThreads();
22234 result = (bool)(arg1)->Yield(arg2);
22235
22236 wxPyEndAllowThreads(__tstate);
22237 if (PyErr_Occurred()) SWIG_fail;
22238 }
22239 {
22240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22241 }
22242 return resultobj;
22243 fail:
22244 return NULL;
22245 }
22246
22247
22248 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22249 PyObject *resultobj;
22250 wxPyApp *arg1 = (wxPyApp *) 0 ;
22251 PyObject * obj0 = 0 ;
22252 char *kwnames[] = {
22253 (char *) "self", NULL
22254 };
22255
22256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22258 if (SWIG_arg_fail(1)) SWIG_fail;
22259 {
22260 PyThreadState* __tstate = wxPyBeginAllowThreads();
22261 (arg1)->WakeUpIdle();
22262
22263 wxPyEndAllowThreads(__tstate);
22264 if (PyErr_Occurred()) SWIG_fail;
22265 }
22266 Py_INCREF(Py_None); resultobj = Py_None;
22267 return resultobj;
22268 fail:
22269 return NULL;
22270 }
22271
22272
22273 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22274 PyObject *resultobj;
22275 bool result;
22276 char *kwnames[] = {
22277 NULL
22278 };
22279
22280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22281 {
22282 PyThreadState* __tstate = wxPyBeginAllowThreads();
22283 result = (bool)wxPyApp::IsMainLoopRunning();
22284
22285 wxPyEndAllowThreads(__tstate);
22286 if (PyErr_Occurred()) SWIG_fail;
22287 }
22288 {
22289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22290 }
22291 return resultobj;
22292 fail:
22293 return NULL;
22294 }
22295
22296
22297 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22298 PyObject *resultobj;
22299 wxPyApp *arg1 = (wxPyApp *) 0 ;
22300 int result;
22301 PyObject * obj0 = 0 ;
22302 char *kwnames[] = {
22303 (char *) "self", NULL
22304 };
22305
22306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22308 if (SWIG_arg_fail(1)) SWIG_fail;
22309 {
22310 PyThreadState* __tstate = wxPyBeginAllowThreads();
22311 result = (int)(arg1)->MainLoop();
22312
22313 wxPyEndAllowThreads(__tstate);
22314 if (PyErr_Occurred()) SWIG_fail;
22315 }
22316 {
22317 resultobj = SWIG_From_int((int)(result));
22318 }
22319 return resultobj;
22320 fail:
22321 return NULL;
22322 }
22323
22324
22325 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22326 PyObject *resultobj;
22327 wxPyApp *arg1 = (wxPyApp *) 0 ;
22328 PyObject * obj0 = 0 ;
22329 char *kwnames[] = {
22330 (char *) "self", NULL
22331 };
22332
22333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22335 if (SWIG_arg_fail(1)) SWIG_fail;
22336 {
22337 PyThreadState* __tstate = wxPyBeginAllowThreads();
22338 (arg1)->Exit();
22339
22340 wxPyEndAllowThreads(__tstate);
22341 if (PyErr_Occurred()) SWIG_fail;
22342 }
22343 Py_INCREF(Py_None); resultobj = Py_None;
22344 return resultobj;
22345 fail:
22346 return NULL;
22347 }
22348
22349
22350 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22351 PyObject *resultobj;
22352 wxPyApp *arg1 = (wxPyApp *) 0 ;
22353 PyObject * obj0 = 0 ;
22354 char *kwnames[] = {
22355 (char *) "self", NULL
22356 };
22357
22358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22360 if (SWIG_arg_fail(1)) SWIG_fail;
22361 {
22362 PyThreadState* __tstate = wxPyBeginAllowThreads();
22363 (arg1)->ExitMainLoop();
22364
22365 wxPyEndAllowThreads(__tstate);
22366 if (PyErr_Occurred()) SWIG_fail;
22367 }
22368 Py_INCREF(Py_None); resultobj = Py_None;
22369 return resultobj;
22370 fail:
22371 return NULL;
22372 }
22373
22374
22375 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22376 PyObject *resultobj;
22377 wxPyApp *arg1 = (wxPyApp *) 0 ;
22378 bool result;
22379 PyObject * obj0 = 0 ;
22380 char *kwnames[] = {
22381 (char *) "self", NULL
22382 };
22383
22384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22386 if (SWIG_arg_fail(1)) SWIG_fail;
22387 {
22388 PyThreadState* __tstate = wxPyBeginAllowThreads();
22389 result = (bool)(arg1)->Pending();
22390
22391 wxPyEndAllowThreads(__tstate);
22392 if (PyErr_Occurred()) SWIG_fail;
22393 }
22394 {
22395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22396 }
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22404 PyObject *resultobj;
22405 wxPyApp *arg1 = (wxPyApp *) 0 ;
22406 bool result;
22407 PyObject * obj0 = 0 ;
22408 char *kwnames[] = {
22409 (char *) "self", NULL
22410 };
22411
22412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22414 if (SWIG_arg_fail(1)) SWIG_fail;
22415 {
22416 PyThreadState* __tstate = wxPyBeginAllowThreads();
22417 result = (bool)(arg1)->Dispatch();
22418
22419 wxPyEndAllowThreads(__tstate);
22420 if (PyErr_Occurred()) SWIG_fail;
22421 }
22422 {
22423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22424 }
22425 return resultobj;
22426 fail:
22427 return NULL;
22428 }
22429
22430
22431 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22432 PyObject *resultobj;
22433 wxPyApp *arg1 = (wxPyApp *) 0 ;
22434 bool result;
22435 PyObject * obj0 = 0 ;
22436 char *kwnames[] = {
22437 (char *) "self", NULL
22438 };
22439
22440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22442 if (SWIG_arg_fail(1)) SWIG_fail;
22443 {
22444 PyThreadState* __tstate = wxPyBeginAllowThreads();
22445 result = (bool)(arg1)->ProcessIdle();
22446
22447 wxPyEndAllowThreads(__tstate);
22448 if (PyErr_Occurred()) SWIG_fail;
22449 }
22450 {
22451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22452 }
22453 return resultobj;
22454 fail:
22455 return NULL;
22456 }
22457
22458
22459 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22460 PyObject *resultobj;
22461 wxPyApp *arg1 = (wxPyApp *) 0 ;
22462 wxWindow *arg2 = (wxWindow *) 0 ;
22463 wxIdleEvent *arg3 = 0 ;
22464 bool result;
22465 PyObject * obj0 = 0 ;
22466 PyObject * obj1 = 0 ;
22467 PyObject * obj2 = 0 ;
22468 char *kwnames[] = {
22469 (char *) "self",(char *) "win",(char *) "event", NULL
22470 };
22471
22472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22474 if (SWIG_arg_fail(1)) SWIG_fail;
22475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(2)) SWIG_fail;
22477 {
22478 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22479 if (SWIG_arg_fail(3)) SWIG_fail;
22480 if (arg3 == NULL) {
22481 SWIG_null_ref("wxIdleEvent");
22482 }
22483 if (SWIG_arg_fail(3)) SWIG_fail;
22484 }
22485 {
22486 PyThreadState* __tstate = wxPyBeginAllowThreads();
22487 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22488
22489 wxPyEndAllowThreads(__tstate);
22490 if (PyErr_Occurred()) SWIG_fail;
22491 }
22492 {
22493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22494 }
22495 return resultobj;
22496 fail:
22497 return NULL;
22498 }
22499
22500
22501 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22502 PyObject *resultobj;
22503 wxPyApp *arg1 = (wxPyApp *) 0 ;
22504 bool result;
22505 PyObject * obj0 = 0 ;
22506 char *kwnames[] = {
22507 (char *) "self", NULL
22508 };
22509
22510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22512 if (SWIG_arg_fail(1)) SWIG_fail;
22513 {
22514 PyThreadState* __tstate = wxPyBeginAllowThreads();
22515 result = (bool)((wxPyApp const *)arg1)->IsActive();
22516
22517 wxPyEndAllowThreads(__tstate);
22518 if (PyErr_Occurred()) SWIG_fail;
22519 }
22520 {
22521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22522 }
22523 return resultobj;
22524 fail:
22525 return NULL;
22526 }
22527
22528
22529 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22530 PyObject *resultobj;
22531 wxPyApp *arg1 = (wxPyApp *) 0 ;
22532 wxWindow *arg2 = (wxWindow *) 0 ;
22533 PyObject * obj0 = 0 ;
22534 PyObject * obj1 = 0 ;
22535 char *kwnames[] = {
22536 (char *) "self",(char *) "win", NULL
22537 };
22538
22539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22541 if (SWIG_arg_fail(1)) SWIG_fail;
22542 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22543 if (SWIG_arg_fail(2)) SWIG_fail;
22544 {
22545 PyThreadState* __tstate = wxPyBeginAllowThreads();
22546 (arg1)->SetTopWindow(arg2);
22547
22548 wxPyEndAllowThreads(__tstate);
22549 if (PyErr_Occurred()) SWIG_fail;
22550 }
22551 Py_INCREF(Py_None); resultobj = Py_None;
22552 return resultobj;
22553 fail:
22554 return NULL;
22555 }
22556
22557
22558 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22559 PyObject *resultobj;
22560 wxPyApp *arg1 = (wxPyApp *) 0 ;
22561 wxWindow *result;
22562 PyObject * obj0 = 0 ;
22563 char *kwnames[] = {
22564 (char *) "self", NULL
22565 };
22566
22567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22569 if (SWIG_arg_fail(1)) SWIG_fail;
22570 {
22571 PyThreadState* __tstate = wxPyBeginAllowThreads();
22572 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22573
22574 wxPyEndAllowThreads(__tstate);
22575 if (PyErr_Occurred()) SWIG_fail;
22576 }
22577 {
22578 resultobj = wxPyMake_wxObject(result, 0);
22579 }
22580 return resultobj;
22581 fail:
22582 return NULL;
22583 }
22584
22585
22586 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22587 PyObject *resultobj;
22588 wxPyApp *arg1 = (wxPyApp *) 0 ;
22589 bool arg2 ;
22590 PyObject * obj0 = 0 ;
22591 PyObject * obj1 = 0 ;
22592 char *kwnames[] = {
22593 (char *) "self",(char *) "flag", NULL
22594 };
22595
22596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22598 if (SWIG_arg_fail(1)) SWIG_fail;
22599 {
22600 arg2 = (bool)(SWIG_As_bool(obj1));
22601 if (SWIG_arg_fail(2)) SWIG_fail;
22602 }
22603 {
22604 PyThreadState* __tstate = wxPyBeginAllowThreads();
22605 (arg1)->SetExitOnFrameDelete(arg2);
22606
22607 wxPyEndAllowThreads(__tstate);
22608 if (PyErr_Occurred()) SWIG_fail;
22609 }
22610 Py_INCREF(Py_None); resultobj = Py_None;
22611 return resultobj;
22612 fail:
22613 return NULL;
22614 }
22615
22616
22617 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22618 PyObject *resultobj;
22619 wxPyApp *arg1 = (wxPyApp *) 0 ;
22620 bool result;
22621 PyObject * obj0 = 0 ;
22622 char *kwnames[] = {
22623 (char *) "self", NULL
22624 };
22625
22626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22628 if (SWIG_arg_fail(1)) SWIG_fail;
22629 {
22630 PyThreadState* __tstate = wxPyBeginAllowThreads();
22631 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22632
22633 wxPyEndAllowThreads(__tstate);
22634 if (PyErr_Occurred()) SWIG_fail;
22635 }
22636 {
22637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22638 }
22639 return resultobj;
22640 fail:
22641 return NULL;
22642 }
22643
22644
22645 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22646 PyObject *resultobj;
22647 wxPyApp *arg1 = (wxPyApp *) 0 ;
22648 bool arg2 ;
22649 PyObject * obj0 = 0 ;
22650 PyObject * obj1 = 0 ;
22651 char *kwnames[] = {
22652 (char *) "self",(char *) "flag", NULL
22653 };
22654
22655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22657 if (SWIG_arg_fail(1)) SWIG_fail;
22658 {
22659 arg2 = (bool)(SWIG_As_bool(obj1));
22660 if (SWIG_arg_fail(2)) SWIG_fail;
22661 }
22662 {
22663 PyThreadState* __tstate = wxPyBeginAllowThreads();
22664 (arg1)->SetUseBestVisual(arg2);
22665
22666 wxPyEndAllowThreads(__tstate);
22667 if (PyErr_Occurred()) SWIG_fail;
22668 }
22669 Py_INCREF(Py_None); resultobj = Py_None;
22670 return resultobj;
22671 fail:
22672 return NULL;
22673 }
22674
22675
22676 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22677 PyObject *resultobj;
22678 wxPyApp *arg1 = (wxPyApp *) 0 ;
22679 bool result;
22680 PyObject * obj0 = 0 ;
22681 char *kwnames[] = {
22682 (char *) "self", NULL
22683 };
22684
22685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22687 if (SWIG_arg_fail(1)) SWIG_fail;
22688 {
22689 PyThreadState* __tstate = wxPyBeginAllowThreads();
22690 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22691
22692 wxPyEndAllowThreads(__tstate);
22693 if (PyErr_Occurred()) SWIG_fail;
22694 }
22695 {
22696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22697 }
22698 return resultobj;
22699 fail:
22700 return NULL;
22701 }
22702
22703
22704 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22705 PyObject *resultobj;
22706 wxPyApp *arg1 = (wxPyApp *) 0 ;
22707 int arg2 ;
22708 PyObject * obj0 = 0 ;
22709 PyObject * obj1 = 0 ;
22710 char *kwnames[] = {
22711 (char *) "self",(char *) "mode", NULL
22712 };
22713
22714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22716 if (SWIG_arg_fail(1)) SWIG_fail;
22717 {
22718 arg2 = (int)(SWIG_As_int(obj1));
22719 if (SWIG_arg_fail(2)) SWIG_fail;
22720 }
22721 {
22722 PyThreadState* __tstate = wxPyBeginAllowThreads();
22723 (arg1)->SetPrintMode(arg2);
22724
22725 wxPyEndAllowThreads(__tstate);
22726 if (PyErr_Occurred()) SWIG_fail;
22727 }
22728 Py_INCREF(Py_None); resultobj = Py_None;
22729 return resultobj;
22730 fail:
22731 return NULL;
22732 }
22733
22734
22735 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22736 PyObject *resultobj;
22737 wxPyApp *arg1 = (wxPyApp *) 0 ;
22738 int result;
22739 PyObject * obj0 = 0 ;
22740 char *kwnames[] = {
22741 (char *) "self", NULL
22742 };
22743
22744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
22745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22746 if (SWIG_arg_fail(1)) SWIG_fail;
22747 {
22748 PyThreadState* __tstate = wxPyBeginAllowThreads();
22749 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
22750
22751 wxPyEndAllowThreads(__tstate);
22752 if (PyErr_Occurred()) SWIG_fail;
22753 }
22754 {
22755 resultobj = SWIG_From_int((int)(result));
22756 }
22757 return resultobj;
22758 fail:
22759 return NULL;
22760 }
22761
22762
22763 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22764 PyObject *resultobj;
22765 wxPyApp *arg1 = (wxPyApp *) 0 ;
22766 int arg2 ;
22767 PyObject * obj0 = 0 ;
22768 PyObject * obj1 = 0 ;
22769 char *kwnames[] = {
22770 (char *) "self",(char *) "mode", NULL
22771 };
22772
22773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
22774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22775 if (SWIG_arg_fail(1)) SWIG_fail;
22776 {
22777 arg2 = (int)(SWIG_As_int(obj1));
22778 if (SWIG_arg_fail(2)) SWIG_fail;
22779 }
22780 {
22781 PyThreadState* __tstate = wxPyBeginAllowThreads();
22782 (arg1)->SetAssertMode(arg2);
22783
22784 wxPyEndAllowThreads(__tstate);
22785 if (PyErr_Occurred()) SWIG_fail;
22786 }
22787 Py_INCREF(Py_None); resultobj = Py_None;
22788 return resultobj;
22789 fail:
22790 return NULL;
22791 }
22792
22793
22794 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22795 PyObject *resultobj;
22796 wxPyApp *arg1 = (wxPyApp *) 0 ;
22797 int result;
22798 PyObject * obj0 = 0 ;
22799 char *kwnames[] = {
22800 (char *) "self", NULL
22801 };
22802
22803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
22804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22805 if (SWIG_arg_fail(1)) SWIG_fail;
22806 {
22807 PyThreadState* __tstate = wxPyBeginAllowThreads();
22808 result = (int)(arg1)->GetAssertMode();
22809
22810 wxPyEndAllowThreads(__tstate);
22811 if (PyErr_Occurred()) SWIG_fail;
22812 }
22813 {
22814 resultobj = SWIG_From_int((int)(result));
22815 }
22816 return resultobj;
22817 fail:
22818 return NULL;
22819 }
22820
22821
22822 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22823 PyObject *resultobj;
22824 bool result;
22825 char *kwnames[] = {
22826 NULL
22827 };
22828
22829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
22830 {
22831 PyThreadState* __tstate = wxPyBeginAllowThreads();
22832 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
22833
22834 wxPyEndAllowThreads(__tstate);
22835 if (PyErr_Occurred()) SWIG_fail;
22836 }
22837 {
22838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22839 }
22840 return resultobj;
22841 fail:
22842 return NULL;
22843 }
22844
22845
22846 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22847 PyObject *resultobj;
22848 long result;
22849 char *kwnames[] = {
22850 NULL
22851 };
22852
22853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
22854 {
22855 PyThreadState* __tstate = wxPyBeginAllowThreads();
22856 result = (long)wxPyApp::GetMacAboutMenuItemId();
22857
22858 wxPyEndAllowThreads(__tstate);
22859 if (PyErr_Occurred()) SWIG_fail;
22860 }
22861 {
22862 resultobj = SWIG_From_long((long)(result));
22863 }
22864 return resultobj;
22865 fail:
22866 return NULL;
22867 }
22868
22869
22870 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22871 PyObject *resultobj;
22872 long result;
22873 char *kwnames[] = {
22874 NULL
22875 };
22876
22877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
22878 {
22879 PyThreadState* __tstate = wxPyBeginAllowThreads();
22880 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
22881
22882 wxPyEndAllowThreads(__tstate);
22883 if (PyErr_Occurred()) SWIG_fail;
22884 }
22885 {
22886 resultobj = SWIG_From_long((long)(result));
22887 }
22888 return resultobj;
22889 fail:
22890 return NULL;
22891 }
22892
22893
22894 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22895 PyObject *resultobj;
22896 long result;
22897 char *kwnames[] = {
22898 NULL
22899 };
22900
22901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
22902 {
22903 PyThreadState* __tstate = wxPyBeginAllowThreads();
22904 result = (long)wxPyApp::GetMacExitMenuItemId();
22905
22906 wxPyEndAllowThreads(__tstate);
22907 if (PyErr_Occurred()) SWIG_fail;
22908 }
22909 {
22910 resultobj = SWIG_From_long((long)(result));
22911 }
22912 return resultobj;
22913 fail:
22914 return NULL;
22915 }
22916
22917
22918 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
22919 PyObject *resultobj;
22920 wxString result;
22921 char *kwnames[] = {
22922 NULL
22923 };
22924
22925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
22926 {
22927 PyThreadState* __tstate = wxPyBeginAllowThreads();
22928 result = wxPyApp::GetMacHelpMenuTitleName();
22929
22930 wxPyEndAllowThreads(__tstate);
22931 if (PyErr_Occurred()) SWIG_fail;
22932 }
22933 {
22934 #if wxUSE_UNICODE
22935 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22936 #else
22937 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22938 #endif
22939 }
22940 return resultobj;
22941 fail:
22942 return NULL;
22943 }
22944
22945
22946 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22947 PyObject *resultobj;
22948 bool arg1 ;
22949 PyObject * obj0 = 0 ;
22950 char *kwnames[] = {
22951 (char *) "val", NULL
22952 };
22953
22954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
22955 {
22956 arg1 = (bool)(SWIG_As_bool(obj0));
22957 if (SWIG_arg_fail(1)) SWIG_fail;
22958 }
22959 {
22960 PyThreadState* __tstate = wxPyBeginAllowThreads();
22961 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
22962
22963 wxPyEndAllowThreads(__tstate);
22964 if (PyErr_Occurred()) SWIG_fail;
22965 }
22966 Py_INCREF(Py_None); resultobj = Py_None;
22967 return resultobj;
22968 fail:
22969 return NULL;
22970 }
22971
22972
22973 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22974 PyObject *resultobj;
22975 long arg1 ;
22976 PyObject * obj0 = 0 ;
22977 char *kwnames[] = {
22978 (char *) "val", NULL
22979 };
22980
22981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
22982 {
22983 arg1 = (long)(SWIG_As_long(obj0));
22984 if (SWIG_arg_fail(1)) SWIG_fail;
22985 }
22986 {
22987 PyThreadState* __tstate = wxPyBeginAllowThreads();
22988 wxPyApp::SetMacAboutMenuItemId(arg1);
22989
22990 wxPyEndAllowThreads(__tstate);
22991 if (PyErr_Occurred()) SWIG_fail;
22992 }
22993 Py_INCREF(Py_None); resultobj = Py_None;
22994 return resultobj;
22995 fail:
22996 return NULL;
22997 }
22998
22999
23000 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23001 PyObject *resultobj;
23002 long arg1 ;
23003 PyObject * obj0 = 0 ;
23004 char *kwnames[] = {
23005 (char *) "val", NULL
23006 };
23007
23008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23009 {
23010 arg1 = (long)(SWIG_As_long(obj0));
23011 if (SWIG_arg_fail(1)) SWIG_fail;
23012 }
23013 {
23014 PyThreadState* __tstate = wxPyBeginAllowThreads();
23015 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23016
23017 wxPyEndAllowThreads(__tstate);
23018 if (PyErr_Occurred()) SWIG_fail;
23019 }
23020 Py_INCREF(Py_None); resultobj = Py_None;
23021 return resultobj;
23022 fail:
23023 return NULL;
23024 }
23025
23026
23027 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23028 PyObject *resultobj;
23029 long arg1 ;
23030 PyObject * obj0 = 0 ;
23031 char *kwnames[] = {
23032 (char *) "val", NULL
23033 };
23034
23035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23036 {
23037 arg1 = (long)(SWIG_As_long(obj0));
23038 if (SWIG_arg_fail(1)) SWIG_fail;
23039 }
23040 {
23041 PyThreadState* __tstate = wxPyBeginAllowThreads();
23042 wxPyApp::SetMacExitMenuItemId(arg1);
23043
23044 wxPyEndAllowThreads(__tstate);
23045 if (PyErr_Occurred()) SWIG_fail;
23046 }
23047 Py_INCREF(Py_None); resultobj = Py_None;
23048 return resultobj;
23049 fail:
23050 return NULL;
23051 }
23052
23053
23054 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23055 PyObject *resultobj;
23056 wxString *arg1 = 0 ;
23057 bool temp1 = false ;
23058 PyObject * obj0 = 0 ;
23059 char *kwnames[] = {
23060 (char *) "val", NULL
23061 };
23062
23063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23064 {
23065 arg1 = wxString_in_helper(obj0);
23066 if (arg1 == NULL) SWIG_fail;
23067 temp1 = true;
23068 }
23069 {
23070 PyThreadState* __tstate = wxPyBeginAllowThreads();
23071 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23072
23073 wxPyEndAllowThreads(__tstate);
23074 if (PyErr_Occurred()) SWIG_fail;
23075 }
23076 Py_INCREF(Py_None); resultobj = Py_None;
23077 {
23078 if (temp1)
23079 delete arg1;
23080 }
23081 return resultobj;
23082 fail:
23083 {
23084 if (temp1)
23085 delete arg1;
23086 }
23087 return NULL;
23088 }
23089
23090
23091 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23092 PyObject *resultobj;
23093 wxPyApp *arg1 = (wxPyApp *) 0 ;
23094 PyObject * obj0 = 0 ;
23095 char *kwnames[] = {
23096 (char *) "self", NULL
23097 };
23098
23099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23101 if (SWIG_arg_fail(1)) SWIG_fail;
23102 {
23103 PyThreadState* __tstate = wxPyBeginAllowThreads();
23104 (arg1)->_BootstrapApp();
23105
23106 wxPyEndAllowThreads(__tstate);
23107 if (PyErr_Occurred()) SWIG_fail;
23108 }
23109 Py_INCREF(Py_None); resultobj = Py_None;
23110 return resultobj;
23111 fail:
23112 return NULL;
23113 }
23114
23115
23116 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23117 PyObject *resultobj;
23118 int result;
23119 char *kwnames[] = {
23120 NULL
23121 };
23122
23123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23124 {
23125 PyThreadState* __tstate = wxPyBeginAllowThreads();
23126 result = (int)wxPyApp::GetComCtl32Version();
23127
23128 wxPyEndAllowThreads(__tstate);
23129 if (PyErr_Occurred()) SWIG_fail;
23130 }
23131 {
23132 resultobj = SWIG_From_int((int)(result));
23133 }
23134 return resultobj;
23135 fail:
23136 return NULL;
23137 }
23138
23139
23140 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23141 PyObject *obj;
23142 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23143 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23144 Py_INCREF(obj);
23145 return Py_BuildValue((char *)"");
23146 }
23147 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23148 PyObject *resultobj;
23149 char *kwnames[] = {
23150 NULL
23151 };
23152
23153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23154 {
23155 PyThreadState* __tstate = wxPyBeginAllowThreads();
23156 wxExit();
23157
23158 wxPyEndAllowThreads(__tstate);
23159 if (PyErr_Occurred()) SWIG_fail;
23160 }
23161 Py_INCREF(Py_None); resultobj = Py_None;
23162 return resultobj;
23163 fail:
23164 return NULL;
23165 }
23166
23167
23168 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23169 PyObject *resultobj;
23170 bool result;
23171 char *kwnames[] = {
23172 NULL
23173 };
23174
23175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23176 {
23177 PyThreadState* __tstate = wxPyBeginAllowThreads();
23178 result = (bool)wxYield();
23179
23180 wxPyEndAllowThreads(__tstate);
23181 if (PyErr_Occurred()) SWIG_fail;
23182 }
23183 {
23184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23185 }
23186 return resultobj;
23187 fail:
23188 return NULL;
23189 }
23190
23191
23192 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23193 PyObject *resultobj;
23194 bool result;
23195 char *kwnames[] = {
23196 NULL
23197 };
23198
23199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 result = (bool)wxYieldIfNeeded();
23203
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 {
23208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23209 }
23210 return resultobj;
23211 fail:
23212 return NULL;
23213 }
23214
23215
23216 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23217 PyObject *resultobj;
23218 wxWindow *arg1 = (wxWindow *) NULL ;
23219 bool arg2 = (bool) false ;
23220 bool result;
23221 PyObject * obj0 = 0 ;
23222 PyObject * obj1 = 0 ;
23223 char *kwnames[] = {
23224 (char *) "win",(char *) "onlyIfNeeded", NULL
23225 };
23226
23227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23228 if (obj0) {
23229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23230 if (SWIG_arg_fail(1)) SWIG_fail;
23231 }
23232 if (obj1) {
23233 {
23234 arg2 = (bool)(SWIG_As_bool(obj1));
23235 if (SWIG_arg_fail(2)) SWIG_fail;
23236 }
23237 }
23238 {
23239 PyThreadState* __tstate = wxPyBeginAllowThreads();
23240 result = (bool)wxSafeYield(arg1,arg2);
23241
23242 wxPyEndAllowThreads(__tstate);
23243 if (PyErr_Occurred()) SWIG_fail;
23244 }
23245 {
23246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23247 }
23248 return resultobj;
23249 fail:
23250 return NULL;
23251 }
23252
23253
23254 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23255 PyObject *resultobj;
23256 char *kwnames[] = {
23257 NULL
23258 };
23259
23260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23261 {
23262 PyThreadState* __tstate = wxPyBeginAllowThreads();
23263 wxWakeUpIdle();
23264
23265 wxPyEndAllowThreads(__tstate);
23266 if (PyErr_Occurred()) SWIG_fail;
23267 }
23268 Py_INCREF(Py_None); resultobj = Py_None;
23269 return resultobj;
23270 fail:
23271 return NULL;
23272 }
23273
23274
23275 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23276 PyObject *resultobj;
23277 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23278 wxEvent *arg2 = 0 ;
23279 PyObject * obj0 = 0 ;
23280 PyObject * obj1 = 0 ;
23281 char *kwnames[] = {
23282 (char *) "dest",(char *) "event", NULL
23283 };
23284
23285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23287 if (SWIG_arg_fail(1)) SWIG_fail;
23288 {
23289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23290 if (SWIG_arg_fail(2)) SWIG_fail;
23291 if (arg2 == NULL) {
23292 SWIG_null_ref("wxEvent");
23293 }
23294 if (SWIG_arg_fail(2)) SWIG_fail;
23295 }
23296 {
23297 PyThreadState* __tstate = wxPyBeginAllowThreads();
23298 wxPostEvent(arg1,*arg2);
23299
23300 wxPyEndAllowThreads(__tstate);
23301 if (PyErr_Occurred()) SWIG_fail;
23302 }
23303 Py_INCREF(Py_None); resultobj = Py_None;
23304 return resultobj;
23305 fail:
23306 return NULL;
23307 }
23308
23309
23310 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23311 PyObject *resultobj;
23312 char *kwnames[] = {
23313 NULL
23314 };
23315
23316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23317 {
23318 PyThreadState* __tstate = wxPyBeginAllowThreads();
23319 wxApp_CleanUp();
23320
23321 wxPyEndAllowThreads(__tstate);
23322 if (PyErr_Occurred()) SWIG_fail;
23323 }
23324 Py_INCREF(Py_None); resultobj = Py_None;
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23332 PyObject *resultobj;
23333 wxPyApp *result;
23334 char *kwnames[] = {
23335 NULL
23336 };
23337
23338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23339 {
23340 PyThreadState* __tstate = wxPyBeginAllowThreads();
23341 result = (wxPyApp *)wxPyGetApp();
23342
23343 wxPyEndAllowThreads(__tstate);
23344 if (PyErr_Occurred()) SWIG_fail;
23345 }
23346 {
23347 resultobj = wxPyMake_wxObject(result, 0);
23348 }
23349 return resultobj;
23350 fail:
23351 return NULL;
23352 }
23353
23354
23355 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23356 PyObject *resultobj;
23357 char *arg1 = (char *) 0 ;
23358 PyObject * obj0 = 0 ;
23359 char *kwnames[] = {
23360 (char *) "encoding", NULL
23361 };
23362
23363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23364 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23365 SWIG_arg_fail(1);SWIG_fail;
23366 }
23367 {
23368 PyThreadState* __tstate = wxPyBeginAllowThreads();
23369 wxSetDefaultPyEncoding((char const *)arg1);
23370
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 Py_INCREF(Py_None); resultobj = Py_None;
23375 return resultobj;
23376 fail:
23377 return NULL;
23378 }
23379
23380
23381 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23382 PyObject *resultobj;
23383 char *result;
23384 char *kwnames[] = {
23385 NULL
23386 };
23387
23388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23389 {
23390 PyThreadState* __tstate = wxPyBeginAllowThreads();
23391 result = (char *)wxGetDefaultPyEncoding();
23392
23393 wxPyEndAllowThreads(__tstate);
23394 if (PyErr_Occurred()) SWIG_fail;
23395 }
23396 resultobj = SWIG_FromCharPtr(result);
23397 return resultobj;
23398 fail:
23399 return NULL;
23400 }
23401
23402
23403 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23404 PyObject *resultobj;
23405 wxEventLoop *result;
23406 char *kwnames[] = {
23407 NULL
23408 };
23409
23410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23411 {
23412 PyThreadState* __tstate = wxPyBeginAllowThreads();
23413 result = (wxEventLoop *)new wxEventLoop();
23414
23415 wxPyEndAllowThreads(__tstate);
23416 if (PyErr_Occurred()) SWIG_fail;
23417 }
23418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23419 return resultobj;
23420 fail:
23421 return NULL;
23422 }
23423
23424
23425 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23426 PyObject *resultobj;
23427 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23428 PyObject * obj0 = 0 ;
23429 char *kwnames[] = {
23430 (char *) "self", NULL
23431 };
23432
23433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23435 if (SWIG_arg_fail(1)) SWIG_fail;
23436 {
23437 PyThreadState* __tstate = wxPyBeginAllowThreads();
23438 delete arg1;
23439
23440 wxPyEndAllowThreads(__tstate);
23441 if (PyErr_Occurred()) SWIG_fail;
23442 }
23443 Py_INCREF(Py_None); resultobj = Py_None;
23444 return resultobj;
23445 fail:
23446 return NULL;
23447 }
23448
23449
23450 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23451 PyObject *resultobj;
23452 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23453 int result;
23454 PyObject * obj0 = 0 ;
23455 char *kwnames[] = {
23456 (char *) "self", NULL
23457 };
23458
23459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23461 if (SWIG_arg_fail(1)) SWIG_fail;
23462 {
23463 PyThreadState* __tstate = wxPyBeginAllowThreads();
23464 result = (int)(arg1)->Run();
23465
23466 wxPyEndAllowThreads(__tstate);
23467 if (PyErr_Occurred()) SWIG_fail;
23468 }
23469 {
23470 resultobj = SWIG_From_int((int)(result));
23471 }
23472 return resultobj;
23473 fail:
23474 return NULL;
23475 }
23476
23477
23478 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23479 PyObject *resultobj;
23480 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23481 int arg2 = (int) 0 ;
23482 PyObject * obj0 = 0 ;
23483 PyObject * obj1 = 0 ;
23484 char *kwnames[] = {
23485 (char *) "self",(char *) "rc", NULL
23486 };
23487
23488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23490 if (SWIG_arg_fail(1)) SWIG_fail;
23491 if (obj1) {
23492 {
23493 arg2 = (int)(SWIG_As_int(obj1));
23494 if (SWIG_arg_fail(2)) SWIG_fail;
23495 }
23496 }
23497 {
23498 PyThreadState* __tstate = wxPyBeginAllowThreads();
23499 (arg1)->Exit(arg2);
23500
23501 wxPyEndAllowThreads(__tstate);
23502 if (PyErr_Occurred()) SWIG_fail;
23503 }
23504 Py_INCREF(Py_None); resultobj = Py_None;
23505 return resultobj;
23506 fail:
23507 return NULL;
23508 }
23509
23510
23511 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23512 PyObject *resultobj;
23513 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23514 bool result;
23515 PyObject * obj0 = 0 ;
23516 char *kwnames[] = {
23517 (char *) "self", NULL
23518 };
23519
23520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23522 if (SWIG_arg_fail(1)) SWIG_fail;
23523 {
23524 PyThreadState* __tstate = wxPyBeginAllowThreads();
23525 result = (bool)((wxEventLoop const *)arg1)->Pending();
23526
23527 wxPyEndAllowThreads(__tstate);
23528 if (PyErr_Occurred()) SWIG_fail;
23529 }
23530 {
23531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23532 }
23533 return resultobj;
23534 fail:
23535 return NULL;
23536 }
23537
23538
23539 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23540 PyObject *resultobj;
23541 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23542 bool result;
23543 PyObject * obj0 = 0 ;
23544 char *kwnames[] = {
23545 (char *) "self", NULL
23546 };
23547
23548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23550 if (SWIG_arg_fail(1)) SWIG_fail;
23551 {
23552 PyThreadState* __tstate = wxPyBeginAllowThreads();
23553 result = (bool)(arg1)->Dispatch();
23554
23555 wxPyEndAllowThreads(__tstate);
23556 if (PyErr_Occurred()) SWIG_fail;
23557 }
23558 {
23559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23560 }
23561 return resultobj;
23562 fail:
23563 return NULL;
23564 }
23565
23566
23567 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23568 PyObject *resultobj;
23569 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23570 bool result;
23571 PyObject * obj0 = 0 ;
23572 char *kwnames[] = {
23573 (char *) "self", NULL
23574 };
23575
23576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23578 if (SWIG_arg_fail(1)) SWIG_fail;
23579 {
23580 PyThreadState* __tstate = wxPyBeginAllowThreads();
23581 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23582
23583 wxPyEndAllowThreads(__tstate);
23584 if (PyErr_Occurred()) SWIG_fail;
23585 }
23586 {
23587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23588 }
23589 return resultobj;
23590 fail:
23591 return NULL;
23592 }
23593
23594
23595 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23596 PyObject *resultobj;
23597 wxEventLoop *result;
23598 char *kwnames[] = {
23599 NULL
23600 };
23601
23602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23603 {
23604 PyThreadState* __tstate = wxPyBeginAllowThreads();
23605 result = (wxEventLoop *)wxEventLoop::GetActive();
23606
23607 wxPyEndAllowThreads(__tstate);
23608 if (PyErr_Occurred()) SWIG_fail;
23609 }
23610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23618 PyObject *resultobj;
23619 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23620 PyObject * obj0 = 0 ;
23621 char *kwnames[] = {
23622 (char *) "loop", NULL
23623 };
23624
23625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23627 if (SWIG_arg_fail(1)) SWIG_fail;
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 wxEventLoop::SetActive(arg1);
23631
23632 wxPyEndAllowThreads(__tstate);
23633 if (PyErr_Occurred()) SWIG_fail;
23634 }
23635 Py_INCREF(Py_None); resultobj = Py_None;
23636 return resultobj;
23637 fail:
23638 return NULL;
23639 }
23640
23641
23642 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23643 PyObject *obj;
23644 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23645 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23646 Py_INCREF(obj);
23647 return Py_BuildValue((char *)"");
23648 }
23649 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23650 PyObject *resultobj;
23651 int arg1 = (int) 0 ;
23652 int arg2 = (int) 0 ;
23653 int arg3 = (int) 0 ;
23654 wxAcceleratorEntry *result;
23655 PyObject * obj0 = 0 ;
23656 PyObject * obj1 = 0 ;
23657 PyObject * obj2 = 0 ;
23658 char *kwnames[] = {
23659 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23660 };
23661
23662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23663 if (obj0) {
23664 {
23665 arg1 = (int)(SWIG_As_int(obj0));
23666 if (SWIG_arg_fail(1)) SWIG_fail;
23667 }
23668 }
23669 if (obj1) {
23670 {
23671 arg2 = (int)(SWIG_As_int(obj1));
23672 if (SWIG_arg_fail(2)) SWIG_fail;
23673 }
23674 }
23675 if (obj2) {
23676 {
23677 arg3 = (int)(SWIG_As_int(obj2));
23678 if (SWIG_arg_fail(3)) SWIG_fail;
23679 }
23680 }
23681 {
23682 PyThreadState* __tstate = wxPyBeginAllowThreads();
23683 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23684
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23689 return resultobj;
23690 fail:
23691 return NULL;
23692 }
23693
23694
23695 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23696 PyObject *resultobj;
23697 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23698 PyObject * obj0 = 0 ;
23699 char *kwnames[] = {
23700 (char *) "self", NULL
23701 };
23702
23703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23705 if (SWIG_arg_fail(1)) SWIG_fail;
23706 {
23707 PyThreadState* __tstate = wxPyBeginAllowThreads();
23708 delete arg1;
23709
23710 wxPyEndAllowThreads(__tstate);
23711 if (PyErr_Occurred()) SWIG_fail;
23712 }
23713 Py_INCREF(Py_None); resultobj = Py_None;
23714 return resultobj;
23715 fail:
23716 return NULL;
23717 }
23718
23719
23720 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23721 PyObject *resultobj;
23722 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23723 int arg2 ;
23724 int arg3 ;
23725 int arg4 ;
23726 PyObject * obj0 = 0 ;
23727 PyObject * obj1 = 0 ;
23728 PyObject * obj2 = 0 ;
23729 PyObject * obj3 = 0 ;
23730 char *kwnames[] = {
23731 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23732 };
23733
23734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23736 if (SWIG_arg_fail(1)) SWIG_fail;
23737 {
23738 arg2 = (int)(SWIG_As_int(obj1));
23739 if (SWIG_arg_fail(2)) SWIG_fail;
23740 }
23741 {
23742 arg3 = (int)(SWIG_As_int(obj2));
23743 if (SWIG_arg_fail(3)) SWIG_fail;
23744 }
23745 {
23746 arg4 = (int)(SWIG_As_int(obj3));
23747 if (SWIG_arg_fail(4)) SWIG_fail;
23748 }
23749 {
23750 PyThreadState* __tstate = wxPyBeginAllowThreads();
23751 (arg1)->Set(arg2,arg3,arg4);
23752
23753 wxPyEndAllowThreads(__tstate);
23754 if (PyErr_Occurred()) SWIG_fail;
23755 }
23756 Py_INCREF(Py_None); resultobj = Py_None;
23757 return resultobj;
23758 fail:
23759 return NULL;
23760 }
23761
23762
23763 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
23764 PyObject *resultobj;
23765 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23766 int result;
23767 PyObject * obj0 = 0 ;
23768 char *kwnames[] = {
23769 (char *) "self", NULL
23770 };
23771
23772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
23773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23774 if (SWIG_arg_fail(1)) SWIG_fail;
23775 {
23776 PyThreadState* __tstate = wxPyBeginAllowThreads();
23777 result = (int)(arg1)->GetFlags();
23778
23779 wxPyEndAllowThreads(__tstate);
23780 if (PyErr_Occurred()) SWIG_fail;
23781 }
23782 {
23783 resultobj = SWIG_From_int((int)(result));
23784 }
23785 return resultobj;
23786 fail:
23787 return NULL;
23788 }
23789
23790
23791 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
23792 PyObject *resultobj;
23793 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23794 int result;
23795 PyObject * obj0 = 0 ;
23796 char *kwnames[] = {
23797 (char *) "self", NULL
23798 };
23799
23800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
23801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23802 if (SWIG_arg_fail(1)) SWIG_fail;
23803 {
23804 PyThreadState* __tstate = wxPyBeginAllowThreads();
23805 result = (int)(arg1)->GetKeyCode();
23806
23807 wxPyEndAllowThreads(__tstate);
23808 if (PyErr_Occurred()) SWIG_fail;
23809 }
23810 {
23811 resultobj = SWIG_From_int((int)(result));
23812 }
23813 return resultobj;
23814 fail:
23815 return NULL;
23816 }
23817
23818
23819 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
23820 PyObject *resultobj;
23821 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23822 int result;
23823 PyObject * obj0 = 0 ;
23824 char *kwnames[] = {
23825 (char *) "self", NULL
23826 };
23827
23828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
23829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23830 if (SWIG_arg_fail(1)) SWIG_fail;
23831 {
23832 PyThreadState* __tstate = wxPyBeginAllowThreads();
23833 result = (int)(arg1)->GetCommand();
23834
23835 wxPyEndAllowThreads(__tstate);
23836 if (PyErr_Occurred()) SWIG_fail;
23837 }
23838 {
23839 resultobj = SWIG_From_int((int)(result));
23840 }
23841 return resultobj;
23842 fail:
23843 return NULL;
23844 }
23845
23846
23847 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
23848 PyObject *obj;
23849 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23850 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
23851 Py_INCREF(obj);
23852 return Py_BuildValue((char *)"");
23853 }
23854 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23855 PyObject *resultobj;
23856 int arg1 ;
23857 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
23858 wxAcceleratorTable *result;
23859 PyObject * obj0 = 0 ;
23860 char *kwnames[] = {
23861 (char *) "n", NULL
23862 };
23863
23864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
23865 {
23866 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
23867 if (arg2) arg1 = PyList_Size(obj0);
23868 else arg1 = 0;
23869 }
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
23873
23874 wxPyEndAllowThreads(__tstate);
23875 if (PyErr_Occurred()) SWIG_fail;
23876 }
23877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
23878 {
23879 delete [] arg2;
23880 }
23881 return resultobj;
23882 fail:
23883 {
23884 delete [] arg2;
23885 }
23886 return NULL;
23887 }
23888
23889
23890 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23891 PyObject *resultobj;
23892 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23893 PyObject * obj0 = 0 ;
23894 char *kwnames[] = {
23895 (char *) "self", NULL
23896 };
23897
23898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
23899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23900 if (SWIG_arg_fail(1)) SWIG_fail;
23901 {
23902 PyThreadState* __tstate = wxPyBeginAllowThreads();
23903 delete arg1;
23904
23905 wxPyEndAllowThreads(__tstate);
23906 if (PyErr_Occurred()) SWIG_fail;
23907 }
23908 Py_INCREF(Py_None); resultobj = Py_None;
23909 return resultobj;
23910 fail:
23911 return NULL;
23912 }
23913
23914
23915 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
23916 PyObject *resultobj;
23917 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23918 bool result;
23919 PyObject * obj0 = 0 ;
23920 char *kwnames[] = {
23921 (char *) "self", NULL
23922 };
23923
23924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
23925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23926 if (SWIG_arg_fail(1)) SWIG_fail;
23927 {
23928 PyThreadState* __tstate = wxPyBeginAllowThreads();
23929 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
23930
23931 wxPyEndAllowThreads(__tstate);
23932 if (PyErr_Occurred()) SWIG_fail;
23933 }
23934 {
23935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23936 }
23937 return resultobj;
23938 fail:
23939 return NULL;
23940 }
23941
23942
23943 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
23944 PyObject *obj;
23945 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23946 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
23947 Py_INCREF(obj);
23948 return Py_BuildValue((char *)"");
23949 }
23950 static int _wrap_NullAcceleratorTable_set(PyObject *) {
23951 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
23952 return 1;
23953 }
23954
23955
23956 static PyObject *_wrap_NullAcceleratorTable_get(void) {
23957 PyObject *pyobj;
23958
23959 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
23960 return pyobj;
23961 }
23962
23963
23964 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
23965 PyObject *resultobj;
23966 wxString *arg1 = 0 ;
23967 wxAcceleratorEntry *result;
23968 bool temp1 = false ;
23969 PyObject * obj0 = 0 ;
23970 char *kwnames[] = {
23971 (char *) "label", NULL
23972 };
23973
23974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
23975 {
23976 arg1 = wxString_in_helper(obj0);
23977 if (arg1 == NULL) SWIG_fail;
23978 temp1 = true;
23979 }
23980 {
23981 PyThreadState* __tstate = wxPyBeginAllowThreads();
23982 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
23983
23984 wxPyEndAllowThreads(__tstate);
23985 if (PyErr_Occurred()) SWIG_fail;
23986 }
23987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
23988 {
23989 if (temp1)
23990 delete arg1;
23991 }
23992 return resultobj;
23993 fail:
23994 {
23995 if (temp1)
23996 delete arg1;
23997 }
23998 return NULL;
23999 }
24000
24001
24002 static int _wrap_PanelNameStr_set(PyObject *) {
24003 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24004 return 1;
24005 }
24006
24007
24008 static PyObject *_wrap_PanelNameStr_get(void) {
24009 PyObject *pyobj;
24010
24011 {
24012 #if wxUSE_UNICODE
24013 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24014 #else
24015 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24016 #endif
24017 }
24018 return pyobj;
24019 }
24020
24021
24022 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24023 PyObject *resultobj;
24024 wxVisualAttributes *result;
24025 char *kwnames[] = {
24026 NULL
24027 };
24028
24029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24030 {
24031 PyThreadState* __tstate = wxPyBeginAllowThreads();
24032 result = (wxVisualAttributes *)new_wxVisualAttributes();
24033
24034 wxPyEndAllowThreads(__tstate);
24035 if (PyErr_Occurred()) SWIG_fail;
24036 }
24037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24038 return resultobj;
24039 fail:
24040 return NULL;
24041 }
24042
24043
24044 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24045 PyObject *resultobj;
24046 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24047 PyObject * obj0 = 0 ;
24048 char *kwnames[] = {
24049 (char *) "self", NULL
24050 };
24051
24052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24054 if (SWIG_arg_fail(1)) SWIG_fail;
24055 {
24056 PyThreadState* __tstate = wxPyBeginAllowThreads();
24057 delete_wxVisualAttributes(arg1);
24058
24059 wxPyEndAllowThreads(__tstate);
24060 if (PyErr_Occurred()) SWIG_fail;
24061 }
24062 Py_INCREF(Py_None); resultobj = Py_None;
24063 return resultobj;
24064 fail:
24065 return NULL;
24066 }
24067
24068
24069 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24070 PyObject *resultobj;
24071 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24072 wxFont *arg2 = (wxFont *) 0 ;
24073 PyObject * obj0 = 0 ;
24074 PyObject * obj1 = 0 ;
24075 char *kwnames[] = {
24076 (char *) "self",(char *) "font", NULL
24077 };
24078
24079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24081 if (SWIG_arg_fail(1)) SWIG_fail;
24082 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24083 if (SWIG_arg_fail(2)) SWIG_fail;
24084 if (arg1) (arg1)->font = *arg2;
24085
24086 Py_INCREF(Py_None); resultobj = Py_None;
24087 return resultobj;
24088 fail:
24089 return NULL;
24090 }
24091
24092
24093 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24094 PyObject *resultobj;
24095 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24096 wxFont *result;
24097 PyObject * obj0 = 0 ;
24098 char *kwnames[] = {
24099 (char *) "self", NULL
24100 };
24101
24102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24104 if (SWIG_arg_fail(1)) SWIG_fail;
24105 result = (wxFont *)& ((arg1)->font);
24106
24107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24108 return resultobj;
24109 fail:
24110 return NULL;
24111 }
24112
24113
24114 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24115 PyObject *resultobj;
24116 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24117 wxColour *arg2 = (wxColour *) 0 ;
24118 PyObject * obj0 = 0 ;
24119 PyObject * obj1 = 0 ;
24120 char *kwnames[] = {
24121 (char *) "self",(char *) "colFg", NULL
24122 };
24123
24124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24126 if (SWIG_arg_fail(1)) SWIG_fail;
24127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24128 if (SWIG_arg_fail(2)) SWIG_fail;
24129 if (arg1) (arg1)->colFg = *arg2;
24130
24131 Py_INCREF(Py_None); resultobj = Py_None;
24132 return resultobj;
24133 fail:
24134 return NULL;
24135 }
24136
24137
24138 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24139 PyObject *resultobj;
24140 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24141 wxColour *result;
24142 PyObject * obj0 = 0 ;
24143 char *kwnames[] = {
24144 (char *) "self", NULL
24145 };
24146
24147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24149 if (SWIG_arg_fail(1)) SWIG_fail;
24150 result = (wxColour *)& ((arg1)->colFg);
24151
24152 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24160 PyObject *resultobj;
24161 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24162 wxColour *arg2 = (wxColour *) 0 ;
24163 PyObject * obj0 = 0 ;
24164 PyObject * obj1 = 0 ;
24165 char *kwnames[] = {
24166 (char *) "self",(char *) "colBg", NULL
24167 };
24168
24169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24171 if (SWIG_arg_fail(1)) SWIG_fail;
24172 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24173 if (SWIG_arg_fail(2)) SWIG_fail;
24174 if (arg1) (arg1)->colBg = *arg2;
24175
24176 Py_INCREF(Py_None); resultobj = Py_None;
24177 return resultobj;
24178 fail:
24179 return NULL;
24180 }
24181
24182
24183 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24184 PyObject *resultobj;
24185 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24186 wxColour *result;
24187 PyObject * obj0 = 0 ;
24188 char *kwnames[] = {
24189 (char *) "self", NULL
24190 };
24191
24192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24194 if (SWIG_arg_fail(1)) SWIG_fail;
24195 result = (wxColour *)& ((arg1)->colBg);
24196
24197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24198 return resultobj;
24199 fail:
24200 return NULL;
24201 }
24202
24203
24204 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24205 PyObject *obj;
24206 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24207 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24208 Py_INCREF(obj);
24209 return Py_BuildValue((char *)"");
24210 }
24211 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24212 PyObject *resultobj;
24213 wxWindow *arg1 = (wxWindow *) 0 ;
24214 int arg2 = (int) (int)-1 ;
24215 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24216 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24217 wxSize const &arg4_defvalue = wxDefaultSize ;
24218 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24219 long arg5 = (long) 0 ;
24220 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24221 wxString *arg6 = (wxString *) &arg6_defvalue ;
24222 wxWindow *result;
24223 wxPoint temp3 ;
24224 wxSize temp4 ;
24225 bool temp6 = false ;
24226 PyObject * obj0 = 0 ;
24227 PyObject * obj1 = 0 ;
24228 PyObject * obj2 = 0 ;
24229 PyObject * obj3 = 0 ;
24230 PyObject * obj4 = 0 ;
24231 PyObject * obj5 = 0 ;
24232 char *kwnames[] = {
24233 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24234 };
24235
24236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24238 if (SWIG_arg_fail(1)) SWIG_fail;
24239 if (obj1) {
24240 {
24241 arg2 = (int const)(SWIG_As_int(obj1));
24242 if (SWIG_arg_fail(2)) SWIG_fail;
24243 }
24244 }
24245 if (obj2) {
24246 {
24247 arg3 = &temp3;
24248 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24249 }
24250 }
24251 if (obj3) {
24252 {
24253 arg4 = &temp4;
24254 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24255 }
24256 }
24257 if (obj4) {
24258 {
24259 arg5 = (long)(SWIG_As_long(obj4));
24260 if (SWIG_arg_fail(5)) SWIG_fail;
24261 }
24262 }
24263 if (obj5) {
24264 {
24265 arg6 = wxString_in_helper(obj5);
24266 if (arg6 == NULL) SWIG_fail;
24267 temp6 = true;
24268 }
24269 }
24270 {
24271 if (!wxPyCheckForApp()) SWIG_fail;
24272 PyThreadState* __tstate = wxPyBeginAllowThreads();
24273 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24274
24275 wxPyEndAllowThreads(__tstate);
24276 if (PyErr_Occurred()) SWIG_fail;
24277 }
24278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24279 {
24280 if (temp6)
24281 delete arg6;
24282 }
24283 return resultobj;
24284 fail:
24285 {
24286 if (temp6)
24287 delete arg6;
24288 }
24289 return NULL;
24290 }
24291
24292
24293 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24294 PyObject *resultobj;
24295 wxWindow *result;
24296 char *kwnames[] = {
24297 NULL
24298 };
24299
24300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24301 {
24302 if (!wxPyCheckForApp()) SWIG_fail;
24303 PyThreadState* __tstate = wxPyBeginAllowThreads();
24304 result = (wxWindow *)new wxWindow();
24305
24306 wxPyEndAllowThreads(__tstate);
24307 if (PyErr_Occurred()) SWIG_fail;
24308 }
24309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24310 return resultobj;
24311 fail:
24312 return NULL;
24313 }
24314
24315
24316 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24317 PyObject *resultobj;
24318 wxWindow *arg1 = (wxWindow *) 0 ;
24319 wxWindow *arg2 = (wxWindow *) 0 ;
24320 int arg3 = (int) (int)-1 ;
24321 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24322 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24323 wxSize const &arg5_defvalue = wxDefaultSize ;
24324 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24325 long arg6 = (long) 0 ;
24326 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24327 wxString *arg7 = (wxString *) &arg7_defvalue ;
24328 bool result;
24329 wxPoint temp4 ;
24330 wxSize temp5 ;
24331 bool temp7 = false ;
24332 PyObject * obj0 = 0 ;
24333 PyObject * obj1 = 0 ;
24334 PyObject * obj2 = 0 ;
24335 PyObject * obj3 = 0 ;
24336 PyObject * obj4 = 0 ;
24337 PyObject * obj5 = 0 ;
24338 PyObject * obj6 = 0 ;
24339 char *kwnames[] = {
24340 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24341 };
24342
24343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24345 if (SWIG_arg_fail(1)) SWIG_fail;
24346 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24347 if (SWIG_arg_fail(2)) SWIG_fail;
24348 if (obj2) {
24349 {
24350 arg3 = (int const)(SWIG_As_int(obj2));
24351 if (SWIG_arg_fail(3)) SWIG_fail;
24352 }
24353 }
24354 if (obj3) {
24355 {
24356 arg4 = &temp4;
24357 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24358 }
24359 }
24360 if (obj4) {
24361 {
24362 arg5 = &temp5;
24363 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24364 }
24365 }
24366 if (obj5) {
24367 {
24368 arg6 = (long)(SWIG_As_long(obj5));
24369 if (SWIG_arg_fail(6)) SWIG_fail;
24370 }
24371 }
24372 if (obj6) {
24373 {
24374 arg7 = wxString_in_helper(obj6);
24375 if (arg7 == NULL) SWIG_fail;
24376 temp7 = true;
24377 }
24378 }
24379 {
24380 PyThreadState* __tstate = wxPyBeginAllowThreads();
24381 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24382
24383 wxPyEndAllowThreads(__tstate);
24384 if (PyErr_Occurred()) SWIG_fail;
24385 }
24386 {
24387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24388 }
24389 {
24390 if (temp7)
24391 delete arg7;
24392 }
24393 return resultobj;
24394 fail:
24395 {
24396 if (temp7)
24397 delete arg7;
24398 }
24399 return NULL;
24400 }
24401
24402
24403 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24404 PyObject *resultobj;
24405 wxWindow *arg1 = (wxWindow *) 0 ;
24406 bool arg2 = (bool) false ;
24407 bool result;
24408 PyObject * obj0 = 0 ;
24409 PyObject * obj1 = 0 ;
24410 char *kwnames[] = {
24411 (char *) "self",(char *) "force", NULL
24412 };
24413
24414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24416 if (SWIG_arg_fail(1)) SWIG_fail;
24417 if (obj1) {
24418 {
24419 arg2 = (bool)(SWIG_As_bool(obj1));
24420 if (SWIG_arg_fail(2)) SWIG_fail;
24421 }
24422 }
24423 {
24424 PyThreadState* __tstate = wxPyBeginAllowThreads();
24425 result = (bool)(arg1)->Close(arg2);
24426
24427 wxPyEndAllowThreads(__tstate);
24428 if (PyErr_Occurred()) SWIG_fail;
24429 }
24430 {
24431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24432 }
24433 return resultobj;
24434 fail:
24435 return NULL;
24436 }
24437
24438
24439 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24440 PyObject *resultobj;
24441 wxWindow *arg1 = (wxWindow *) 0 ;
24442 bool result;
24443 PyObject * obj0 = 0 ;
24444 char *kwnames[] = {
24445 (char *) "self", NULL
24446 };
24447
24448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24450 if (SWIG_arg_fail(1)) SWIG_fail;
24451 {
24452 PyThreadState* __tstate = wxPyBeginAllowThreads();
24453 result = (bool)(arg1)->Destroy();
24454
24455 wxPyEndAllowThreads(__tstate);
24456 if (PyErr_Occurred()) SWIG_fail;
24457 }
24458 {
24459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24460 }
24461 return resultobj;
24462 fail:
24463 return NULL;
24464 }
24465
24466
24467 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24468 PyObject *resultobj;
24469 wxWindow *arg1 = (wxWindow *) 0 ;
24470 bool result;
24471 PyObject * obj0 = 0 ;
24472 char *kwnames[] = {
24473 (char *) "self", NULL
24474 };
24475
24476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24478 if (SWIG_arg_fail(1)) SWIG_fail;
24479 {
24480 PyThreadState* __tstate = wxPyBeginAllowThreads();
24481 result = (bool)(arg1)->DestroyChildren();
24482
24483 wxPyEndAllowThreads(__tstate);
24484 if (PyErr_Occurred()) SWIG_fail;
24485 }
24486 {
24487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24488 }
24489 return resultobj;
24490 fail:
24491 return NULL;
24492 }
24493
24494
24495 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24496 PyObject *resultobj;
24497 wxWindow *arg1 = (wxWindow *) 0 ;
24498 bool result;
24499 PyObject * obj0 = 0 ;
24500 char *kwnames[] = {
24501 (char *) "self", NULL
24502 };
24503
24504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24506 if (SWIG_arg_fail(1)) SWIG_fail;
24507 {
24508 PyThreadState* __tstate = wxPyBeginAllowThreads();
24509 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24510
24511 wxPyEndAllowThreads(__tstate);
24512 if (PyErr_Occurred()) SWIG_fail;
24513 }
24514 {
24515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24516 }
24517 return resultobj;
24518 fail:
24519 return NULL;
24520 }
24521
24522
24523 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24524 PyObject *resultobj;
24525 wxWindow *arg1 = (wxWindow *) 0 ;
24526 wxString *arg2 = 0 ;
24527 bool temp2 = false ;
24528 PyObject * obj0 = 0 ;
24529 PyObject * obj1 = 0 ;
24530 char *kwnames[] = {
24531 (char *) "self",(char *) "title", NULL
24532 };
24533
24534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24536 if (SWIG_arg_fail(1)) SWIG_fail;
24537 {
24538 arg2 = wxString_in_helper(obj1);
24539 if (arg2 == NULL) SWIG_fail;
24540 temp2 = true;
24541 }
24542 {
24543 PyThreadState* __tstate = wxPyBeginAllowThreads();
24544 (arg1)->SetTitle((wxString const &)*arg2);
24545
24546 wxPyEndAllowThreads(__tstate);
24547 if (PyErr_Occurred()) SWIG_fail;
24548 }
24549 Py_INCREF(Py_None); resultobj = Py_None;
24550 {
24551 if (temp2)
24552 delete arg2;
24553 }
24554 return resultobj;
24555 fail:
24556 {
24557 if (temp2)
24558 delete arg2;
24559 }
24560 return NULL;
24561 }
24562
24563
24564 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24565 PyObject *resultobj;
24566 wxWindow *arg1 = (wxWindow *) 0 ;
24567 wxString result;
24568 PyObject * obj0 = 0 ;
24569 char *kwnames[] = {
24570 (char *) "self", NULL
24571 };
24572
24573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24575 if (SWIG_arg_fail(1)) SWIG_fail;
24576 {
24577 PyThreadState* __tstate = wxPyBeginAllowThreads();
24578 result = ((wxWindow const *)arg1)->GetTitle();
24579
24580 wxPyEndAllowThreads(__tstate);
24581 if (PyErr_Occurred()) SWIG_fail;
24582 }
24583 {
24584 #if wxUSE_UNICODE
24585 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24586 #else
24587 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24588 #endif
24589 }
24590 return resultobj;
24591 fail:
24592 return NULL;
24593 }
24594
24595
24596 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24597 PyObject *resultobj;
24598 wxWindow *arg1 = (wxWindow *) 0 ;
24599 wxString *arg2 = 0 ;
24600 bool temp2 = false ;
24601 PyObject * obj0 = 0 ;
24602 PyObject * obj1 = 0 ;
24603 char *kwnames[] = {
24604 (char *) "self",(char *) "label", NULL
24605 };
24606
24607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24609 if (SWIG_arg_fail(1)) SWIG_fail;
24610 {
24611 arg2 = wxString_in_helper(obj1);
24612 if (arg2 == NULL) SWIG_fail;
24613 temp2 = true;
24614 }
24615 {
24616 PyThreadState* __tstate = wxPyBeginAllowThreads();
24617 (arg1)->SetLabel((wxString const &)*arg2);
24618
24619 wxPyEndAllowThreads(__tstate);
24620 if (PyErr_Occurred()) SWIG_fail;
24621 }
24622 Py_INCREF(Py_None); resultobj = Py_None;
24623 {
24624 if (temp2)
24625 delete arg2;
24626 }
24627 return resultobj;
24628 fail:
24629 {
24630 if (temp2)
24631 delete arg2;
24632 }
24633 return NULL;
24634 }
24635
24636
24637 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24638 PyObject *resultobj;
24639 wxWindow *arg1 = (wxWindow *) 0 ;
24640 wxString result;
24641 PyObject * obj0 = 0 ;
24642 char *kwnames[] = {
24643 (char *) "self", NULL
24644 };
24645
24646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24648 if (SWIG_arg_fail(1)) SWIG_fail;
24649 {
24650 PyThreadState* __tstate = wxPyBeginAllowThreads();
24651 result = ((wxWindow const *)arg1)->GetLabel();
24652
24653 wxPyEndAllowThreads(__tstate);
24654 if (PyErr_Occurred()) SWIG_fail;
24655 }
24656 {
24657 #if wxUSE_UNICODE
24658 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24659 #else
24660 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24661 #endif
24662 }
24663 return resultobj;
24664 fail:
24665 return NULL;
24666 }
24667
24668
24669 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24670 PyObject *resultobj;
24671 wxWindow *arg1 = (wxWindow *) 0 ;
24672 wxString *arg2 = 0 ;
24673 bool temp2 = false ;
24674 PyObject * obj0 = 0 ;
24675 PyObject * obj1 = 0 ;
24676 char *kwnames[] = {
24677 (char *) "self",(char *) "name", NULL
24678 };
24679
24680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24682 if (SWIG_arg_fail(1)) SWIG_fail;
24683 {
24684 arg2 = wxString_in_helper(obj1);
24685 if (arg2 == NULL) SWIG_fail;
24686 temp2 = true;
24687 }
24688 {
24689 PyThreadState* __tstate = wxPyBeginAllowThreads();
24690 (arg1)->SetName((wxString const &)*arg2);
24691
24692 wxPyEndAllowThreads(__tstate);
24693 if (PyErr_Occurred()) SWIG_fail;
24694 }
24695 Py_INCREF(Py_None); resultobj = Py_None;
24696 {
24697 if (temp2)
24698 delete arg2;
24699 }
24700 return resultobj;
24701 fail:
24702 {
24703 if (temp2)
24704 delete arg2;
24705 }
24706 return NULL;
24707 }
24708
24709
24710 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24711 PyObject *resultobj;
24712 wxWindow *arg1 = (wxWindow *) 0 ;
24713 wxString result;
24714 PyObject * obj0 = 0 ;
24715 char *kwnames[] = {
24716 (char *) "self", NULL
24717 };
24718
24719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24721 if (SWIG_arg_fail(1)) SWIG_fail;
24722 {
24723 PyThreadState* __tstate = wxPyBeginAllowThreads();
24724 result = ((wxWindow const *)arg1)->GetName();
24725
24726 wxPyEndAllowThreads(__tstate);
24727 if (PyErr_Occurred()) SWIG_fail;
24728 }
24729 {
24730 #if wxUSE_UNICODE
24731 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24732 #else
24733 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24734 #endif
24735 }
24736 return resultobj;
24737 fail:
24738 return NULL;
24739 }
24740
24741
24742 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24743 PyObject *resultobj;
24744 wxWindow *arg1 = (wxWindow *) 0 ;
24745 wxWindowVariant arg2 ;
24746 PyObject * obj0 = 0 ;
24747 PyObject * obj1 = 0 ;
24748 char *kwnames[] = {
24749 (char *) "self",(char *) "variant", NULL
24750 };
24751
24752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
24753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24754 if (SWIG_arg_fail(1)) SWIG_fail;
24755 {
24756 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
24757 if (SWIG_arg_fail(2)) SWIG_fail;
24758 }
24759 {
24760 PyThreadState* __tstate = wxPyBeginAllowThreads();
24761 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
24762
24763 wxPyEndAllowThreads(__tstate);
24764 if (PyErr_Occurred()) SWIG_fail;
24765 }
24766 Py_INCREF(Py_None); resultobj = Py_None;
24767 return resultobj;
24768 fail:
24769 return NULL;
24770 }
24771
24772
24773 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24774 PyObject *resultobj;
24775 wxWindow *arg1 = (wxWindow *) 0 ;
24776 wxWindowVariant result;
24777 PyObject * obj0 = 0 ;
24778 char *kwnames[] = {
24779 (char *) "self", NULL
24780 };
24781
24782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
24783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24784 if (SWIG_arg_fail(1)) SWIG_fail;
24785 {
24786 PyThreadState* __tstate = wxPyBeginAllowThreads();
24787 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
24788
24789 wxPyEndAllowThreads(__tstate);
24790 if (PyErr_Occurred()) SWIG_fail;
24791 }
24792 resultobj = SWIG_From_int((result));
24793 return resultobj;
24794 fail:
24795 return NULL;
24796 }
24797
24798
24799 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
24800 PyObject *resultobj;
24801 wxWindow *arg1 = (wxWindow *) 0 ;
24802 int arg2 ;
24803 PyObject * obj0 = 0 ;
24804 PyObject * obj1 = 0 ;
24805 char *kwnames[] = {
24806 (char *) "self",(char *) "winid", NULL
24807 };
24808
24809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
24810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24811 if (SWIG_arg_fail(1)) SWIG_fail;
24812 {
24813 arg2 = (int)(SWIG_As_int(obj1));
24814 if (SWIG_arg_fail(2)) SWIG_fail;
24815 }
24816 {
24817 PyThreadState* __tstate = wxPyBeginAllowThreads();
24818 (arg1)->SetId(arg2);
24819
24820 wxPyEndAllowThreads(__tstate);
24821 if (PyErr_Occurred()) SWIG_fail;
24822 }
24823 Py_INCREF(Py_None); resultobj = Py_None;
24824 return resultobj;
24825 fail:
24826 return NULL;
24827 }
24828
24829
24830 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
24831 PyObject *resultobj;
24832 wxWindow *arg1 = (wxWindow *) 0 ;
24833 int result;
24834 PyObject * obj0 = 0 ;
24835 char *kwnames[] = {
24836 (char *) "self", NULL
24837 };
24838
24839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
24840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24841 if (SWIG_arg_fail(1)) SWIG_fail;
24842 {
24843 PyThreadState* __tstate = wxPyBeginAllowThreads();
24844 result = (int)((wxWindow const *)arg1)->GetId();
24845
24846 wxPyEndAllowThreads(__tstate);
24847 if (PyErr_Occurred()) SWIG_fail;
24848 }
24849 {
24850 resultobj = SWIG_From_int((int)(result));
24851 }
24852 return resultobj;
24853 fail:
24854 return NULL;
24855 }
24856
24857
24858 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24859 PyObject *resultobj;
24860 int result;
24861 char *kwnames[] = {
24862 NULL
24863 };
24864
24865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
24866 {
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 result = (int)wxWindow::NewControlId();
24869
24870 wxPyEndAllowThreads(__tstate);
24871 if (PyErr_Occurred()) SWIG_fail;
24872 }
24873 {
24874 resultobj = SWIG_From_int((int)(result));
24875 }
24876 return resultobj;
24877 fail:
24878 return NULL;
24879 }
24880
24881
24882 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24883 PyObject *resultobj;
24884 int arg1 ;
24885 int result;
24886 PyObject * obj0 = 0 ;
24887 char *kwnames[] = {
24888 (char *) "winid", NULL
24889 };
24890
24891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
24892 {
24893 arg1 = (int)(SWIG_As_int(obj0));
24894 if (SWIG_arg_fail(1)) SWIG_fail;
24895 }
24896 {
24897 PyThreadState* __tstate = wxPyBeginAllowThreads();
24898 result = (int)wxWindow::NextControlId(arg1);
24899
24900 wxPyEndAllowThreads(__tstate);
24901 if (PyErr_Occurred()) SWIG_fail;
24902 }
24903 {
24904 resultobj = SWIG_From_int((int)(result));
24905 }
24906 return resultobj;
24907 fail:
24908 return NULL;
24909 }
24910
24911
24912 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24913 PyObject *resultobj;
24914 int arg1 ;
24915 int result;
24916 PyObject * obj0 = 0 ;
24917 char *kwnames[] = {
24918 (char *) "winid", NULL
24919 };
24920
24921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
24922 {
24923 arg1 = (int)(SWIG_As_int(obj0));
24924 if (SWIG_arg_fail(1)) SWIG_fail;
24925 }
24926 {
24927 PyThreadState* __tstate = wxPyBeginAllowThreads();
24928 result = (int)wxWindow::PrevControlId(arg1);
24929
24930 wxPyEndAllowThreads(__tstate);
24931 if (PyErr_Occurred()) SWIG_fail;
24932 }
24933 {
24934 resultobj = SWIG_From_int((int)(result));
24935 }
24936 return resultobj;
24937 fail:
24938 return NULL;
24939 }
24940
24941
24942 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
24943 PyObject *resultobj;
24944 wxWindow *arg1 = (wxWindow *) 0 ;
24945 wxSize *arg2 = 0 ;
24946 wxSize temp2 ;
24947 PyObject * obj0 = 0 ;
24948 PyObject * obj1 = 0 ;
24949 char *kwnames[] = {
24950 (char *) "self",(char *) "size", NULL
24951 };
24952
24953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
24954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24955 if (SWIG_arg_fail(1)) SWIG_fail;
24956 {
24957 arg2 = &temp2;
24958 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
24959 }
24960 {
24961 PyThreadState* __tstate = wxPyBeginAllowThreads();
24962 (arg1)->SetSize((wxSize const &)*arg2);
24963
24964 wxPyEndAllowThreads(__tstate);
24965 if (PyErr_Occurred()) SWIG_fail;
24966 }
24967 Py_INCREF(Py_None); resultobj = Py_None;
24968 return resultobj;
24969 fail:
24970 return NULL;
24971 }
24972
24973
24974 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
24975 PyObject *resultobj;
24976 wxWindow *arg1 = (wxWindow *) 0 ;
24977 int arg2 ;
24978 int arg3 ;
24979 int arg4 ;
24980 int arg5 ;
24981 int arg6 = (int) wxSIZE_AUTO ;
24982 PyObject * obj0 = 0 ;
24983 PyObject * obj1 = 0 ;
24984 PyObject * obj2 = 0 ;
24985 PyObject * obj3 = 0 ;
24986 PyObject * obj4 = 0 ;
24987 PyObject * obj5 = 0 ;
24988 char *kwnames[] = {
24989 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
24990 };
24991
24992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24994 if (SWIG_arg_fail(1)) SWIG_fail;
24995 {
24996 arg2 = (int)(SWIG_As_int(obj1));
24997 if (SWIG_arg_fail(2)) SWIG_fail;
24998 }
24999 {
25000 arg3 = (int)(SWIG_As_int(obj2));
25001 if (SWIG_arg_fail(3)) SWIG_fail;
25002 }
25003 {
25004 arg4 = (int)(SWIG_As_int(obj3));
25005 if (SWIG_arg_fail(4)) SWIG_fail;
25006 }
25007 {
25008 arg5 = (int)(SWIG_As_int(obj4));
25009 if (SWIG_arg_fail(5)) SWIG_fail;
25010 }
25011 if (obj5) {
25012 {
25013 arg6 = (int)(SWIG_As_int(obj5));
25014 if (SWIG_arg_fail(6)) SWIG_fail;
25015 }
25016 }
25017 {
25018 PyThreadState* __tstate = wxPyBeginAllowThreads();
25019 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25020
25021 wxPyEndAllowThreads(__tstate);
25022 if (PyErr_Occurred()) SWIG_fail;
25023 }
25024 Py_INCREF(Py_None); resultobj = Py_None;
25025 return resultobj;
25026 fail:
25027 return NULL;
25028 }
25029
25030
25031 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25032 PyObject *resultobj;
25033 wxWindow *arg1 = (wxWindow *) 0 ;
25034 wxRect *arg2 = 0 ;
25035 int arg3 = (int) wxSIZE_AUTO ;
25036 wxRect temp2 ;
25037 PyObject * obj0 = 0 ;
25038 PyObject * obj1 = 0 ;
25039 PyObject * obj2 = 0 ;
25040 char *kwnames[] = {
25041 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25042 };
25043
25044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25046 if (SWIG_arg_fail(1)) SWIG_fail;
25047 {
25048 arg2 = &temp2;
25049 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25050 }
25051 if (obj2) {
25052 {
25053 arg3 = (int)(SWIG_As_int(obj2));
25054 if (SWIG_arg_fail(3)) SWIG_fail;
25055 }
25056 }
25057 {
25058 PyThreadState* __tstate = wxPyBeginAllowThreads();
25059 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25060
25061 wxPyEndAllowThreads(__tstate);
25062 if (PyErr_Occurred()) SWIG_fail;
25063 }
25064 Py_INCREF(Py_None); resultobj = Py_None;
25065 return resultobj;
25066 fail:
25067 return NULL;
25068 }
25069
25070
25071 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25072 PyObject *resultobj;
25073 wxWindow *arg1 = (wxWindow *) 0 ;
25074 int arg2 ;
25075 int arg3 ;
25076 PyObject * obj0 = 0 ;
25077 PyObject * obj1 = 0 ;
25078 PyObject * obj2 = 0 ;
25079 char *kwnames[] = {
25080 (char *) "self",(char *) "width",(char *) "height", NULL
25081 };
25082
25083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25085 if (SWIG_arg_fail(1)) SWIG_fail;
25086 {
25087 arg2 = (int)(SWIG_As_int(obj1));
25088 if (SWIG_arg_fail(2)) SWIG_fail;
25089 }
25090 {
25091 arg3 = (int)(SWIG_As_int(obj2));
25092 if (SWIG_arg_fail(3)) SWIG_fail;
25093 }
25094 {
25095 PyThreadState* __tstate = wxPyBeginAllowThreads();
25096 (arg1)->SetSize(arg2,arg3);
25097
25098 wxPyEndAllowThreads(__tstate);
25099 if (PyErr_Occurred()) SWIG_fail;
25100 }
25101 Py_INCREF(Py_None); resultobj = Py_None;
25102 return resultobj;
25103 fail:
25104 return NULL;
25105 }
25106
25107
25108 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25109 PyObject *resultobj;
25110 wxWindow *arg1 = (wxWindow *) 0 ;
25111 wxPoint *arg2 = 0 ;
25112 int arg3 = (int) wxSIZE_USE_EXISTING ;
25113 wxPoint temp2 ;
25114 PyObject * obj0 = 0 ;
25115 PyObject * obj1 = 0 ;
25116 PyObject * obj2 = 0 ;
25117 char *kwnames[] = {
25118 (char *) "self",(char *) "pt",(char *) "flags", NULL
25119 };
25120
25121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25123 if (SWIG_arg_fail(1)) SWIG_fail;
25124 {
25125 arg2 = &temp2;
25126 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25127 }
25128 if (obj2) {
25129 {
25130 arg3 = (int)(SWIG_As_int(obj2));
25131 if (SWIG_arg_fail(3)) SWIG_fail;
25132 }
25133 }
25134 {
25135 PyThreadState* __tstate = wxPyBeginAllowThreads();
25136 (arg1)->Move((wxPoint const &)*arg2,arg3);
25137
25138 wxPyEndAllowThreads(__tstate);
25139 if (PyErr_Occurred()) SWIG_fail;
25140 }
25141 Py_INCREF(Py_None); resultobj = Py_None;
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25149 PyObject *resultobj;
25150 wxWindow *arg1 = (wxWindow *) 0 ;
25151 int arg2 ;
25152 int arg3 ;
25153 int arg4 = (int) wxSIZE_USE_EXISTING ;
25154 PyObject * obj0 = 0 ;
25155 PyObject * obj1 = 0 ;
25156 PyObject * obj2 = 0 ;
25157 PyObject * obj3 = 0 ;
25158 char *kwnames[] = {
25159 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25160 };
25161
25162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25164 if (SWIG_arg_fail(1)) SWIG_fail;
25165 {
25166 arg2 = (int)(SWIG_As_int(obj1));
25167 if (SWIG_arg_fail(2)) SWIG_fail;
25168 }
25169 {
25170 arg3 = (int)(SWIG_As_int(obj2));
25171 if (SWIG_arg_fail(3)) SWIG_fail;
25172 }
25173 if (obj3) {
25174 {
25175 arg4 = (int)(SWIG_As_int(obj3));
25176 if (SWIG_arg_fail(4)) SWIG_fail;
25177 }
25178 }
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 (arg1)->Move(arg2,arg3,arg4);
25182
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 Py_INCREF(Py_None); resultobj = Py_None;
25187 return resultobj;
25188 fail:
25189 return NULL;
25190 }
25191
25192
25193 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25194 PyObject *resultobj;
25195 wxWindow *arg1 = (wxWindow *) 0 ;
25196 wxSize const &arg2_defvalue = wxDefaultSize ;
25197 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25198 wxSize temp2 ;
25199 PyObject * obj0 = 0 ;
25200 PyObject * obj1 = 0 ;
25201 char *kwnames[] = {
25202 (char *) "self",(char *) "size", NULL
25203 };
25204
25205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25207 if (SWIG_arg_fail(1)) SWIG_fail;
25208 if (obj1) {
25209 {
25210 arg2 = &temp2;
25211 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25212 }
25213 }
25214 {
25215 PyThreadState* __tstate = wxPyBeginAllowThreads();
25216 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25217
25218 wxPyEndAllowThreads(__tstate);
25219 if (PyErr_Occurred()) SWIG_fail;
25220 }
25221 Py_INCREF(Py_None); resultobj = Py_None;
25222 return resultobj;
25223 fail:
25224 return NULL;
25225 }
25226
25227
25228 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25229 PyObject *resultobj;
25230 wxWindow *arg1 = (wxWindow *) 0 ;
25231 PyObject * obj0 = 0 ;
25232 char *kwnames[] = {
25233 (char *) "self", NULL
25234 };
25235
25236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25238 if (SWIG_arg_fail(1)) SWIG_fail;
25239 {
25240 PyThreadState* __tstate = wxPyBeginAllowThreads();
25241 (arg1)->Raise();
25242
25243 wxPyEndAllowThreads(__tstate);
25244 if (PyErr_Occurred()) SWIG_fail;
25245 }
25246 Py_INCREF(Py_None); resultobj = Py_None;
25247 return resultobj;
25248 fail:
25249 return NULL;
25250 }
25251
25252
25253 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25254 PyObject *resultobj;
25255 wxWindow *arg1 = (wxWindow *) 0 ;
25256 PyObject * obj0 = 0 ;
25257 char *kwnames[] = {
25258 (char *) "self", NULL
25259 };
25260
25261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25263 if (SWIG_arg_fail(1)) SWIG_fail;
25264 {
25265 PyThreadState* __tstate = wxPyBeginAllowThreads();
25266 (arg1)->Lower();
25267
25268 wxPyEndAllowThreads(__tstate);
25269 if (PyErr_Occurred()) SWIG_fail;
25270 }
25271 Py_INCREF(Py_None); resultobj = Py_None;
25272 return resultobj;
25273 fail:
25274 return NULL;
25275 }
25276
25277
25278 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25279 PyObject *resultobj;
25280 wxWindow *arg1 = (wxWindow *) 0 ;
25281 wxSize *arg2 = 0 ;
25282 wxSize temp2 ;
25283 PyObject * obj0 = 0 ;
25284 PyObject * obj1 = 0 ;
25285 char *kwnames[] = {
25286 (char *) "self",(char *) "size", NULL
25287 };
25288
25289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25291 if (SWIG_arg_fail(1)) SWIG_fail;
25292 {
25293 arg2 = &temp2;
25294 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25295 }
25296 {
25297 PyThreadState* __tstate = wxPyBeginAllowThreads();
25298 (arg1)->SetClientSize((wxSize const &)*arg2);
25299
25300 wxPyEndAllowThreads(__tstate);
25301 if (PyErr_Occurred()) SWIG_fail;
25302 }
25303 Py_INCREF(Py_None); resultobj = Py_None;
25304 return resultobj;
25305 fail:
25306 return NULL;
25307 }
25308
25309
25310 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25311 PyObject *resultobj;
25312 wxWindow *arg1 = (wxWindow *) 0 ;
25313 int arg2 ;
25314 int arg3 ;
25315 PyObject * obj0 = 0 ;
25316 PyObject * obj1 = 0 ;
25317 PyObject * obj2 = 0 ;
25318 char *kwnames[] = {
25319 (char *) "self",(char *) "width",(char *) "height", NULL
25320 };
25321
25322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25324 if (SWIG_arg_fail(1)) SWIG_fail;
25325 {
25326 arg2 = (int)(SWIG_As_int(obj1));
25327 if (SWIG_arg_fail(2)) SWIG_fail;
25328 }
25329 {
25330 arg3 = (int)(SWIG_As_int(obj2));
25331 if (SWIG_arg_fail(3)) SWIG_fail;
25332 }
25333 {
25334 PyThreadState* __tstate = wxPyBeginAllowThreads();
25335 (arg1)->SetClientSize(arg2,arg3);
25336
25337 wxPyEndAllowThreads(__tstate);
25338 if (PyErr_Occurred()) SWIG_fail;
25339 }
25340 Py_INCREF(Py_None); resultobj = Py_None;
25341 return resultobj;
25342 fail:
25343 return NULL;
25344 }
25345
25346
25347 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25348 PyObject *resultobj;
25349 wxWindow *arg1 = (wxWindow *) 0 ;
25350 wxRect *arg2 = 0 ;
25351 wxRect temp2 ;
25352 PyObject * obj0 = 0 ;
25353 PyObject * obj1 = 0 ;
25354 char *kwnames[] = {
25355 (char *) "self",(char *) "rect", NULL
25356 };
25357
25358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25360 if (SWIG_arg_fail(1)) SWIG_fail;
25361 {
25362 arg2 = &temp2;
25363 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25364 }
25365 {
25366 PyThreadState* __tstate = wxPyBeginAllowThreads();
25367 (arg1)->SetClientSize((wxRect const &)*arg2);
25368
25369 wxPyEndAllowThreads(__tstate);
25370 if (PyErr_Occurred()) SWIG_fail;
25371 }
25372 Py_INCREF(Py_None); resultobj = Py_None;
25373 return resultobj;
25374 fail:
25375 return NULL;
25376 }
25377
25378
25379 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25380 PyObject *resultobj;
25381 wxWindow *arg1 = (wxWindow *) 0 ;
25382 wxPoint result;
25383 PyObject * obj0 = 0 ;
25384 char *kwnames[] = {
25385 (char *) "self", NULL
25386 };
25387
25388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25390 if (SWIG_arg_fail(1)) SWIG_fail;
25391 {
25392 PyThreadState* __tstate = wxPyBeginAllowThreads();
25393 result = (arg1)->GetPosition();
25394
25395 wxPyEndAllowThreads(__tstate);
25396 if (PyErr_Occurred()) SWIG_fail;
25397 }
25398 {
25399 wxPoint * resultptr;
25400 resultptr = new wxPoint((wxPoint &)(result));
25401 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25402 }
25403 return resultobj;
25404 fail:
25405 return NULL;
25406 }
25407
25408
25409 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25410 PyObject *resultobj;
25411 wxWindow *arg1 = (wxWindow *) 0 ;
25412 int *arg2 = (int *) 0 ;
25413 int *arg3 = (int *) 0 ;
25414 int temp2 ;
25415 int res2 = 0 ;
25416 int temp3 ;
25417 int res3 = 0 ;
25418 PyObject * obj0 = 0 ;
25419 char *kwnames[] = {
25420 (char *) "self", NULL
25421 };
25422
25423 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25424 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25427 if (SWIG_arg_fail(1)) SWIG_fail;
25428 {
25429 PyThreadState* __tstate = wxPyBeginAllowThreads();
25430 (arg1)->GetPosition(arg2,arg3);
25431
25432 wxPyEndAllowThreads(__tstate);
25433 if (PyErr_Occurred()) SWIG_fail;
25434 }
25435 Py_INCREF(Py_None); resultobj = Py_None;
25436 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25437 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25438 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25439 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25440 return resultobj;
25441 fail:
25442 return NULL;
25443 }
25444
25445
25446 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25447 PyObject *resultobj;
25448 wxWindow *arg1 = (wxWindow *) 0 ;
25449 wxSize result;
25450 PyObject * obj0 = 0 ;
25451 char *kwnames[] = {
25452 (char *) "self", NULL
25453 };
25454
25455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25457 if (SWIG_arg_fail(1)) SWIG_fail;
25458 {
25459 PyThreadState* __tstate = wxPyBeginAllowThreads();
25460 result = ((wxWindow const *)arg1)->GetSize();
25461
25462 wxPyEndAllowThreads(__tstate);
25463 if (PyErr_Occurred()) SWIG_fail;
25464 }
25465 {
25466 wxSize * resultptr;
25467 resultptr = new wxSize((wxSize &)(result));
25468 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25469 }
25470 return resultobj;
25471 fail:
25472 return NULL;
25473 }
25474
25475
25476 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25477 PyObject *resultobj;
25478 wxWindow *arg1 = (wxWindow *) 0 ;
25479 int *arg2 = (int *) 0 ;
25480 int *arg3 = (int *) 0 ;
25481 int temp2 ;
25482 int res2 = 0 ;
25483 int temp3 ;
25484 int res3 = 0 ;
25485 PyObject * obj0 = 0 ;
25486 char *kwnames[] = {
25487 (char *) "self", NULL
25488 };
25489
25490 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25491 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25494 if (SWIG_arg_fail(1)) SWIG_fail;
25495 {
25496 PyThreadState* __tstate = wxPyBeginAllowThreads();
25497 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25498
25499 wxPyEndAllowThreads(__tstate);
25500 if (PyErr_Occurred()) SWIG_fail;
25501 }
25502 Py_INCREF(Py_None); resultobj = Py_None;
25503 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25504 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25505 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25506 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25507 return resultobj;
25508 fail:
25509 return NULL;
25510 }
25511
25512
25513 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25514 PyObject *resultobj;
25515 wxWindow *arg1 = (wxWindow *) 0 ;
25516 wxRect result;
25517 PyObject * obj0 = 0 ;
25518 char *kwnames[] = {
25519 (char *) "self", NULL
25520 };
25521
25522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25524 if (SWIG_arg_fail(1)) SWIG_fail;
25525 {
25526 PyThreadState* __tstate = wxPyBeginAllowThreads();
25527 result = ((wxWindow const *)arg1)->GetRect();
25528
25529 wxPyEndAllowThreads(__tstate);
25530 if (PyErr_Occurred()) SWIG_fail;
25531 }
25532 {
25533 wxRect * resultptr;
25534 resultptr = new wxRect((wxRect &)(result));
25535 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25536 }
25537 return resultobj;
25538 fail:
25539 return NULL;
25540 }
25541
25542
25543 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25544 PyObject *resultobj;
25545 wxWindow *arg1 = (wxWindow *) 0 ;
25546 wxSize result;
25547 PyObject * obj0 = 0 ;
25548 char *kwnames[] = {
25549 (char *) "self", NULL
25550 };
25551
25552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25554 if (SWIG_arg_fail(1)) SWIG_fail;
25555 {
25556 PyThreadState* __tstate = wxPyBeginAllowThreads();
25557 result = ((wxWindow const *)arg1)->GetClientSize();
25558
25559 wxPyEndAllowThreads(__tstate);
25560 if (PyErr_Occurred()) SWIG_fail;
25561 }
25562 {
25563 wxSize * resultptr;
25564 resultptr = new wxSize((wxSize &)(result));
25565 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25566 }
25567 return resultobj;
25568 fail:
25569 return NULL;
25570 }
25571
25572
25573 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25574 PyObject *resultobj;
25575 wxWindow *arg1 = (wxWindow *) 0 ;
25576 int *arg2 = (int *) 0 ;
25577 int *arg3 = (int *) 0 ;
25578 int temp2 ;
25579 int res2 = 0 ;
25580 int temp3 ;
25581 int res3 = 0 ;
25582 PyObject * obj0 = 0 ;
25583 char *kwnames[] = {
25584 (char *) "self", NULL
25585 };
25586
25587 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25588 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25591 if (SWIG_arg_fail(1)) SWIG_fail;
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25595
25596 wxPyEndAllowThreads(__tstate);
25597 if (PyErr_Occurred()) SWIG_fail;
25598 }
25599 Py_INCREF(Py_None); resultobj = Py_None;
25600 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25601 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25602 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25603 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25604 return resultobj;
25605 fail:
25606 return NULL;
25607 }
25608
25609
25610 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25611 PyObject *resultobj;
25612 wxWindow *arg1 = (wxWindow *) 0 ;
25613 wxPoint result;
25614 PyObject * obj0 = 0 ;
25615 char *kwnames[] = {
25616 (char *) "self", NULL
25617 };
25618
25619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25621 if (SWIG_arg_fail(1)) SWIG_fail;
25622 {
25623 PyThreadState* __tstate = wxPyBeginAllowThreads();
25624 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25625
25626 wxPyEndAllowThreads(__tstate);
25627 if (PyErr_Occurred()) SWIG_fail;
25628 }
25629 {
25630 wxPoint * resultptr;
25631 resultptr = new wxPoint((wxPoint &)(result));
25632 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25633 }
25634 return resultobj;
25635 fail:
25636 return NULL;
25637 }
25638
25639
25640 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25641 PyObject *resultobj;
25642 wxWindow *arg1 = (wxWindow *) 0 ;
25643 wxRect result;
25644 PyObject * obj0 = 0 ;
25645 char *kwnames[] = {
25646 (char *) "self", NULL
25647 };
25648
25649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25651 if (SWIG_arg_fail(1)) SWIG_fail;
25652 {
25653 PyThreadState* __tstate = wxPyBeginAllowThreads();
25654 result = ((wxWindow const *)arg1)->GetClientRect();
25655
25656 wxPyEndAllowThreads(__tstate);
25657 if (PyErr_Occurred()) SWIG_fail;
25658 }
25659 {
25660 wxRect * resultptr;
25661 resultptr = new wxRect((wxRect &)(result));
25662 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25663 }
25664 return resultobj;
25665 fail:
25666 return NULL;
25667 }
25668
25669
25670 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25671 PyObject *resultobj;
25672 wxWindow *arg1 = (wxWindow *) 0 ;
25673 wxSize result;
25674 PyObject * obj0 = 0 ;
25675 char *kwnames[] = {
25676 (char *) "self", NULL
25677 };
25678
25679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25681 if (SWIG_arg_fail(1)) SWIG_fail;
25682 {
25683 PyThreadState* __tstate = wxPyBeginAllowThreads();
25684 result = ((wxWindow const *)arg1)->GetBestSize();
25685
25686 wxPyEndAllowThreads(__tstate);
25687 if (PyErr_Occurred()) SWIG_fail;
25688 }
25689 {
25690 wxSize * resultptr;
25691 resultptr = new wxSize((wxSize &)(result));
25692 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25693 }
25694 return resultobj;
25695 fail:
25696 return NULL;
25697 }
25698
25699
25700 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25701 PyObject *resultobj;
25702 wxWindow *arg1 = (wxWindow *) 0 ;
25703 int *arg2 = (int *) 0 ;
25704 int *arg3 = (int *) 0 ;
25705 int temp2 ;
25706 int res2 = 0 ;
25707 int temp3 ;
25708 int res3 = 0 ;
25709 PyObject * obj0 = 0 ;
25710 char *kwnames[] = {
25711 (char *) "self", NULL
25712 };
25713
25714 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25715 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25718 if (SWIG_arg_fail(1)) SWIG_fail;
25719 {
25720 PyThreadState* __tstate = wxPyBeginAllowThreads();
25721 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25722
25723 wxPyEndAllowThreads(__tstate);
25724 if (PyErr_Occurred()) SWIG_fail;
25725 }
25726 Py_INCREF(Py_None); resultobj = Py_None;
25727 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25728 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25729 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25730 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25738 PyObject *resultobj;
25739 wxWindow *arg1 = (wxWindow *) 0 ;
25740 PyObject * obj0 = 0 ;
25741 char *kwnames[] = {
25742 (char *) "self", NULL
25743 };
25744
25745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
25746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25747 if (SWIG_arg_fail(1)) SWIG_fail;
25748 {
25749 PyThreadState* __tstate = wxPyBeginAllowThreads();
25750 (arg1)->InvalidateBestSize();
25751
25752 wxPyEndAllowThreads(__tstate);
25753 if (PyErr_Occurred()) SWIG_fail;
25754 }
25755 Py_INCREF(Py_None); resultobj = Py_None;
25756 return resultobj;
25757 fail:
25758 return NULL;
25759 }
25760
25761
25762 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25763 PyObject *resultobj;
25764 wxWindow *arg1 = (wxWindow *) 0 ;
25765 wxSize result;
25766 PyObject * obj0 = 0 ;
25767 char *kwnames[] = {
25768 (char *) "self", NULL
25769 };
25770
25771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
25772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25773 if (SWIG_arg_fail(1)) SWIG_fail;
25774 {
25775 PyThreadState* __tstate = wxPyBeginAllowThreads();
25776 result = ((wxWindow const *)arg1)->GetBestFittingSize();
25777
25778 wxPyEndAllowThreads(__tstate);
25779 if (PyErr_Occurred()) SWIG_fail;
25780 }
25781 {
25782 wxSize * resultptr;
25783 resultptr = new wxSize((wxSize &)(result));
25784 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25785 }
25786 return resultobj;
25787 fail:
25788 return NULL;
25789 }
25790
25791
25792 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25793 PyObject *resultobj;
25794 wxWindow *arg1 = (wxWindow *) 0 ;
25795 wxSize result;
25796 PyObject * obj0 = 0 ;
25797 char *kwnames[] = {
25798 (char *) "self", NULL
25799 };
25800
25801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
25802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25803 if (SWIG_arg_fail(1)) SWIG_fail;
25804 {
25805 PyThreadState* __tstate = wxPyBeginAllowThreads();
25806 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
25807
25808 wxPyEndAllowThreads(__tstate);
25809 if (PyErr_Occurred()) SWIG_fail;
25810 }
25811 {
25812 wxSize * resultptr;
25813 resultptr = new wxSize((wxSize &)(result));
25814 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25815 }
25816 return resultobj;
25817 fail:
25818 return NULL;
25819 }
25820
25821
25822 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
25823 PyObject *resultobj;
25824 wxWindow *arg1 = (wxWindow *) 0 ;
25825 int arg2 = (int) wxBOTH ;
25826 PyObject * obj0 = 0 ;
25827 PyObject * obj1 = 0 ;
25828 char *kwnames[] = {
25829 (char *) "self",(char *) "direction", NULL
25830 };
25831
25832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
25833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25834 if (SWIG_arg_fail(1)) SWIG_fail;
25835 if (obj1) {
25836 {
25837 arg2 = (int)(SWIG_As_int(obj1));
25838 if (SWIG_arg_fail(2)) SWIG_fail;
25839 }
25840 }
25841 {
25842 PyThreadState* __tstate = wxPyBeginAllowThreads();
25843 (arg1)->Center(arg2);
25844
25845 wxPyEndAllowThreads(__tstate);
25846 if (PyErr_Occurred()) SWIG_fail;
25847 }
25848 Py_INCREF(Py_None); resultobj = Py_None;
25849 return resultobj;
25850 fail:
25851 return NULL;
25852 }
25853
25854
25855 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25856 PyObject *resultobj;
25857 wxWindow *arg1 = (wxWindow *) 0 ;
25858 int arg2 = (int) wxBOTH ;
25859 PyObject * obj0 = 0 ;
25860 PyObject * obj1 = 0 ;
25861 char *kwnames[] = {
25862 (char *) "self",(char *) "dir", NULL
25863 };
25864
25865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
25866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25867 if (SWIG_arg_fail(1)) SWIG_fail;
25868 if (obj1) {
25869 {
25870 arg2 = (int)(SWIG_As_int(obj1));
25871 if (SWIG_arg_fail(2)) SWIG_fail;
25872 }
25873 }
25874 {
25875 PyThreadState* __tstate = wxPyBeginAllowThreads();
25876 (arg1)->CenterOnScreen(arg2);
25877
25878 wxPyEndAllowThreads(__tstate);
25879 if (PyErr_Occurred()) SWIG_fail;
25880 }
25881 Py_INCREF(Py_None); resultobj = Py_None;
25882 return resultobj;
25883 fail:
25884 return NULL;
25885 }
25886
25887
25888 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
25889 PyObject *resultobj;
25890 wxWindow *arg1 = (wxWindow *) 0 ;
25891 int arg2 = (int) wxBOTH ;
25892 PyObject * obj0 = 0 ;
25893 PyObject * obj1 = 0 ;
25894 char *kwnames[] = {
25895 (char *) "self",(char *) "dir", NULL
25896 };
25897
25898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
25899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25900 if (SWIG_arg_fail(1)) SWIG_fail;
25901 if (obj1) {
25902 {
25903 arg2 = (int)(SWIG_As_int(obj1));
25904 if (SWIG_arg_fail(2)) SWIG_fail;
25905 }
25906 }
25907 {
25908 PyThreadState* __tstate = wxPyBeginAllowThreads();
25909 (arg1)->CenterOnParent(arg2);
25910
25911 wxPyEndAllowThreads(__tstate);
25912 if (PyErr_Occurred()) SWIG_fail;
25913 }
25914 Py_INCREF(Py_None); resultobj = Py_None;
25915 return resultobj;
25916 fail:
25917 return NULL;
25918 }
25919
25920
25921 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
25922 PyObject *resultobj;
25923 wxWindow *arg1 = (wxWindow *) 0 ;
25924 PyObject * obj0 = 0 ;
25925 char *kwnames[] = {
25926 (char *) "self", NULL
25927 };
25928
25929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
25930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25931 if (SWIG_arg_fail(1)) SWIG_fail;
25932 {
25933 PyThreadState* __tstate = wxPyBeginAllowThreads();
25934 (arg1)->Fit();
25935
25936 wxPyEndAllowThreads(__tstate);
25937 if (PyErr_Occurred()) SWIG_fail;
25938 }
25939 Py_INCREF(Py_None); resultobj = Py_None;
25940 return resultobj;
25941 fail:
25942 return NULL;
25943 }
25944
25945
25946 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
25947 PyObject *resultobj;
25948 wxWindow *arg1 = (wxWindow *) 0 ;
25949 PyObject * obj0 = 0 ;
25950 char *kwnames[] = {
25951 (char *) "self", NULL
25952 };
25953
25954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
25955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25956 if (SWIG_arg_fail(1)) SWIG_fail;
25957 {
25958 PyThreadState* __tstate = wxPyBeginAllowThreads();
25959 (arg1)->FitInside();
25960
25961 wxPyEndAllowThreads(__tstate);
25962 if (PyErr_Occurred()) SWIG_fail;
25963 }
25964 Py_INCREF(Py_None); resultobj = Py_None;
25965 return resultobj;
25966 fail:
25967 return NULL;
25968 }
25969
25970
25971 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
25972 PyObject *resultobj;
25973 wxWindow *arg1 = (wxWindow *) 0 ;
25974 int arg2 ;
25975 int arg3 ;
25976 int arg4 = (int) -1 ;
25977 int arg5 = (int) -1 ;
25978 int arg6 = (int) -1 ;
25979 int arg7 = (int) -1 ;
25980 PyObject * obj0 = 0 ;
25981 PyObject * obj1 = 0 ;
25982 PyObject * obj2 = 0 ;
25983 PyObject * obj3 = 0 ;
25984 PyObject * obj4 = 0 ;
25985 PyObject * obj5 = 0 ;
25986 PyObject * obj6 = 0 ;
25987 char *kwnames[] = {
25988 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
25989 };
25990
25991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25993 if (SWIG_arg_fail(1)) SWIG_fail;
25994 {
25995 arg2 = (int)(SWIG_As_int(obj1));
25996 if (SWIG_arg_fail(2)) SWIG_fail;
25997 }
25998 {
25999 arg3 = (int)(SWIG_As_int(obj2));
26000 if (SWIG_arg_fail(3)) SWIG_fail;
26001 }
26002 if (obj3) {
26003 {
26004 arg4 = (int)(SWIG_As_int(obj3));
26005 if (SWIG_arg_fail(4)) SWIG_fail;
26006 }
26007 }
26008 if (obj4) {
26009 {
26010 arg5 = (int)(SWIG_As_int(obj4));
26011 if (SWIG_arg_fail(5)) SWIG_fail;
26012 }
26013 }
26014 if (obj5) {
26015 {
26016 arg6 = (int)(SWIG_As_int(obj5));
26017 if (SWIG_arg_fail(6)) SWIG_fail;
26018 }
26019 }
26020 if (obj6) {
26021 {
26022 arg7 = (int)(SWIG_As_int(obj6));
26023 if (SWIG_arg_fail(7)) SWIG_fail;
26024 }
26025 }
26026 {
26027 PyThreadState* __tstate = wxPyBeginAllowThreads();
26028 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26029
26030 wxPyEndAllowThreads(__tstate);
26031 if (PyErr_Occurred()) SWIG_fail;
26032 }
26033 Py_INCREF(Py_None); resultobj = Py_None;
26034 return resultobj;
26035 fail:
26036 return NULL;
26037 }
26038
26039
26040 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26041 PyObject *resultobj;
26042 wxWindow *arg1 = (wxWindow *) 0 ;
26043 wxSize *arg2 = 0 ;
26044 wxSize const &arg3_defvalue = wxDefaultSize ;
26045 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26046 wxSize const &arg4_defvalue = wxDefaultSize ;
26047 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26048 wxSize temp2 ;
26049 wxSize temp3 ;
26050 wxSize temp4 ;
26051 PyObject * obj0 = 0 ;
26052 PyObject * obj1 = 0 ;
26053 PyObject * obj2 = 0 ;
26054 PyObject * obj3 = 0 ;
26055 char *kwnames[] = {
26056 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26057 };
26058
26059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26061 if (SWIG_arg_fail(1)) SWIG_fail;
26062 {
26063 arg2 = &temp2;
26064 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26065 }
26066 if (obj2) {
26067 {
26068 arg3 = &temp3;
26069 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26070 }
26071 }
26072 if (obj3) {
26073 {
26074 arg4 = &temp4;
26075 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26076 }
26077 }
26078 {
26079 PyThreadState* __tstate = wxPyBeginAllowThreads();
26080 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26081
26082 wxPyEndAllowThreads(__tstate);
26083 if (PyErr_Occurred()) SWIG_fail;
26084 }
26085 Py_INCREF(Py_None); resultobj = Py_None;
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26093 PyObject *resultobj;
26094 wxWindow *arg1 = (wxWindow *) 0 ;
26095 int arg2 ;
26096 int arg3 ;
26097 int arg4 = (int) -1 ;
26098 int arg5 = (int) -1 ;
26099 PyObject * obj0 = 0 ;
26100 PyObject * obj1 = 0 ;
26101 PyObject * obj2 = 0 ;
26102 PyObject * obj3 = 0 ;
26103 PyObject * obj4 = 0 ;
26104 char *kwnames[] = {
26105 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26106 };
26107
26108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26110 if (SWIG_arg_fail(1)) SWIG_fail;
26111 {
26112 arg2 = (int)(SWIG_As_int(obj1));
26113 if (SWIG_arg_fail(2)) SWIG_fail;
26114 }
26115 {
26116 arg3 = (int)(SWIG_As_int(obj2));
26117 if (SWIG_arg_fail(3)) SWIG_fail;
26118 }
26119 if (obj3) {
26120 {
26121 arg4 = (int)(SWIG_As_int(obj3));
26122 if (SWIG_arg_fail(4)) SWIG_fail;
26123 }
26124 }
26125 if (obj4) {
26126 {
26127 arg5 = (int)(SWIG_As_int(obj4));
26128 if (SWIG_arg_fail(5)) SWIG_fail;
26129 }
26130 }
26131 {
26132 PyThreadState* __tstate = wxPyBeginAllowThreads();
26133 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26134
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 Py_INCREF(Py_None); resultobj = Py_None;
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26146 PyObject *resultobj;
26147 wxWindow *arg1 = (wxWindow *) 0 ;
26148 wxSize *arg2 = 0 ;
26149 wxSize const &arg3_defvalue = wxDefaultSize ;
26150 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26151 wxSize temp2 ;
26152 wxSize temp3 ;
26153 PyObject * obj0 = 0 ;
26154 PyObject * obj1 = 0 ;
26155 PyObject * obj2 = 0 ;
26156 char *kwnames[] = {
26157 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26158 };
26159
26160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26162 if (SWIG_arg_fail(1)) SWIG_fail;
26163 {
26164 arg2 = &temp2;
26165 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26166 }
26167 if (obj2) {
26168 {
26169 arg3 = &temp3;
26170 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26171 }
26172 }
26173 {
26174 PyThreadState* __tstate = wxPyBeginAllowThreads();
26175 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26176
26177 wxPyEndAllowThreads(__tstate);
26178 if (PyErr_Occurred()) SWIG_fail;
26179 }
26180 Py_INCREF(Py_None); resultobj = Py_None;
26181 return resultobj;
26182 fail:
26183 return NULL;
26184 }
26185
26186
26187 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26188 PyObject *resultobj;
26189 wxWindow *arg1 = (wxWindow *) 0 ;
26190 wxSize result;
26191 PyObject * obj0 = 0 ;
26192 char *kwnames[] = {
26193 (char *) "self", NULL
26194 };
26195
26196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26198 if (SWIG_arg_fail(1)) SWIG_fail;
26199 {
26200 PyThreadState* __tstate = wxPyBeginAllowThreads();
26201 result = ((wxWindow const *)arg1)->GetMaxSize();
26202
26203 wxPyEndAllowThreads(__tstate);
26204 if (PyErr_Occurred()) SWIG_fail;
26205 }
26206 {
26207 wxSize * resultptr;
26208 resultptr = new wxSize((wxSize &)(result));
26209 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26210 }
26211 return resultobj;
26212 fail:
26213 return NULL;
26214 }
26215
26216
26217 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26218 PyObject *resultobj;
26219 wxWindow *arg1 = (wxWindow *) 0 ;
26220 wxSize result;
26221 PyObject * obj0 = 0 ;
26222 char *kwnames[] = {
26223 (char *) "self", NULL
26224 };
26225
26226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26228 if (SWIG_arg_fail(1)) SWIG_fail;
26229 {
26230 PyThreadState* __tstate = wxPyBeginAllowThreads();
26231 result = ((wxWindow const *)arg1)->GetMinSize();
26232
26233 wxPyEndAllowThreads(__tstate);
26234 if (PyErr_Occurred()) SWIG_fail;
26235 }
26236 {
26237 wxSize * resultptr;
26238 resultptr = new wxSize((wxSize &)(result));
26239 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26240 }
26241 return resultobj;
26242 fail:
26243 return NULL;
26244 }
26245
26246
26247 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26248 PyObject *resultobj;
26249 wxWindow *arg1 = (wxWindow *) 0 ;
26250 wxSize *arg2 = 0 ;
26251 wxSize temp2 ;
26252 PyObject * obj0 = 0 ;
26253 PyObject * obj1 = 0 ;
26254 char *kwnames[] = {
26255 (char *) "self",(char *) "minSize", NULL
26256 };
26257
26258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26260 if (SWIG_arg_fail(1)) SWIG_fail;
26261 {
26262 arg2 = &temp2;
26263 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26264 }
26265 {
26266 PyThreadState* __tstate = wxPyBeginAllowThreads();
26267 (arg1)->SetMinSize((wxSize const &)*arg2);
26268
26269 wxPyEndAllowThreads(__tstate);
26270 if (PyErr_Occurred()) SWIG_fail;
26271 }
26272 Py_INCREF(Py_None); resultobj = Py_None;
26273 return resultobj;
26274 fail:
26275 return NULL;
26276 }
26277
26278
26279 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26280 PyObject *resultobj;
26281 wxWindow *arg1 = (wxWindow *) 0 ;
26282 wxSize *arg2 = 0 ;
26283 wxSize temp2 ;
26284 PyObject * obj0 = 0 ;
26285 PyObject * obj1 = 0 ;
26286 char *kwnames[] = {
26287 (char *) "self",(char *) "maxSize", NULL
26288 };
26289
26290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26292 if (SWIG_arg_fail(1)) SWIG_fail;
26293 {
26294 arg2 = &temp2;
26295 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26296 }
26297 {
26298 PyThreadState* __tstate = wxPyBeginAllowThreads();
26299 (arg1)->SetMaxSize((wxSize const &)*arg2);
26300
26301 wxPyEndAllowThreads(__tstate);
26302 if (PyErr_Occurred()) SWIG_fail;
26303 }
26304 Py_INCREF(Py_None); resultobj = Py_None;
26305 return resultobj;
26306 fail:
26307 return NULL;
26308 }
26309
26310
26311 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26312 PyObject *resultobj;
26313 wxWindow *arg1 = (wxWindow *) 0 ;
26314 int result;
26315 PyObject * obj0 = 0 ;
26316 char *kwnames[] = {
26317 (char *) "self", NULL
26318 };
26319
26320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26322 if (SWIG_arg_fail(1)) SWIG_fail;
26323 {
26324 PyThreadState* __tstate = wxPyBeginAllowThreads();
26325 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26326
26327 wxPyEndAllowThreads(__tstate);
26328 if (PyErr_Occurred()) SWIG_fail;
26329 }
26330 {
26331 resultobj = SWIG_From_int((int)(result));
26332 }
26333 return resultobj;
26334 fail:
26335 return NULL;
26336 }
26337
26338
26339 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26340 PyObject *resultobj;
26341 wxWindow *arg1 = (wxWindow *) 0 ;
26342 int result;
26343 PyObject * obj0 = 0 ;
26344 char *kwnames[] = {
26345 (char *) "self", NULL
26346 };
26347
26348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26350 if (SWIG_arg_fail(1)) SWIG_fail;
26351 {
26352 PyThreadState* __tstate = wxPyBeginAllowThreads();
26353 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26354
26355 wxPyEndAllowThreads(__tstate);
26356 if (PyErr_Occurred()) SWIG_fail;
26357 }
26358 {
26359 resultobj = SWIG_From_int((int)(result));
26360 }
26361 return resultobj;
26362 fail:
26363 return NULL;
26364 }
26365
26366
26367 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26368 PyObject *resultobj;
26369 wxWindow *arg1 = (wxWindow *) 0 ;
26370 int result;
26371 PyObject * obj0 = 0 ;
26372 char *kwnames[] = {
26373 (char *) "self", NULL
26374 };
26375
26376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26378 if (SWIG_arg_fail(1)) SWIG_fail;
26379 {
26380 PyThreadState* __tstate = wxPyBeginAllowThreads();
26381 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26382
26383 wxPyEndAllowThreads(__tstate);
26384 if (PyErr_Occurred()) SWIG_fail;
26385 }
26386 {
26387 resultobj = SWIG_From_int((int)(result));
26388 }
26389 return resultobj;
26390 fail:
26391 return NULL;
26392 }
26393
26394
26395 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26396 PyObject *resultobj;
26397 wxWindow *arg1 = (wxWindow *) 0 ;
26398 int result;
26399 PyObject * obj0 = 0 ;
26400 char *kwnames[] = {
26401 (char *) "self", NULL
26402 };
26403
26404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26406 if (SWIG_arg_fail(1)) SWIG_fail;
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26410
26411 wxPyEndAllowThreads(__tstate);
26412 if (PyErr_Occurred()) SWIG_fail;
26413 }
26414 {
26415 resultobj = SWIG_From_int((int)(result));
26416 }
26417 return resultobj;
26418 fail:
26419 return NULL;
26420 }
26421
26422
26423 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26424 PyObject *resultobj;
26425 wxWindow *arg1 = (wxWindow *) 0 ;
26426 wxSize *arg2 = 0 ;
26427 wxSize temp2 ;
26428 PyObject * obj0 = 0 ;
26429 PyObject * obj1 = 0 ;
26430 char *kwnames[] = {
26431 (char *) "self",(char *) "size", NULL
26432 };
26433
26434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26436 if (SWIG_arg_fail(1)) SWIG_fail;
26437 {
26438 arg2 = &temp2;
26439 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26440 }
26441 {
26442 PyThreadState* __tstate = wxPyBeginAllowThreads();
26443 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26444
26445 wxPyEndAllowThreads(__tstate);
26446 if (PyErr_Occurred()) SWIG_fail;
26447 }
26448 Py_INCREF(Py_None); resultobj = Py_None;
26449 return resultobj;
26450 fail:
26451 return NULL;
26452 }
26453
26454
26455 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26456 PyObject *resultobj;
26457 wxWindow *arg1 = (wxWindow *) 0 ;
26458 int arg2 ;
26459 int arg3 ;
26460 PyObject * obj0 = 0 ;
26461 PyObject * obj1 = 0 ;
26462 PyObject * obj2 = 0 ;
26463 char *kwnames[] = {
26464 (char *) "self",(char *) "w",(char *) "h", NULL
26465 };
26466
26467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26469 if (SWIG_arg_fail(1)) SWIG_fail;
26470 {
26471 arg2 = (int)(SWIG_As_int(obj1));
26472 if (SWIG_arg_fail(2)) SWIG_fail;
26473 }
26474 {
26475 arg3 = (int)(SWIG_As_int(obj2));
26476 if (SWIG_arg_fail(3)) SWIG_fail;
26477 }
26478 {
26479 PyThreadState* __tstate = wxPyBeginAllowThreads();
26480 (arg1)->SetVirtualSize(arg2,arg3);
26481
26482 wxPyEndAllowThreads(__tstate);
26483 if (PyErr_Occurred()) SWIG_fail;
26484 }
26485 Py_INCREF(Py_None); resultobj = Py_None;
26486 return resultobj;
26487 fail:
26488 return NULL;
26489 }
26490
26491
26492 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26493 PyObject *resultobj;
26494 wxWindow *arg1 = (wxWindow *) 0 ;
26495 wxSize result;
26496 PyObject * obj0 = 0 ;
26497 char *kwnames[] = {
26498 (char *) "self", NULL
26499 };
26500
26501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26503 if (SWIG_arg_fail(1)) SWIG_fail;
26504 {
26505 PyThreadState* __tstate = wxPyBeginAllowThreads();
26506 result = ((wxWindow const *)arg1)->GetVirtualSize();
26507
26508 wxPyEndAllowThreads(__tstate);
26509 if (PyErr_Occurred()) SWIG_fail;
26510 }
26511 {
26512 wxSize * resultptr;
26513 resultptr = new wxSize((wxSize &)(result));
26514 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26515 }
26516 return resultobj;
26517 fail:
26518 return NULL;
26519 }
26520
26521
26522 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26523 PyObject *resultobj;
26524 wxWindow *arg1 = (wxWindow *) 0 ;
26525 int *arg2 = (int *) 0 ;
26526 int *arg3 = (int *) 0 ;
26527 int temp2 ;
26528 int res2 = 0 ;
26529 int temp3 ;
26530 int res3 = 0 ;
26531 PyObject * obj0 = 0 ;
26532 char *kwnames[] = {
26533 (char *) "self", NULL
26534 };
26535
26536 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26537 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26540 if (SWIG_arg_fail(1)) SWIG_fail;
26541 {
26542 PyThreadState* __tstate = wxPyBeginAllowThreads();
26543 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26544
26545 wxPyEndAllowThreads(__tstate);
26546 if (PyErr_Occurred()) SWIG_fail;
26547 }
26548 Py_INCREF(Py_None); resultobj = Py_None;
26549 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26550 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26551 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26552 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26553 return resultobj;
26554 fail:
26555 return NULL;
26556 }
26557
26558
26559 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26560 PyObject *resultobj;
26561 wxWindow *arg1 = (wxWindow *) 0 ;
26562 wxSize result;
26563 PyObject * obj0 = 0 ;
26564 char *kwnames[] = {
26565 (char *) "self", NULL
26566 };
26567
26568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26570 if (SWIG_arg_fail(1)) SWIG_fail;
26571 {
26572 PyThreadState* __tstate = wxPyBeginAllowThreads();
26573 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26574
26575 wxPyEndAllowThreads(__tstate);
26576 if (PyErr_Occurred()) SWIG_fail;
26577 }
26578 {
26579 wxSize * resultptr;
26580 resultptr = new wxSize((wxSize &)(result));
26581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26582 }
26583 return resultobj;
26584 fail:
26585 return NULL;
26586 }
26587
26588
26589 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26590 PyObject *resultobj;
26591 wxWindow *arg1 = (wxWindow *) 0 ;
26592 bool arg2 = (bool) true ;
26593 bool result;
26594 PyObject * obj0 = 0 ;
26595 PyObject * obj1 = 0 ;
26596 char *kwnames[] = {
26597 (char *) "self",(char *) "show", NULL
26598 };
26599
26600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26602 if (SWIG_arg_fail(1)) SWIG_fail;
26603 if (obj1) {
26604 {
26605 arg2 = (bool)(SWIG_As_bool(obj1));
26606 if (SWIG_arg_fail(2)) SWIG_fail;
26607 }
26608 }
26609 {
26610 PyThreadState* __tstate = wxPyBeginAllowThreads();
26611 result = (bool)(arg1)->Show(arg2);
26612
26613 wxPyEndAllowThreads(__tstate);
26614 if (PyErr_Occurred()) SWIG_fail;
26615 }
26616 {
26617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26618 }
26619 return resultobj;
26620 fail:
26621 return NULL;
26622 }
26623
26624
26625 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26626 PyObject *resultobj;
26627 wxWindow *arg1 = (wxWindow *) 0 ;
26628 bool result;
26629 PyObject * obj0 = 0 ;
26630 char *kwnames[] = {
26631 (char *) "self", NULL
26632 };
26633
26634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26636 if (SWIG_arg_fail(1)) SWIG_fail;
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 result = (bool)(arg1)->Hide();
26640
26641 wxPyEndAllowThreads(__tstate);
26642 if (PyErr_Occurred()) SWIG_fail;
26643 }
26644 {
26645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26646 }
26647 return resultobj;
26648 fail:
26649 return NULL;
26650 }
26651
26652
26653 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26654 PyObject *resultobj;
26655 wxWindow *arg1 = (wxWindow *) 0 ;
26656 bool arg2 = (bool) true ;
26657 bool result;
26658 PyObject * obj0 = 0 ;
26659 PyObject * obj1 = 0 ;
26660 char *kwnames[] = {
26661 (char *) "self",(char *) "enable", NULL
26662 };
26663
26664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26666 if (SWIG_arg_fail(1)) SWIG_fail;
26667 if (obj1) {
26668 {
26669 arg2 = (bool)(SWIG_As_bool(obj1));
26670 if (SWIG_arg_fail(2)) SWIG_fail;
26671 }
26672 }
26673 {
26674 PyThreadState* __tstate = wxPyBeginAllowThreads();
26675 result = (bool)(arg1)->Enable(arg2);
26676
26677 wxPyEndAllowThreads(__tstate);
26678 if (PyErr_Occurred()) SWIG_fail;
26679 }
26680 {
26681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26682 }
26683 return resultobj;
26684 fail:
26685 return NULL;
26686 }
26687
26688
26689 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26690 PyObject *resultobj;
26691 wxWindow *arg1 = (wxWindow *) 0 ;
26692 bool result;
26693 PyObject * obj0 = 0 ;
26694 char *kwnames[] = {
26695 (char *) "self", NULL
26696 };
26697
26698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26700 if (SWIG_arg_fail(1)) SWIG_fail;
26701 {
26702 PyThreadState* __tstate = wxPyBeginAllowThreads();
26703 result = (bool)(arg1)->Disable();
26704
26705 wxPyEndAllowThreads(__tstate);
26706 if (PyErr_Occurred()) SWIG_fail;
26707 }
26708 {
26709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26710 }
26711 return resultobj;
26712 fail:
26713 return NULL;
26714 }
26715
26716
26717 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26718 PyObject *resultobj;
26719 wxWindow *arg1 = (wxWindow *) 0 ;
26720 bool result;
26721 PyObject * obj0 = 0 ;
26722 char *kwnames[] = {
26723 (char *) "self", NULL
26724 };
26725
26726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26728 if (SWIG_arg_fail(1)) SWIG_fail;
26729 {
26730 PyThreadState* __tstate = wxPyBeginAllowThreads();
26731 result = (bool)((wxWindow const *)arg1)->IsShown();
26732
26733 wxPyEndAllowThreads(__tstate);
26734 if (PyErr_Occurred()) SWIG_fail;
26735 }
26736 {
26737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26738 }
26739 return resultobj;
26740 fail:
26741 return NULL;
26742 }
26743
26744
26745 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26746 PyObject *resultobj;
26747 wxWindow *arg1 = (wxWindow *) 0 ;
26748 bool result;
26749 PyObject * obj0 = 0 ;
26750 char *kwnames[] = {
26751 (char *) "self", NULL
26752 };
26753
26754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
26755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26756 if (SWIG_arg_fail(1)) SWIG_fail;
26757 {
26758 PyThreadState* __tstate = wxPyBeginAllowThreads();
26759 result = (bool)((wxWindow const *)arg1)->IsEnabled();
26760
26761 wxPyEndAllowThreads(__tstate);
26762 if (PyErr_Occurred()) SWIG_fail;
26763 }
26764 {
26765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26766 }
26767 return resultobj;
26768 fail:
26769 return NULL;
26770 }
26771
26772
26773 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26774 PyObject *resultobj;
26775 wxWindow *arg1 = (wxWindow *) 0 ;
26776 long arg2 ;
26777 PyObject * obj0 = 0 ;
26778 PyObject * obj1 = 0 ;
26779 char *kwnames[] = {
26780 (char *) "self",(char *) "style", NULL
26781 };
26782
26783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
26784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26785 if (SWIG_arg_fail(1)) SWIG_fail;
26786 {
26787 arg2 = (long)(SWIG_As_long(obj1));
26788 if (SWIG_arg_fail(2)) SWIG_fail;
26789 }
26790 {
26791 PyThreadState* __tstate = wxPyBeginAllowThreads();
26792 (arg1)->SetWindowStyleFlag(arg2);
26793
26794 wxPyEndAllowThreads(__tstate);
26795 if (PyErr_Occurred()) SWIG_fail;
26796 }
26797 Py_INCREF(Py_None); resultobj = Py_None;
26798 return resultobj;
26799 fail:
26800 return NULL;
26801 }
26802
26803
26804 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26805 PyObject *resultobj;
26806 wxWindow *arg1 = (wxWindow *) 0 ;
26807 long result;
26808 PyObject * obj0 = 0 ;
26809 char *kwnames[] = {
26810 (char *) "self", NULL
26811 };
26812
26813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
26814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26815 if (SWIG_arg_fail(1)) SWIG_fail;
26816 {
26817 PyThreadState* __tstate = wxPyBeginAllowThreads();
26818 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
26819
26820 wxPyEndAllowThreads(__tstate);
26821 if (PyErr_Occurred()) SWIG_fail;
26822 }
26823 {
26824 resultobj = SWIG_From_long((long)(result));
26825 }
26826 return resultobj;
26827 fail:
26828 return NULL;
26829 }
26830
26831
26832 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26833 PyObject *resultobj;
26834 wxWindow *arg1 = (wxWindow *) 0 ;
26835 int arg2 ;
26836 bool result;
26837 PyObject * obj0 = 0 ;
26838 PyObject * obj1 = 0 ;
26839 char *kwnames[] = {
26840 (char *) "self",(char *) "flag", NULL
26841 };
26842
26843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
26844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26845 if (SWIG_arg_fail(1)) SWIG_fail;
26846 {
26847 arg2 = (int)(SWIG_As_int(obj1));
26848 if (SWIG_arg_fail(2)) SWIG_fail;
26849 }
26850 {
26851 PyThreadState* __tstate = wxPyBeginAllowThreads();
26852 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
26853
26854 wxPyEndAllowThreads(__tstate);
26855 if (PyErr_Occurred()) SWIG_fail;
26856 }
26857 {
26858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26859 }
26860 return resultobj;
26861 fail:
26862 return NULL;
26863 }
26864
26865
26866 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
26867 PyObject *resultobj;
26868 wxWindow *arg1 = (wxWindow *) 0 ;
26869 bool result;
26870 PyObject * obj0 = 0 ;
26871 char *kwnames[] = {
26872 (char *) "self", NULL
26873 };
26874
26875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
26876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26877 if (SWIG_arg_fail(1)) SWIG_fail;
26878 {
26879 PyThreadState* __tstate = wxPyBeginAllowThreads();
26880 result = (bool)((wxWindow const *)arg1)->IsRetained();
26881
26882 wxPyEndAllowThreads(__tstate);
26883 if (PyErr_Occurred()) SWIG_fail;
26884 }
26885 {
26886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26887 }
26888 return resultobj;
26889 fail:
26890 return NULL;
26891 }
26892
26893
26894 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26895 PyObject *resultobj;
26896 wxWindow *arg1 = (wxWindow *) 0 ;
26897 long arg2 ;
26898 PyObject * obj0 = 0 ;
26899 PyObject * obj1 = 0 ;
26900 char *kwnames[] = {
26901 (char *) "self",(char *) "exStyle", NULL
26902 };
26903
26904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
26905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26906 if (SWIG_arg_fail(1)) SWIG_fail;
26907 {
26908 arg2 = (long)(SWIG_As_long(obj1));
26909 if (SWIG_arg_fail(2)) SWIG_fail;
26910 }
26911 {
26912 PyThreadState* __tstate = wxPyBeginAllowThreads();
26913 (arg1)->SetExtraStyle(arg2);
26914
26915 wxPyEndAllowThreads(__tstate);
26916 if (PyErr_Occurred()) SWIG_fail;
26917 }
26918 Py_INCREF(Py_None); resultobj = Py_None;
26919 return resultobj;
26920 fail:
26921 return NULL;
26922 }
26923
26924
26925 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26926 PyObject *resultobj;
26927 wxWindow *arg1 = (wxWindow *) 0 ;
26928 long result;
26929 PyObject * obj0 = 0 ;
26930 char *kwnames[] = {
26931 (char *) "self", NULL
26932 };
26933
26934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
26935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26936 if (SWIG_arg_fail(1)) SWIG_fail;
26937 {
26938 PyThreadState* __tstate = wxPyBeginAllowThreads();
26939 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
26940
26941 wxPyEndAllowThreads(__tstate);
26942 if (PyErr_Occurred()) SWIG_fail;
26943 }
26944 {
26945 resultobj = SWIG_From_long((long)(result));
26946 }
26947 return resultobj;
26948 fail:
26949 return NULL;
26950 }
26951
26952
26953 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
26954 PyObject *resultobj;
26955 wxWindow *arg1 = (wxWindow *) 0 ;
26956 bool arg2 = (bool) true ;
26957 PyObject * obj0 = 0 ;
26958 PyObject * obj1 = 0 ;
26959 char *kwnames[] = {
26960 (char *) "self",(char *) "modal", NULL
26961 };
26962
26963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
26964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26965 if (SWIG_arg_fail(1)) SWIG_fail;
26966 if (obj1) {
26967 {
26968 arg2 = (bool)(SWIG_As_bool(obj1));
26969 if (SWIG_arg_fail(2)) SWIG_fail;
26970 }
26971 }
26972 {
26973 PyThreadState* __tstate = wxPyBeginAllowThreads();
26974 (arg1)->MakeModal(arg2);
26975
26976 wxPyEndAllowThreads(__tstate);
26977 if (PyErr_Occurred()) SWIG_fail;
26978 }
26979 Py_INCREF(Py_None); resultobj = Py_None;
26980 return resultobj;
26981 fail:
26982 return NULL;
26983 }
26984
26985
26986 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26987 PyObject *resultobj;
26988 wxWindow *arg1 = (wxWindow *) 0 ;
26989 bool arg2 ;
26990 PyObject * obj0 = 0 ;
26991 PyObject * obj1 = 0 ;
26992 char *kwnames[] = {
26993 (char *) "self",(char *) "enableTheme", NULL
26994 };
26995
26996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
26997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26998 if (SWIG_arg_fail(1)) SWIG_fail;
26999 {
27000 arg2 = (bool)(SWIG_As_bool(obj1));
27001 if (SWIG_arg_fail(2)) SWIG_fail;
27002 }
27003 {
27004 PyThreadState* __tstate = wxPyBeginAllowThreads();
27005 (arg1)->SetThemeEnabled(arg2);
27006
27007 wxPyEndAllowThreads(__tstate);
27008 if (PyErr_Occurred()) SWIG_fail;
27009 }
27010 Py_INCREF(Py_None); resultobj = Py_None;
27011 return resultobj;
27012 fail:
27013 return NULL;
27014 }
27015
27016
27017 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27018 PyObject *resultobj;
27019 wxWindow *arg1 = (wxWindow *) 0 ;
27020 bool result;
27021 PyObject * obj0 = 0 ;
27022 char *kwnames[] = {
27023 (char *) "self", NULL
27024 };
27025
27026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27028 if (SWIG_arg_fail(1)) SWIG_fail;
27029 {
27030 PyThreadState* __tstate = wxPyBeginAllowThreads();
27031 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27032
27033 wxPyEndAllowThreads(__tstate);
27034 if (PyErr_Occurred()) SWIG_fail;
27035 }
27036 {
27037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27038 }
27039 return resultobj;
27040 fail:
27041 return NULL;
27042 }
27043
27044
27045 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27046 PyObject *resultobj;
27047 wxWindow *arg1 = (wxWindow *) 0 ;
27048 PyObject * obj0 = 0 ;
27049 char *kwnames[] = {
27050 (char *) "self", NULL
27051 };
27052
27053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27055 if (SWIG_arg_fail(1)) SWIG_fail;
27056 {
27057 PyThreadState* __tstate = wxPyBeginAllowThreads();
27058 (arg1)->SetFocus();
27059
27060 wxPyEndAllowThreads(__tstate);
27061 if (PyErr_Occurred()) SWIG_fail;
27062 }
27063 Py_INCREF(Py_None); resultobj = Py_None;
27064 return resultobj;
27065 fail:
27066 return NULL;
27067 }
27068
27069
27070 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27071 PyObject *resultobj;
27072 wxWindow *arg1 = (wxWindow *) 0 ;
27073 PyObject * obj0 = 0 ;
27074 char *kwnames[] = {
27075 (char *) "self", NULL
27076 };
27077
27078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27080 if (SWIG_arg_fail(1)) SWIG_fail;
27081 {
27082 PyThreadState* __tstate = wxPyBeginAllowThreads();
27083 (arg1)->SetFocusFromKbd();
27084
27085 wxPyEndAllowThreads(__tstate);
27086 if (PyErr_Occurred()) SWIG_fail;
27087 }
27088 Py_INCREF(Py_None); resultobj = Py_None;
27089 return resultobj;
27090 fail:
27091 return NULL;
27092 }
27093
27094
27095 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27096 PyObject *resultobj;
27097 wxWindow *result;
27098 char *kwnames[] = {
27099 NULL
27100 };
27101
27102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27103 {
27104 if (!wxPyCheckForApp()) SWIG_fail;
27105 PyThreadState* __tstate = wxPyBeginAllowThreads();
27106 result = (wxWindow *)wxWindow::FindFocus();
27107
27108 wxPyEndAllowThreads(__tstate);
27109 if (PyErr_Occurred()) SWIG_fail;
27110 }
27111 {
27112 resultobj = wxPyMake_wxObject(result, 0);
27113 }
27114 return resultobj;
27115 fail:
27116 return NULL;
27117 }
27118
27119
27120 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27121 PyObject *resultobj;
27122 wxWindow *arg1 = (wxWindow *) 0 ;
27123 bool result;
27124 PyObject * obj0 = 0 ;
27125 char *kwnames[] = {
27126 (char *) "self", NULL
27127 };
27128
27129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27131 if (SWIG_arg_fail(1)) SWIG_fail;
27132 {
27133 PyThreadState* __tstate = wxPyBeginAllowThreads();
27134 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27135
27136 wxPyEndAllowThreads(__tstate);
27137 if (PyErr_Occurred()) SWIG_fail;
27138 }
27139 {
27140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27141 }
27142 return resultobj;
27143 fail:
27144 return NULL;
27145 }
27146
27147
27148 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27149 PyObject *resultobj;
27150 wxWindow *arg1 = (wxWindow *) 0 ;
27151 bool result;
27152 PyObject * obj0 = 0 ;
27153 char *kwnames[] = {
27154 (char *) "self", NULL
27155 };
27156
27157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27159 if (SWIG_arg_fail(1)) SWIG_fail;
27160 {
27161 PyThreadState* __tstate = wxPyBeginAllowThreads();
27162 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27163
27164 wxPyEndAllowThreads(__tstate);
27165 if (PyErr_Occurred()) SWIG_fail;
27166 }
27167 {
27168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27169 }
27170 return resultobj;
27171 fail:
27172 return NULL;
27173 }
27174
27175
27176 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27177 PyObject *resultobj;
27178 wxWindow *arg1 = (wxWindow *) 0 ;
27179 wxWindow *result;
27180 PyObject * obj0 = 0 ;
27181 char *kwnames[] = {
27182 (char *) "self", NULL
27183 };
27184
27185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27187 if (SWIG_arg_fail(1)) SWIG_fail;
27188 {
27189 PyThreadState* __tstate = wxPyBeginAllowThreads();
27190 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27191
27192 wxPyEndAllowThreads(__tstate);
27193 if (PyErr_Occurred()) SWIG_fail;
27194 }
27195 {
27196 resultobj = wxPyMake_wxObject(result, 0);
27197 }
27198 return resultobj;
27199 fail:
27200 return NULL;
27201 }
27202
27203
27204 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27205 PyObject *resultobj;
27206 wxWindow *arg1 = (wxWindow *) 0 ;
27207 wxWindow *arg2 = (wxWindow *) 0 ;
27208 wxWindow *result;
27209 PyObject * obj0 = 0 ;
27210 PyObject * obj1 = 0 ;
27211 char *kwnames[] = {
27212 (char *) "self",(char *) "child", NULL
27213 };
27214
27215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27217 if (SWIG_arg_fail(1)) SWIG_fail;
27218 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27219 if (SWIG_arg_fail(2)) SWIG_fail;
27220 {
27221 PyThreadState* __tstate = wxPyBeginAllowThreads();
27222 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27223
27224 wxPyEndAllowThreads(__tstate);
27225 if (PyErr_Occurred()) SWIG_fail;
27226 }
27227 {
27228 resultobj = wxPyMake_wxObject(result, 0);
27229 }
27230 return resultobj;
27231 fail:
27232 return NULL;
27233 }
27234
27235
27236 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27237 PyObject *resultobj;
27238 wxWindow *arg1 = (wxWindow *) 0 ;
27239 wxWindow *arg2 = (wxWindow *) 0 ;
27240 PyObject * obj0 = 0 ;
27241 PyObject * obj1 = 0 ;
27242 char *kwnames[] = {
27243 (char *) "self",(char *) "win", NULL
27244 };
27245
27246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27248 if (SWIG_arg_fail(1)) SWIG_fail;
27249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27250 if (SWIG_arg_fail(2)) SWIG_fail;
27251 {
27252 PyThreadState* __tstate = wxPyBeginAllowThreads();
27253 (arg1)->SetTmpDefaultItem(arg2);
27254
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 Py_INCREF(Py_None); resultobj = Py_None;
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27266 PyObject *resultobj;
27267 wxWindow *arg1 = (wxWindow *) 0 ;
27268 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27269 bool result;
27270 PyObject * obj0 = 0 ;
27271 PyObject * obj1 = 0 ;
27272 char *kwnames[] = {
27273 (char *) "self",(char *) "flags", NULL
27274 };
27275
27276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27278 if (SWIG_arg_fail(1)) SWIG_fail;
27279 if (obj1) {
27280 {
27281 arg2 = (int)(SWIG_As_int(obj1));
27282 if (SWIG_arg_fail(2)) SWIG_fail;
27283 }
27284 }
27285 {
27286 PyThreadState* __tstate = wxPyBeginAllowThreads();
27287 result = (bool)(arg1)->Navigate(arg2);
27288
27289 wxPyEndAllowThreads(__tstate);
27290 if (PyErr_Occurred()) SWIG_fail;
27291 }
27292 {
27293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27294 }
27295 return resultobj;
27296 fail:
27297 return NULL;
27298 }
27299
27300
27301 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27302 PyObject *resultobj;
27303 wxWindow *arg1 = (wxWindow *) 0 ;
27304 wxWindow *arg2 = (wxWindow *) 0 ;
27305 PyObject * obj0 = 0 ;
27306 PyObject * obj1 = 0 ;
27307 char *kwnames[] = {
27308 (char *) "self",(char *) "win", NULL
27309 };
27310
27311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27313 if (SWIG_arg_fail(1)) SWIG_fail;
27314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27315 if (SWIG_arg_fail(2)) SWIG_fail;
27316 {
27317 PyThreadState* __tstate = wxPyBeginAllowThreads();
27318 (arg1)->MoveAfterInTabOrder(arg2);
27319
27320 wxPyEndAllowThreads(__tstate);
27321 if (PyErr_Occurred()) SWIG_fail;
27322 }
27323 Py_INCREF(Py_None); resultobj = Py_None;
27324 return resultobj;
27325 fail:
27326 return NULL;
27327 }
27328
27329
27330 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27331 PyObject *resultobj;
27332 wxWindow *arg1 = (wxWindow *) 0 ;
27333 wxWindow *arg2 = (wxWindow *) 0 ;
27334 PyObject * obj0 = 0 ;
27335 PyObject * obj1 = 0 ;
27336 char *kwnames[] = {
27337 (char *) "self",(char *) "win", NULL
27338 };
27339
27340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27342 if (SWIG_arg_fail(1)) SWIG_fail;
27343 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27344 if (SWIG_arg_fail(2)) SWIG_fail;
27345 {
27346 PyThreadState* __tstate = wxPyBeginAllowThreads();
27347 (arg1)->MoveBeforeInTabOrder(arg2);
27348
27349 wxPyEndAllowThreads(__tstate);
27350 if (PyErr_Occurred()) SWIG_fail;
27351 }
27352 Py_INCREF(Py_None); resultobj = Py_None;
27353 return resultobj;
27354 fail:
27355 return NULL;
27356 }
27357
27358
27359 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27360 PyObject *resultobj;
27361 wxWindow *arg1 = (wxWindow *) 0 ;
27362 PyObject *result;
27363 PyObject * obj0 = 0 ;
27364 char *kwnames[] = {
27365 (char *) "self", NULL
27366 };
27367
27368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27370 if (SWIG_arg_fail(1)) SWIG_fail;
27371 {
27372 PyThreadState* __tstate = wxPyBeginAllowThreads();
27373 result = (PyObject *)wxWindow_GetChildren(arg1);
27374
27375 wxPyEndAllowThreads(__tstate);
27376 if (PyErr_Occurred()) SWIG_fail;
27377 }
27378 resultobj = result;
27379 return resultobj;
27380 fail:
27381 return NULL;
27382 }
27383
27384
27385 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27386 PyObject *resultobj;
27387 wxWindow *arg1 = (wxWindow *) 0 ;
27388 wxWindow *result;
27389 PyObject * obj0 = 0 ;
27390 char *kwnames[] = {
27391 (char *) "self", NULL
27392 };
27393
27394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27396 if (SWIG_arg_fail(1)) SWIG_fail;
27397 {
27398 PyThreadState* __tstate = wxPyBeginAllowThreads();
27399 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27400
27401 wxPyEndAllowThreads(__tstate);
27402 if (PyErr_Occurred()) SWIG_fail;
27403 }
27404 {
27405 resultobj = wxPyMake_wxObject(result, 0);
27406 }
27407 return resultobj;
27408 fail:
27409 return NULL;
27410 }
27411
27412
27413 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27414 PyObject *resultobj;
27415 wxWindow *arg1 = (wxWindow *) 0 ;
27416 wxWindow *result;
27417 PyObject * obj0 = 0 ;
27418 char *kwnames[] = {
27419 (char *) "self", NULL
27420 };
27421
27422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27424 if (SWIG_arg_fail(1)) SWIG_fail;
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27428
27429 wxPyEndAllowThreads(__tstate);
27430 if (PyErr_Occurred()) SWIG_fail;
27431 }
27432 {
27433 resultobj = wxPyMake_wxObject(result, 0);
27434 }
27435 return resultobj;
27436 fail:
27437 return NULL;
27438 }
27439
27440
27441 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27442 PyObject *resultobj;
27443 wxWindow *arg1 = (wxWindow *) 0 ;
27444 bool result;
27445 PyObject * obj0 = 0 ;
27446 char *kwnames[] = {
27447 (char *) "self", NULL
27448 };
27449
27450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27452 if (SWIG_arg_fail(1)) SWIG_fail;
27453 {
27454 PyThreadState* __tstate = wxPyBeginAllowThreads();
27455 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27456
27457 wxPyEndAllowThreads(__tstate);
27458 if (PyErr_Occurred()) SWIG_fail;
27459 }
27460 {
27461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27462 }
27463 return resultobj;
27464 fail:
27465 return NULL;
27466 }
27467
27468
27469 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27470 PyObject *resultobj;
27471 wxWindow *arg1 = (wxWindow *) 0 ;
27472 wxWindow *arg2 = (wxWindow *) 0 ;
27473 bool result;
27474 PyObject * obj0 = 0 ;
27475 PyObject * obj1 = 0 ;
27476 char *kwnames[] = {
27477 (char *) "self",(char *) "newParent", NULL
27478 };
27479
27480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27482 if (SWIG_arg_fail(1)) SWIG_fail;
27483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27484 if (SWIG_arg_fail(2)) SWIG_fail;
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = (bool)(arg1)->Reparent(arg2);
27488
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 {
27493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27494 }
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27502 PyObject *resultobj;
27503 wxWindow *arg1 = (wxWindow *) 0 ;
27504 wxWindow *arg2 = (wxWindow *) 0 ;
27505 PyObject * obj0 = 0 ;
27506 PyObject * obj1 = 0 ;
27507 char *kwnames[] = {
27508 (char *) "self",(char *) "child", NULL
27509 };
27510
27511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27513 if (SWIG_arg_fail(1)) SWIG_fail;
27514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27515 if (SWIG_arg_fail(2)) SWIG_fail;
27516 {
27517 PyThreadState* __tstate = wxPyBeginAllowThreads();
27518 (arg1)->AddChild(arg2);
27519
27520 wxPyEndAllowThreads(__tstate);
27521 if (PyErr_Occurred()) SWIG_fail;
27522 }
27523 Py_INCREF(Py_None); resultobj = Py_None;
27524 return resultobj;
27525 fail:
27526 return NULL;
27527 }
27528
27529
27530 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27531 PyObject *resultobj;
27532 wxWindow *arg1 = (wxWindow *) 0 ;
27533 wxWindow *arg2 = (wxWindow *) 0 ;
27534 PyObject * obj0 = 0 ;
27535 PyObject * obj1 = 0 ;
27536 char *kwnames[] = {
27537 (char *) "self",(char *) "child", NULL
27538 };
27539
27540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27542 if (SWIG_arg_fail(1)) SWIG_fail;
27543 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27544 if (SWIG_arg_fail(2)) SWIG_fail;
27545 {
27546 PyThreadState* __tstate = wxPyBeginAllowThreads();
27547 (arg1)->RemoveChild(arg2);
27548
27549 wxPyEndAllowThreads(__tstate);
27550 if (PyErr_Occurred()) SWIG_fail;
27551 }
27552 Py_INCREF(Py_None); resultobj = Py_None;
27553 return resultobj;
27554 fail:
27555 return NULL;
27556 }
27557
27558
27559 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27560 PyObject *resultobj;
27561 wxWindow *arg1 = (wxWindow *) 0 ;
27562 long arg2 ;
27563 wxWindow *result;
27564 PyObject * obj0 = 0 ;
27565 PyObject * obj1 = 0 ;
27566 char *kwnames[] = {
27567 (char *) "self",(char *) "winid", NULL
27568 };
27569
27570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27572 if (SWIG_arg_fail(1)) SWIG_fail;
27573 {
27574 arg2 = (long)(SWIG_As_long(obj1));
27575 if (SWIG_arg_fail(2)) SWIG_fail;
27576 }
27577 {
27578 PyThreadState* __tstate = wxPyBeginAllowThreads();
27579 result = (wxWindow *)(arg1)->FindWindow(arg2);
27580
27581 wxPyEndAllowThreads(__tstate);
27582 if (PyErr_Occurred()) SWIG_fail;
27583 }
27584 {
27585 resultobj = wxPyMake_wxObject(result, 0);
27586 }
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj;
27595 wxWindow *arg1 = (wxWindow *) 0 ;
27596 wxString *arg2 = 0 ;
27597 wxWindow *result;
27598 bool temp2 = false ;
27599 PyObject * obj0 = 0 ;
27600 PyObject * obj1 = 0 ;
27601 char *kwnames[] = {
27602 (char *) "self",(char *) "name", NULL
27603 };
27604
27605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27607 if (SWIG_arg_fail(1)) SWIG_fail;
27608 {
27609 arg2 = wxString_in_helper(obj1);
27610 if (arg2 == NULL) SWIG_fail;
27611 temp2 = true;
27612 }
27613 {
27614 PyThreadState* __tstate = wxPyBeginAllowThreads();
27615 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27616
27617 wxPyEndAllowThreads(__tstate);
27618 if (PyErr_Occurred()) SWIG_fail;
27619 }
27620 {
27621 resultobj = wxPyMake_wxObject(result, 0);
27622 }
27623 {
27624 if (temp2)
27625 delete arg2;
27626 }
27627 return resultobj;
27628 fail:
27629 {
27630 if (temp2)
27631 delete arg2;
27632 }
27633 return NULL;
27634 }
27635
27636
27637 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27638 PyObject *resultobj;
27639 wxWindow *arg1 = (wxWindow *) 0 ;
27640 wxEvtHandler *result;
27641 PyObject * obj0 = 0 ;
27642 char *kwnames[] = {
27643 (char *) "self", NULL
27644 };
27645
27646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27648 if (SWIG_arg_fail(1)) SWIG_fail;
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27652
27653 wxPyEndAllowThreads(__tstate);
27654 if (PyErr_Occurred()) SWIG_fail;
27655 }
27656 {
27657 resultobj = wxPyMake_wxObject(result, 0);
27658 }
27659 return resultobj;
27660 fail:
27661 return NULL;
27662 }
27663
27664
27665 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27666 PyObject *resultobj;
27667 wxWindow *arg1 = (wxWindow *) 0 ;
27668 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27669 PyObject * obj0 = 0 ;
27670 PyObject * obj1 = 0 ;
27671 char *kwnames[] = {
27672 (char *) "self",(char *) "handler", NULL
27673 };
27674
27675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27677 if (SWIG_arg_fail(1)) SWIG_fail;
27678 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27679 if (SWIG_arg_fail(2)) SWIG_fail;
27680 {
27681 PyThreadState* __tstate = wxPyBeginAllowThreads();
27682 (arg1)->SetEventHandler(arg2);
27683
27684 wxPyEndAllowThreads(__tstate);
27685 if (PyErr_Occurred()) SWIG_fail;
27686 }
27687 Py_INCREF(Py_None); resultobj = Py_None;
27688 return resultobj;
27689 fail:
27690 return NULL;
27691 }
27692
27693
27694 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27695 PyObject *resultobj;
27696 wxWindow *arg1 = (wxWindow *) 0 ;
27697 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27698 PyObject * obj0 = 0 ;
27699 PyObject * obj1 = 0 ;
27700 char *kwnames[] = {
27701 (char *) "self",(char *) "handler", NULL
27702 };
27703
27704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27706 if (SWIG_arg_fail(1)) SWIG_fail;
27707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27708 if (SWIG_arg_fail(2)) SWIG_fail;
27709 {
27710 PyThreadState* __tstate = wxPyBeginAllowThreads();
27711 (arg1)->PushEventHandler(arg2);
27712
27713 wxPyEndAllowThreads(__tstate);
27714 if (PyErr_Occurred()) SWIG_fail;
27715 }
27716 Py_INCREF(Py_None); resultobj = Py_None;
27717 return resultobj;
27718 fail:
27719 return NULL;
27720 }
27721
27722
27723 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27724 PyObject *resultobj;
27725 wxWindow *arg1 = (wxWindow *) 0 ;
27726 bool arg2 = (bool) false ;
27727 wxEvtHandler *result;
27728 PyObject * obj0 = 0 ;
27729 PyObject * obj1 = 0 ;
27730 char *kwnames[] = {
27731 (char *) "self",(char *) "deleteHandler", NULL
27732 };
27733
27734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
27735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27736 if (SWIG_arg_fail(1)) SWIG_fail;
27737 if (obj1) {
27738 {
27739 arg2 = (bool)(SWIG_As_bool(obj1));
27740 if (SWIG_arg_fail(2)) SWIG_fail;
27741 }
27742 }
27743 {
27744 PyThreadState* __tstate = wxPyBeginAllowThreads();
27745 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
27746
27747 wxPyEndAllowThreads(__tstate);
27748 if (PyErr_Occurred()) SWIG_fail;
27749 }
27750 {
27751 resultobj = wxPyMake_wxObject(result, 0);
27752 }
27753 return resultobj;
27754 fail:
27755 return NULL;
27756 }
27757
27758
27759 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27760 PyObject *resultobj;
27761 wxWindow *arg1 = (wxWindow *) 0 ;
27762 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27763 bool result;
27764 PyObject * obj0 = 0 ;
27765 PyObject * obj1 = 0 ;
27766 char *kwnames[] = {
27767 (char *) "self",(char *) "handler", NULL
27768 };
27769
27770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
27771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27772 if (SWIG_arg_fail(1)) SWIG_fail;
27773 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27774 if (SWIG_arg_fail(2)) SWIG_fail;
27775 {
27776 PyThreadState* __tstate = wxPyBeginAllowThreads();
27777 result = (bool)(arg1)->RemoveEventHandler(arg2);
27778
27779 wxPyEndAllowThreads(__tstate);
27780 if (PyErr_Occurred()) SWIG_fail;
27781 }
27782 {
27783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27784 }
27785 return resultobj;
27786 fail:
27787 return NULL;
27788 }
27789
27790
27791 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27792 PyObject *resultobj;
27793 wxWindow *arg1 = (wxWindow *) 0 ;
27794 wxValidator *arg2 = 0 ;
27795 PyObject * obj0 = 0 ;
27796 PyObject * obj1 = 0 ;
27797 char *kwnames[] = {
27798 (char *) "self",(char *) "validator", NULL
27799 };
27800
27801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
27802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27803 if (SWIG_arg_fail(1)) SWIG_fail;
27804 {
27805 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
27806 if (SWIG_arg_fail(2)) SWIG_fail;
27807 if (arg2 == NULL) {
27808 SWIG_null_ref("wxValidator");
27809 }
27810 if (SWIG_arg_fail(2)) SWIG_fail;
27811 }
27812 {
27813 PyThreadState* __tstate = wxPyBeginAllowThreads();
27814 (arg1)->SetValidator((wxValidator const &)*arg2);
27815
27816 wxPyEndAllowThreads(__tstate);
27817 if (PyErr_Occurred()) SWIG_fail;
27818 }
27819 Py_INCREF(Py_None); resultobj = Py_None;
27820 return resultobj;
27821 fail:
27822 return NULL;
27823 }
27824
27825
27826 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27827 PyObject *resultobj;
27828 wxWindow *arg1 = (wxWindow *) 0 ;
27829 wxValidator *result;
27830 PyObject * obj0 = 0 ;
27831 char *kwnames[] = {
27832 (char *) "self", NULL
27833 };
27834
27835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
27836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27837 if (SWIG_arg_fail(1)) SWIG_fail;
27838 {
27839 PyThreadState* __tstate = wxPyBeginAllowThreads();
27840 result = (wxValidator *)(arg1)->GetValidator();
27841
27842 wxPyEndAllowThreads(__tstate);
27843 if (PyErr_Occurred()) SWIG_fail;
27844 }
27845 {
27846 resultobj = wxPyMake_wxObject(result, 0);
27847 }
27848 return resultobj;
27849 fail:
27850 return NULL;
27851 }
27852
27853
27854 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
27855 PyObject *resultobj;
27856 wxWindow *arg1 = (wxWindow *) 0 ;
27857 bool result;
27858 PyObject * obj0 = 0 ;
27859 char *kwnames[] = {
27860 (char *) "self", NULL
27861 };
27862
27863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
27864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27865 if (SWIG_arg_fail(1)) SWIG_fail;
27866 {
27867 PyThreadState* __tstate = wxPyBeginAllowThreads();
27868 result = (bool)(arg1)->Validate();
27869
27870 wxPyEndAllowThreads(__tstate);
27871 if (PyErr_Occurred()) SWIG_fail;
27872 }
27873 {
27874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27875 }
27876 return resultobj;
27877 fail:
27878 return NULL;
27879 }
27880
27881
27882 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27883 PyObject *resultobj;
27884 wxWindow *arg1 = (wxWindow *) 0 ;
27885 bool result;
27886 PyObject * obj0 = 0 ;
27887 char *kwnames[] = {
27888 (char *) "self", NULL
27889 };
27890
27891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
27892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27893 if (SWIG_arg_fail(1)) SWIG_fail;
27894 {
27895 PyThreadState* __tstate = wxPyBeginAllowThreads();
27896 result = (bool)(arg1)->TransferDataToWindow();
27897
27898 wxPyEndAllowThreads(__tstate);
27899 if (PyErr_Occurred()) SWIG_fail;
27900 }
27901 {
27902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27903 }
27904 return resultobj;
27905 fail:
27906 return NULL;
27907 }
27908
27909
27910 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27911 PyObject *resultobj;
27912 wxWindow *arg1 = (wxWindow *) 0 ;
27913 bool result;
27914 PyObject * obj0 = 0 ;
27915 char *kwnames[] = {
27916 (char *) "self", NULL
27917 };
27918
27919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
27920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27921 if (SWIG_arg_fail(1)) SWIG_fail;
27922 {
27923 PyThreadState* __tstate = wxPyBeginAllowThreads();
27924 result = (bool)(arg1)->TransferDataFromWindow();
27925
27926 wxPyEndAllowThreads(__tstate);
27927 if (PyErr_Occurred()) SWIG_fail;
27928 }
27929 {
27930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27931 }
27932 return resultobj;
27933 fail:
27934 return NULL;
27935 }
27936
27937
27938 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
27939 PyObject *resultobj;
27940 wxWindow *arg1 = (wxWindow *) 0 ;
27941 PyObject * obj0 = 0 ;
27942 char *kwnames[] = {
27943 (char *) "self", NULL
27944 };
27945
27946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
27947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27948 if (SWIG_arg_fail(1)) SWIG_fail;
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 (arg1)->InitDialog();
27952
27953 wxPyEndAllowThreads(__tstate);
27954 if (PyErr_Occurred()) SWIG_fail;
27955 }
27956 Py_INCREF(Py_None); resultobj = Py_None;
27957 return resultobj;
27958 fail:
27959 return NULL;
27960 }
27961
27962
27963 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
27964 PyObject *resultobj;
27965 wxWindow *arg1 = (wxWindow *) 0 ;
27966 wxAcceleratorTable *arg2 = 0 ;
27967 PyObject * obj0 = 0 ;
27968 PyObject * obj1 = 0 ;
27969 char *kwnames[] = {
27970 (char *) "self",(char *) "accel", NULL
27971 };
27972
27973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
27974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27975 if (SWIG_arg_fail(1)) SWIG_fail;
27976 {
27977 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
27978 if (SWIG_arg_fail(2)) SWIG_fail;
27979 if (arg2 == NULL) {
27980 SWIG_null_ref("wxAcceleratorTable");
27981 }
27982 if (SWIG_arg_fail(2)) SWIG_fail;
27983 }
27984 {
27985 PyThreadState* __tstate = wxPyBeginAllowThreads();
27986 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
27987
27988 wxPyEndAllowThreads(__tstate);
27989 if (PyErr_Occurred()) SWIG_fail;
27990 }
27991 Py_INCREF(Py_None); resultobj = Py_None;
27992 return resultobj;
27993 fail:
27994 return NULL;
27995 }
27996
27997
27998 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
27999 PyObject *resultobj;
28000 wxWindow *arg1 = (wxWindow *) 0 ;
28001 wxAcceleratorTable *result;
28002 PyObject * obj0 = 0 ;
28003 char *kwnames[] = {
28004 (char *) "self", NULL
28005 };
28006
28007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28009 if (SWIG_arg_fail(1)) SWIG_fail;
28010 {
28011 PyThreadState* __tstate = wxPyBeginAllowThreads();
28012 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28013
28014 wxPyEndAllowThreads(__tstate);
28015 if (PyErr_Occurred()) SWIG_fail;
28016 }
28017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28018 return resultobj;
28019 fail:
28020 return NULL;
28021 }
28022
28023
28024 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28025 PyObject *resultobj;
28026 wxWindow *arg1 = (wxWindow *) 0 ;
28027 int arg2 ;
28028 int arg3 ;
28029 int arg4 ;
28030 bool result;
28031 PyObject * obj0 = 0 ;
28032 PyObject * obj1 = 0 ;
28033 PyObject * obj2 = 0 ;
28034 PyObject * obj3 = 0 ;
28035 char *kwnames[] = {
28036 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28037 };
28038
28039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28041 if (SWIG_arg_fail(1)) SWIG_fail;
28042 {
28043 arg2 = (int)(SWIG_As_int(obj1));
28044 if (SWIG_arg_fail(2)) SWIG_fail;
28045 }
28046 {
28047 arg3 = (int)(SWIG_As_int(obj2));
28048 if (SWIG_arg_fail(3)) SWIG_fail;
28049 }
28050 {
28051 arg4 = (int)(SWIG_As_int(obj3));
28052 if (SWIG_arg_fail(4)) SWIG_fail;
28053 }
28054 {
28055 PyThreadState* __tstate = wxPyBeginAllowThreads();
28056 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28057
28058 wxPyEndAllowThreads(__tstate);
28059 if (PyErr_Occurred()) SWIG_fail;
28060 }
28061 {
28062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28063 }
28064 return resultobj;
28065 fail:
28066 return NULL;
28067 }
28068
28069
28070 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28071 PyObject *resultobj;
28072 wxWindow *arg1 = (wxWindow *) 0 ;
28073 int arg2 ;
28074 bool result;
28075 PyObject * obj0 = 0 ;
28076 PyObject * obj1 = 0 ;
28077 char *kwnames[] = {
28078 (char *) "self",(char *) "hotkeyId", NULL
28079 };
28080
28081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28083 if (SWIG_arg_fail(1)) SWIG_fail;
28084 {
28085 arg2 = (int)(SWIG_As_int(obj1));
28086 if (SWIG_arg_fail(2)) SWIG_fail;
28087 }
28088 {
28089 PyThreadState* __tstate = wxPyBeginAllowThreads();
28090 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28091
28092 wxPyEndAllowThreads(__tstate);
28093 if (PyErr_Occurred()) SWIG_fail;
28094 }
28095 {
28096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28097 }
28098 return resultobj;
28099 fail:
28100 return NULL;
28101 }
28102
28103
28104 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28105 PyObject *resultobj;
28106 wxWindow *arg1 = (wxWindow *) 0 ;
28107 wxPoint *arg2 = 0 ;
28108 wxPoint result;
28109 wxPoint temp2 ;
28110 PyObject * obj0 = 0 ;
28111 PyObject * obj1 = 0 ;
28112 char *kwnames[] = {
28113 (char *) "self",(char *) "pt", NULL
28114 };
28115
28116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28118 if (SWIG_arg_fail(1)) SWIG_fail;
28119 {
28120 arg2 = &temp2;
28121 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28122 }
28123 {
28124 PyThreadState* __tstate = wxPyBeginAllowThreads();
28125 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28126
28127 wxPyEndAllowThreads(__tstate);
28128 if (PyErr_Occurred()) SWIG_fail;
28129 }
28130 {
28131 wxPoint * resultptr;
28132 resultptr = new wxPoint((wxPoint &)(result));
28133 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28134 }
28135 return resultobj;
28136 fail:
28137 return NULL;
28138 }
28139
28140
28141 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28142 PyObject *resultobj;
28143 wxWindow *arg1 = (wxWindow *) 0 ;
28144 wxSize *arg2 = 0 ;
28145 wxSize result;
28146 wxSize temp2 ;
28147 PyObject * obj0 = 0 ;
28148 PyObject * obj1 = 0 ;
28149 char *kwnames[] = {
28150 (char *) "self",(char *) "sz", NULL
28151 };
28152
28153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28155 if (SWIG_arg_fail(1)) SWIG_fail;
28156 {
28157 arg2 = &temp2;
28158 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28159 }
28160 {
28161 PyThreadState* __tstate = wxPyBeginAllowThreads();
28162 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28163
28164 wxPyEndAllowThreads(__tstate);
28165 if (PyErr_Occurred()) SWIG_fail;
28166 }
28167 {
28168 wxSize * resultptr;
28169 resultptr = new wxSize((wxSize &)(result));
28170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28171 }
28172 return resultobj;
28173 fail:
28174 return NULL;
28175 }
28176
28177
28178 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28179 PyObject *resultobj;
28180 wxWindow *arg1 = (wxWindow *) 0 ;
28181 wxPoint *arg2 = 0 ;
28182 wxPoint result;
28183 wxPoint temp2 ;
28184 PyObject * obj0 = 0 ;
28185 PyObject * obj1 = 0 ;
28186 char *kwnames[] = {
28187 (char *) "self",(char *) "pt", NULL
28188 };
28189
28190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28192 if (SWIG_arg_fail(1)) SWIG_fail;
28193 {
28194 arg2 = &temp2;
28195 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28196 }
28197 {
28198 PyThreadState* __tstate = wxPyBeginAllowThreads();
28199 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28200
28201 wxPyEndAllowThreads(__tstate);
28202 if (PyErr_Occurred()) SWIG_fail;
28203 }
28204 {
28205 wxPoint * resultptr;
28206 resultptr = new wxPoint((wxPoint &)(result));
28207 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28208 }
28209 return resultobj;
28210 fail:
28211 return NULL;
28212 }
28213
28214
28215 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28216 PyObject *resultobj;
28217 wxWindow *arg1 = (wxWindow *) 0 ;
28218 wxSize *arg2 = 0 ;
28219 wxSize result;
28220 wxSize temp2 ;
28221 PyObject * obj0 = 0 ;
28222 PyObject * obj1 = 0 ;
28223 char *kwnames[] = {
28224 (char *) "self",(char *) "sz", NULL
28225 };
28226
28227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28229 if (SWIG_arg_fail(1)) SWIG_fail;
28230 {
28231 arg2 = &temp2;
28232 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28233 }
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28237
28238 wxPyEndAllowThreads(__tstate);
28239 if (PyErr_Occurred()) SWIG_fail;
28240 }
28241 {
28242 wxSize * resultptr;
28243 resultptr = new wxSize((wxSize &)(result));
28244 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28245 }
28246 return resultobj;
28247 fail:
28248 return NULL;
28249 }
28250
28251
28252 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28253 PyObject *resultobj;
28254 wxWindow *arg1 = (wxWindow *) 0 ;
28255 wxPoint *arg2 = 0 ;
28256 wxPoint result;
28257 wxPoint temp2 ;
28258 PyObject * obj0 = 0 ;
28259 PyObject * obj1 = 0 ;
28260 char *kwnames[] = {
28261 (char *) "self",(char *) "pt", NULL
28262 };
28263
28264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28266 if (SWIG_arg_fail(1)) SWIG_fail;
28267 {
28268 arg2 = &temp2;
28269 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28270 }
28271 {
28272 PyThreadState* __tstate = wxPyBeginAllowThreads();
28273 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28274
28275 wxPyEndAllowThreads(__tstate);
28276 if (PyErr_Occurred()) SWIG_fail;
28277 }
28278 {
28279 wxPoint * resultptr;
28280 resultptr = new wxPoint((wxPoint &)(result));
28281 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28282 }
28283 return resultobj;
28284 fail:
28285 return NULL;
28286 }
28287
28288
28289 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28290 PyObject *resultobj;
28291 wxWindow *arg1 = (wxWindow *) 0 ;
28292 wxSize *arg2 = 0 ;
28293 wxSize result;
28294 wxSize temp2 ;
28295 PyObject * obj0 = 0 ;
28296 PyObject * obj1 = 0 ;
28297 char *kwnames[] = {
28298 (char *) "self",(char *) "sz", NULL
28299 };
28300
28301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28303 if (SWIG_arg_fail(1)) SWIG_fail;
28304 {
28305 arg2 = &temp2;
28306 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28307 }
28308 {
28309 PyThreadState* __tstate = wxPyBeginAllowThreads();
28310 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28311
28312 wxPyEndAllowThreads(__tstate);
28313 if (PyErr_Occurred()) SWIG_fail;
28314 }
28315 {
28316 wxSize * resultptr;
28317 resultptr = new wxSize((wxSize &)(result));
28318 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28319 }
28320 return resultobj;
28321 fail:
28322 return NULL;
28323 }
28324
28325
28326 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28327 PyObject *resultobj;
28328 wxWindow *arg1 = (wxWindow *) 0 ;
28329 int arg2 ;
28330 int arg3 ;
28331 PyObject * obj0 = 0 ;
28332 PyObject * obj1 = 0 ;
28333 PyObject * obj2 = 0 ;
28334 char *kwnames[] = {
28335 (char *) "self",(char *) "x",(char *) "y", NULL
28336 };
28337
28338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28340 if (SWIG_arg_fail(1)) SWIG_fail;
28341 {
28342 arg2 = (int)(SWIG_As_int(obj1));
28343 if (SWIG_arg_fail(2)) SWIG_fail;
28344 }
28345 {
28346 arg3 = (int)(SWIG_As_int(obj2));
28347 if (SWIG_arg_fail(3)) SWIG_fail;
28348 }
28349 {
28350 PyThreadState* __tstate = wxPyBeginAllowThreads();
28351 (arg1)->WarpPointer(arg2,arg3);
28352
28353 wxPyEndAllowThreads(__tstate);
28354 if (PyErr_Occurred()) SWIG_fail;
28355 }
28356 Py_INCREF(Py_None); resultobj = Py_None;
28357 return resultobj;
28358 fail:
28359 return NULL;
28360 }
28361
28362
28363 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28364 PyObject *resultobj;
28365 wxWindow *arg1 = (wxWindow *) 0 ;
28366 PyObject * obj0 = 0 ;
28367 char *kwnames[] = {
28368 (char *) "self", NULL
28369 };
28370
28371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28373 if (SWIG_arg_fail(1)) SWIG_fail;
28374 {
28375 PyThreadState* __tstate = wxPyBeginAllowThreads();
28376 (arg1)->CaptureMouse();
28377
28378 wxPyEndAllowThreads(__tstate);
28379 if (PyErr_Occurred()) SWIG_fail;
28380 }
28381 Py_INCREF(Py_None); resultobj = Py_None;
28382 return resultobj;
28383 fail:
28384 return NULL;
28385 }
28386
28387
28388 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28389 PyObject *resultobj;
28390 wxWindow *arg1 = (wxWindow *) 0 ;
28391 PyObject * obj0 = 0 ;
28392 char *kwnames[] = {
28393 (char *) "self", NULL
28394 };
28395
28396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28398 if (SWIG_arg_fail(1)) SWIG_fail;
28399 {
28400 PyThreadState* __tstate = wxPyBeginAllowThreads();
28401 (arg1)->ReleaseMouse();
28402
28403 wxPyEndAllowThreads(__tstate);
28404 if (PyErr_Occurred()) SWIG_fail;
28405 }
28406 Py_INCREF(Py_None); resultobj = Py_None;
28407 return resultobj;
28408 fail:
28409 return NULL;
28410 }
28411
28412
28413 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28414 PyObject *resultobj;
28415 wxWindow *result;
28416 char *kwnames[] = {
28417 NULL
28418 };
28419
28420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28421 {
28422 if (!wxPyCheckForApp()) SWIG_fail;
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 result = (wxWindow *)wxWindow::GetCapture();
28425
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 {
28430 resultobj = wxPyMake_wxObject(result, 0);
28431 }
28432 return resultobj;
28433 fail:
28434 return NULL;
28435 }
28436
28437
28438 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28439 PyObject *resultobj;
28440 wxWindow *arg1 = (wxWindow *) 0 ;
28441 bool result;
28442 PyObject * obj0 = 0 ;
28443 char *kwnames[] = {
28444 (char *) "self", NULL
28445 };
28446
28447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28449 if (SWIG_arg_fail(1)) SWIG_fail;
28450 {
28451 PyThreadState* __tstate = wxPyBeginAllowThreads();
28452 result = (bool)((wxWindow const *)arg1)->HasCapture();
28453
28454 wxPyEndAllowThreads(__tstate);
28455 if (PyErr_Occurred()) SWIG_fail;
28456 }
28457 {
28458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28459 }
28460 return resultobj;
28461 fail:
28462 return NULL;
28463 }
28464
28465
28466 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28467 PyObject *resultobj;
28468 wxWindow *arg1 = (wxWindow *) 0 ;
28469 bool arg2 = (bool) true ;
28470 wxRect *arg3 = (wxRect *) NULL ;
28471 PyObject * obj0 = 0 ;
28472 PyObject * obj1 = 0 ;
28473 PyObject * obj2 = 0 ;
28474 char *kwnames[] = {
28475 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28476 };
28477
28478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28480 if (SWIG_arg_fail(1)) SWIG_fail;
28481 if (obj1) {
28482 {
28483 arg2 = (bool)(SWIG_As_bool(obj1));
28484 if (SWIG_arg_fail(2)) SWIG_fail;
28485 }
28486 }
28487 if (obj2) {
28488 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28489 if (SWIG_arg_fail(3)) SWIG_fail;
28490 }
28491 {
28492 PyThreadState* __tstate = wxPyBeginAllowThreads();
28493 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28494
28495 wxPyEndAllowThreads(__tstate);
28496 if (PyErr_Occurred()) SWIG_fail;
28497 }
28498 Py_INCREF(Py_None); resultobj = Py_None;
28499 return resultobj;
28500 fail:
28501 return NULL;
28502 }
28503
28504
28505 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28506 PyObject *resultobj;
28507 wxWindow *arg1 = (wxWindow *) 0 ;
28508 wxRect *arg2 = 0 ;
28509 wxRect temp2 ;
28510 PyObject * obj0 = 0 ;
28511 PyObject * obj1 = 0 ;
28512 char *kwnames[] = {
28513 (char *) "self",(char *) "rect", NULL
28514 };
28515
28516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RefreshRect",kwnames,&obj0,&obj1)) goto fail;
28517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28518 if (SWIG_arg_fail(1)) SWIG_fail;
28519 {
28520 arg2 = &temp2;
28521 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28522 }
28523 {
28524 PyThreadState* __tstate = wxPyBeginAllowThreads();
28525 (arg1)->RefreshRect((wxRect const &)*arg2);
28526
28527 wxPyEndAllowThreads(__tstate);
28528 if (PyErr_Occurred()) SWIG_fail;
28529 }
28530 Py_INCREF(Py_None); resultobj = Py_None;
28531 return resultobj;
28532 fail:
28533 return NULL;
28534 }
28535
28536
28537 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28538 PyObject *resultobj;
28539 wxWindow *arg1 = (wxWindow *) 0 ;
28540 PyObject * obj0 = 0 ;
28541 char *kwnames[] = {
28542 (char *) "self", NULL
28543 };
28544
28545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28547 if (SWIG_arg_fail(1)) SWIG_fail;
28548 {
28549 PyThreadState* __tstate = wxPyBeginAllowThreads();
28550 (arg1)->Update();
28551
28552 wxPyEndAllowThreads(__tstate);
28553 if (PyErr_Occurred()) SWIG_fail;
28554 }
28555 Py_INCREF(Py_None); resultobj = Py_None;
28556 return resultobj;
28557 fail:
28558 return NULL;
28559 }
28560
28561
28562 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28563 PyObject *resultobj;
28564 wxWindow *arg1 = (wxWindow *) 0 ;
28565 PyObject * obj0 = 0 ;
28566 char *kwnames[] = {
28567 (char *) "self", NULL
28568 };
28569
28570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28572 if (SWIG_arg_fail(1)) SWIG_fail;
28573 {
28574 PyThreadState* __tstate = wxPyBeginAllowThreads();
28575 (arg1)->ClearBackground();
28576
28577 wxPyEndAllowThreads(__tstate);
28578 if (PyErr_Occurred()) SWIG_fail;
28579 }
28580 Py_INCREF(Py_None); resultobj = Py_None;
28581 return resultobj;
28582 fail:
28583 return NULL;
28584 }
28585
28586
28587 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28588 PyObject *resultobj;
28589 wxWindow *arg1 = (wxWindow *) 0 ;
28590 PyObject * obj0 = 0 ;
28591 char *kwnames[] = {
28592 (char *) "self", NULL
28593 };
28594
28595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28597 if (SWIG_arg_fail(1)) SWIG_fail;
28598 {
28599 PyThreadState* __tstate = wxPyBeginAllowThreads();
28600 (arg1)->Freeze();
28601
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 Py_INCREF(Py_None); resultobj = Py_None;
28606 return resultobj;
28607 fail:
28608 return NULL;
28609 }
28610
28611
28612 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28613 PyObject *resultobj;
28614 wxWindow *arg1 = (wxWindow *) 0 ;
28615 PyObject * obj0 = 0 ;
28616 char *kwnames[] = {
28617 (char *) "self", NULL
28618 };
28619
28620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28622 if (SWIG_arg_fail(1)) SWIG_fail;
28623 {
28624 PyThreadState* __tstate = wxPyBeginAllowThreads();
28625 (arg1)->Thaw();
28626
28627 wxPyEndAllowThreads(__tstate);
28628 if (PyErr_Occurred()) SWIG_fail;
28629 }
28630 Py_INCREF(Py_None); resultobj = Py_None;
28631 return resultobj;
28632 fail:
28633 return NULL;
28634 }
28635
28636
28637 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28638 PyObject *resultobj;
28639 wxWindow *arg1 = (wxWindow *) 0 ;
28640 wxDC *arg2 = 0 ;
28641 PyObject * obj0 = 0 ;
28642 PyObject * obj1 = 0 ;
28643 char *kwnames[] = {
28644 (char *) "self",(char *) "dc", NULL
28645 };
28646
28647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28649 if (SWIG_arg_fail(1)) SWIG_fail;
28650 {
28651 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28652 if (SWIG_arg_fail(2)) SWIG_fail;
28653 if (arg2 == NULL) {
28654 SWIG_null_ref("wxDC");
28655 }
28656 if (SWIG_arg_fail(2)) SWIG_fail;
28657 }
28658 {
28659 PyThreadState* __tstate = wxPyBeginAllowThreads();
28660 (arg1)->PrepareDC(*arg2);
28661
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 Py_INCREF(Py_None); resultobj = Py_None;
28666 return resultobj;
28667 fail:
28668 return NULL;
28669 }
28670
28671
28672 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28673 PyObject *resultobj;
28674 wxWindow *arg1 = (wxWindow *) 0 ;
28675 wxRegion *result;
28676 PyObject * obj0 = 0 ;
28677 char *kwnames[] = {
28678 (char *) "self", NULL
28679 };
28680
28681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28683 if (SWIG_arg_fail(1)) SWIG_fail;
28684 {
28685 PyThreadState* __tstate = wxPyBeginAllowThreads();
28686 {
28687 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28688 result = (wxRegion *) &_result_ref;
28689 }
28690
28691 wxPyEndAllowThreads(__tstate);
28692 if (PyErr_Occurred()) SWIG_fail;
28693 }
28694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28695 return resultobj;
28696 fail:
28697 return NULL;
28698 }
28699
28700
28701 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28702 PyObject *resultobj;
28703 wxWindow *arg1 = (wxWindow *) 0 ;
28704 wxRect result;
28705 PyObject * obj0 = 0 ;
28706 char *kwnames[] = {
28707 (char *) "self", NULL
28708 };
28709
28710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28712 if (SWIG_arg_fail(1)) SWIG_fail;
28713 {
28714 PyThreadState* __tstate = wxPyBeginAllowThreads();
28715 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28716
28717 wxPyEndAllowThreads(__tstate);
28718 if (PyErr_Occurred()) SWIG_fail;
28719 }
28720 {
28721 wxRect * resultptr;
28722 resultptr = new wxRect((wxRect &)(result));
28723 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28724 }
28725 return resultobj;
28726 fail:
28727 return NULL;
28728 }
28729
28730
28731 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
28732 PyObject *resultobj;
28733 wxWindow *arg1 = (wxWindow *) 0 ;
28734 int arg2 ;
28735 int arg3 ;
28736 int arg4 = (int) 1 ;
28737 int arg5 = (int) 1 ;
28738 bool result;
28739 PyObject * obj0 = 0 ;
28740 PyObject * obj1 = 0 ;
28741 PyObject * obj2 = 0 ;
28742 PyObject * obj3 = 0 ;
28743 PyObject * obj4 = 0 ;
28744 char *kwnames[] = {
28745 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
28746 };
28747
28748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
28749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28750 if (SWIG_arg_fail(1)) SWIG_fail;
28751 {
28752 arg2 = (int)(SWIG_As_int(obj1));
28753 if (SWIG_arg_fail(2)) SWIG_fail;
28754 }
28755 {
28756 arg3 = (int)(SWIG_As_int(obj2));
28757 if (SWIG_arg_fail(3)) SWIG_fail;
28758 }
28759 if (obj3) {
28760 {
28761 arg4 = (int)(SWIG_As_int(obj3));
28762 if (SWIG_arg_fail(4)) SWIG_fail;
28763 }
28764 }
28765 if (obj4) {
28766 {
28767 arg5 = (int)(SWIG_As_int(obj4));
28768 if (SWIG_arg_fail(5)) SWIG_fail;
28769 }
28770 }
28771 {
28772 PyThreadState* __tstate = wxPyBeginAllowThreads();
28773 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
28774
28775 wxPyEndAllowThreads(__tstate);
28776 if (PyErr_Occurred()) SWIG_fail;
28777 }
28778 {
28779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28780 }
28781 return resultobj;
28782 fail:
28783 return NULL;
28784 }
28785
28786
28787 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
28788 PyObject *resultobj;
28789 wxWindow *arg1 = (wxWindow *) 0 ;
28790 wxPoint *arg2 = 0 ;
28791 bool result;
28792 wxPoint temp2 ;
28793 PyObject * obj0 = 0 ;
28794 PyObject * obj1 = 0 ;
28795 char *kwnames[] = {
28796 (char *) "self",(char *) "pt", NULL
28797 };
28798
28799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
28800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28801 if (SWIG_arg_fail(1)) SWIG_fail;
28802 {
28803 arg2 = &temp2;
28804 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28805 }
28806 {
28807 PyThreadState* __tstate = wxPyBeginAllowThreads();
28808 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
28809
28810 wxPyEndAllowThreads(__tstate);
28811 if (PyErr_Occurred()) SWIG_fail;
28812 }
28813 {
28814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28815 }
28816 return resultobj;
28817 fail:
28818 return NULL;
28819 }
28820
28821
28822 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
28823 PyObject *resultobj;
28824 wxWindow *arg1 = (wxWindow *) 0 ;
28825 wxRect *arg2 = 0 ;
28826 bool result;
28827 wxRect temp2 ;
28828 PyObject * obj0 = 0 ;
28829 PyObject * obj1 = 0 ;
28830 char *kwnames[] = {
28831 (char *) "self",(char *) "rect", NULL
28832 };
28833
28834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
28835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28836 if (SWIG_arg_fail(1)) SWIG_fail;
28837 {
28838 arg2 = &temp2;
28839 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28840 }
28841 {
28842 PyThreadState* __tstate = wxPyBeginAllowThreads();
28843 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
28844
28845 wxPyEndAllowThreads(__tstate);
28846 if (PyErr_Occurred()) SWIG_fail;
28847 }
28848 {
28849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28850 }
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28858 PyObject *resultobj;
28859 wxWindow *arg1 = (wxWindow *) 0 ;
28860 wxVisualAttributes result;
28861 PyObject * obj0 = 0 ;
28862 char *kwnames[] = {
28863 (char *) "self", NULL
28864 };
28865
28866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
28867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28868 if (SWIG_arg_fail(1)) SWIG_fail;
28869 {
28870 PyThreadState* __tstate = wxPyBeginAllowThreads();
28871 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
28872
28873 wxPyEndAllowThreads(__tstate);
28874 if (PyErr_Occurred()) SWIG_fail;
28875 }
28876 {
28877 wxVisualAttributes * resultptr;
28878 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28879 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28880 }
28881 return resultobj;
28882 fail:
28883 return NULL;
28884 }
28885
28886
28887 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28888 PyObject *resultobj;
28889 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
28890 wxVisualAttributes result;
28891 PyObject * obj0 = 0 ;
28892 char *kwnames[] = {
28893 (char *) "variant", NULL
28894 };
28895
28896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
28897 if (obj0) {
28898 {
28899 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
28900 if (SWIG_arg_fail(1)) SWIG_fail;
28901 }
28902 }
28903 {
28904 if (!wxPyCheckForApp()) SWIG_fail;
28905 PyThreadState* __tstate = wxPyBeginAllowThreads();
28906 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
28907
28908 wxPyEndAllowThreads(__tstate);
28909 if (PyErr_Occurred()) SWIG_fail;
28910 }
28911 {
28912 wxVisualAttributes * resultptr;
28913 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28914 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28915 }
28916 return resultobj;
28917 fail:
28918 return NULL;
28919 }
28920
28921
28922 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28923 PyObject *resultobj;
28924 wxWindow *arg1 = (wxWindow *) 0 ;
28925 wxColour *arg2 = 0 ;
28926 bool result;
28927 wxColour temp2 ;
28928 PyObject * obj0 = 0 ;
28929 PyObject * obj1 = 0 ;
28930 char *kwnames[] = {
28931 (char *) "self",(char *) "colour", NULL
28932 };
28933
28934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28936 if (SWIG_arg_fail(1)) SWIG_fail;
28937 {
28938 arg2 = &temp2;
28939 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28940 }
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
28944
28945 wxPyEndAllowThreads(__tstate);
28946 if (PyErr_Occurred()) SWIG_fail;
28947 }
28948 {
28949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28950 }
28951 return resultobj;
28952 fail:
28953 return NULL;
28954 }
28955
28956
28957 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28958 PyObject *resultobj;
28959 wxWindow *arg1 = (wxWindow *) 0 ;
28960 wxColour *arg2 = 0 ;
28961 wxColour temp2 ;
28962 PyObject * obj0 = 0 ;
28963 PyObject * obj1 = 0 ;
28964 char *kwnames[] = {
28965 (char *) "self",(char *) "colour", NULL
28966 };
28967
28968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28970 if (SWIG_arg_fail(1)) SWIG_fail;
28971 {
28972 arg2 = &temp2;
28973 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28974 }
28975 {
28976 PyThreadState* __tstate = wxPyBeginAllowThreads();
28977 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
28978
28979 wxPyEndAllowThreads(__tstate);
28980 if (PyErr_Occurred()) SWIG_fail;
28981 }
28982 Py_INCREF(Py_None); resultobj = Py_None;
28983 return resultobj;
28984 fail:
28985 return NULL;
28986 }
28987
28988
28989 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28990 PyObject *resultobj;
28991 wxWindow *arg1 = (wxWindow *) 0 ;
28992 wxColour *arg2 = 0 ;
28993 bool result;
28994 wxColour temp2 ;
28995 PyObject * obj0 = 0 ;
28996 PyObject * obj1 = 0 ;
28997 char *kwnames[] = {
28998 (char *) "self",(char *) "colour", NULL
28999 };
29000
29001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29003 if (SWIG_arg_fail(1)) SWIG_fail;
29004 {
29005 arg2 = &temp2;
29006 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29007 }
29008 {
29009 PyThreadState* __tstate = wxPyBeginAllowThreads();
29010 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29011
29012 wxPyEndAllowThreads(__tstate);
29013 if (PyErr_Occurred()) SWIG_fail;
29014 }
29015 {
29016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29017 }
29018 return resultobj;
29019 fail:
29020 return NULL;
29021 }
29022
29023
29024 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29025 PyObject *resultobj;
29026 wxWindow *arg1 = (wxWindow *) 0 ;
29027 wxColour *arg2 = 0 ;
29028 wxColour temp2 ;
29029 PyObject * obj0 = 0 ;
29030 PyObject * obj1 = 0 ;
29031 char *kwnames[] = {
29032 (char *) "self",(char *) "colour", NULL
29033 };
29034
29035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29037 if (SWIG_arg_fail(1)) SWIG_fail;
29038 {
29039 arg2 = &temp2;
29040 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29041 }
29042 {
29043 PyThreadState* __tstate = wxPyBeginAllowThreads();
29044 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29045
29046 wxPyEndAllowThreads(__tstate);
29047 if (PyErr_Occurred()) SWIG_fail;
29048 }
29049 Py_INCREF(Py_None); resultobj = Py_None;
29050 return resultobj;
29051 fail:
29052 return NULL;
29053 }
29054
29055
29056 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29057 PyObject *resultobj;
29058 wxWindow *arg1 = (wxWindow *) 0 ;
29059 wxColour result;
29060 PyObject * obj0 = 0 ;
29061 char *kwnames[] = {
29062 (char *) "self", NULL
29063 };
29064
29065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29067 if (SWIG_arg_fail(1)) SWIG_fail;
29068 {
29069 PyThreadState* __tstate = wxPyBeginAllowThreads();
29070 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29071
29072 wxPyEndAllowThreads(__tstate);
29073 if (PyErr_Occurred()) SWIG_fail;
29074 }
29075 {
29076 wxColour * resultptr;
29077 resultptr = new wxColour((wxColour &)(result));
29078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29079 }
29080 return resultobj;
29081 fail:
29082 return NULL;
29083 }
29084
29085
29086 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29087 PyObject *resultobj;
29088 wxWindow *arg1 = (wxWindow *) 0 ;
29089 wxColour result;
29090 PyObject * obj0 = 0 ;
29091 char *kwnames[] = {
29092 (char *) "self", NULL
29093 };
29094
29095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29097 if (SWIG_arg_fail(1)) SWIG_fail;
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = ((wxWindow const *)arg1)->GetForegroundColour();
29101
29102 wxPyEndAllowThreads(__tstate);
29103 if (PyErr_Occurred()) SWIG_fail;
29104 }
29105 {
29106 wxColour * resultptr;
29107 resultptr = new wxColour((wxColour &)(result));
29108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29109 }
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29117 PyObject *resultobj;
29118 wxWindow *arg1 = (wxWindow *) 0 ;
29119 wxBackgroundStyle arg2 ;
29120 bool result;
29121 PyObject * obj0 = 0 ;
29122 PyObject * obj1 = 0 ;
29123 char *kwnames[] = {
29124 (char *) "self",(char *) "style", NULL
29125 };
29126
29127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29129 if (SWIG_arg_fail(1)) SWIG_fail;
29130 {
29131 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29132 if (SWIG_arg_fail(2)) SWIG_fail;
29133 }
29134 {
29135 PyThreadState* __tstate = wxPyBeginAllowThreads();
29136 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29137
29138 wxPyEndAllowThreads(__tstate);
29139 if (PyErr_Occurred()) SWIG_fail;
29140 }
29141 {
29142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29143 }
29144 return resultobj;
29145 fail:
29146 return NULL;
29147 }
29148
29149
29150 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29151 PyObject *resultobj;
29152 wxWindow *arg1 = (wxWindow *) 0 ;
29153 wxBackgroundStyle result;
29154 PyObject * obj0 = 0 ;
29155 char *kwnames[] = {
29156 (char *) "self", NULL
29157 };
29158
29159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29161 if (SWIG_arg_fail(1)) SWIG_fail;
29162 {
29163 PyThreadState* __tstate = wxPyBeginAllowThreads();
29164 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29165
29166 wxPyEndAllowThreads(__tstate);
29167 if (PyErr_Occurred()) SWIG_fail;
29168 }
29169 resultobj = SWIG_From_int((result));
29170 return resultobj;
29171 fail:
29172 return NULL;
29173 }
29174
29175
29176 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29177 PyObject *resultobj;
29178 wxWindow *arg1 = (wxWindow *) 0 ;
29179 wxCursor *arg2 = 0 ;
29180 bool result;
29181 PyObject * obj0 = 0 ;
29182 PyObject * obj1 = 0 ;
29183 char *kwnames[] = {
29184 (char *) "self",(char *) "cursor", NULL
29185 };
29186
29187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29189 if (SWIG_arg_fail(1)) SWIG_fail;
29190 {
29191 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29192 if (SWIG_arg_fail(2)) SWIG_fail;
29193 if (arg2 == NULL) {
29194 SWIG_null_ref("wxCursor");
29195 }
29196 if (SWIG_arg_fail(2)) SWIG_fail;
29197 }
29198 {
29199 PyThreadState* __tstate = wxPyBeginAllowThreads();
29200 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29201
29202 wxPyEndAllowThreads(__tstate);
29203 if (PyErr_Occurred()) SWIG_fail;
29204 }
29205 {
29206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29207 }
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29215 PyObject *resultobj;
29216 wxWindow *arg1 = (wxWindow *) 0 ;
29217 wxCursor result;
29218 PyObject * obj0 = 0 ;
29219 char *kwnames[] = {
29220 (char *) "self", NULL
29221 };
29222
29223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29225 if (SWIG_arg_fail(1)) SWIG_fail;
29226 {
29227 PyThreadState* __tstate = wxPyBeginAllowThreads();
29228 result = (arg1)->GetCursor();
29229
29230 wxPyEndAllowThreads(__tstate);
29231 if (PyErr_Occurred()) SWIG_fail;
29232 }
29233 {
29234 wxCursor * resultptr;
29235 resultptr = new wxCursor((wxCursor &)(result));
29236 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29237 }
29238 return resultobj;
29239 fail:
29240 return NULL;
29241 }
29242
29243
29244 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29245 PyObject *resultobj;
29246 wxWindow *arg1 = (wxWindow *) 0 ;
29247 wxFont *arg2 = 0 ;
29248 bool result;
29249 PyObject * obj0 = 0 ;
29250 PyObject * obj1 = 0 ;
29251 char *kwnames[] = {
29252 (char *) "self",(char *) "font", NULL
29253 };
29254
29255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29257 if (SWIG_arg_fail(1)) SWIG_fail;
29258 {
29259 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29260 if (SWIG_arg_fail(2)) SWIG_fail;
29261 if (arg2 == NULL) {
29262 SWIG_null_ref("wxFont");
29263 }
29264 if (SWIG_arg_fail(2)) SWIG_fail;
29265 }
29266 {
29267 PyThreadState* __tstate = wxPyBeginAllowThreads();
29268 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29269
29270 wxPyEndAllowThreads(__tstate);
29271 if (PyErr_Occurred()) SWIG_fail;
29272 }
29273 {
29274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29275 }
29276 return resultobj;
29277 fail:
29278 return NULL;
29279 }
29280
29281
29282 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29283 PyObject *resultobj;
29284 wxWindow *arg1 = (wxWindow *) 0 ;
29285 wxFont *arg2 = 0 ;
29286 PyObject * obj0 = 0 ;
29287 PyObject * obj1 = 0 ;
29288 char *kwnames[] = {
29289 (char *) "self",(char *) "font", NULL
29290 };
29291
29292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29294 if (SWIG_arg_fail(1)) SWIG_fail;
29295 {
29296 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29297 if (SWIG_arg_fail(2)) SWIG_fail;
29298 if (arg2 == NULL) {
29299 SWIG_null_ref("wxFont");
29300 }
29301 if (SWIG_arg_fail(2)) SWIG_fail;
29302 }
29303 {
29304 PyThreadState* __tstate = wxPyBeginAllowThreads();
29305 (arg1)->SetOwnFont((wxFont const &)*arg2);
29306
29307 wxPyEndAllowThreads(__tstate);
29308 if (PyErr_Occurred()) SWIG_fail;
29309 }
29310 Py_INCREF(Py_None); resultobj = Py_None;
29311 return resultobj;
29312 fail:
29313 return NULL;
29314 }
29315
29316
29317 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29318 PyObject *resultobj;
29319 wxWindow *arg1 = (wxWindow *) 0 ;
29320 wxFont result;
29321 PyObject * obj0 = 0 ;
29322 char *kwnames[] = {
29323 (char *) "self", NULL
29324 };
29325
29326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29328 if (SWIG_arg_fail(1)) SWIG_fail;
29329 {
29330 PyThreadState* __tstate = wxPyBeginAllowThreads();
29331 result = (arg1)->GetFont();
29332
29333 wxPyEndAllowThreads(__tstate);
29334 if (PyErr_Occurred()) SWIG_fail;
29335 }
29336 {
29337 wxFont * resultptr;
29338 resultptr = new wxFont((wxFont &)(result));
29339 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29340 }
29341 return resultobj;
29342 fail:
29343 return NULL;
29344 }
29345
29346
29347 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29348 PyObject *resultobj;
29349 wxWindow *arg1 = (wxWindow *) 0 ;
29350 wxCaret *arg2 = (wxCaret *) 0 ;
29351 PyObject * obj0 = 0 ;
29352 PyObject * obj1 = 0 ;
29353 char *kwnames[] = {
29354 (char *) "self",(char *) "caret", NULL
29355 };
29356
29357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29359 if (SWIG_arg_fail(1)) SWIG_fail;
29360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29361 if (SWIG_arg_fail(2)) SWIG_fail;
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 (arg1)->SetCaret(arg2);
29365
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 Py_INCREF(Py_None); resultobj = Py_None;
29370 return resultobj;
29371 fail:
29372 return NULL;
29373 }
29374
29375
29376 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29377 PyObject *resultobj;
29378 wxWindow *arg1 = (wxWindow *) 0 ;
29379 wxCaret *result;
29380 PyObject * obj0 = 0 ;
29381 char *kwnames[] = {
29382 (char *) "self", NULL
29383 };
29384
29385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29387 if (SWIG_arg_fail(1)) SWIG_fail;
29388 {
29389 PyThreadState* __tstate = wxPyBeginAllowThreads();
29390 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29391
29392 wxPyEndAllowThreads(__tstate);
29393 if (PyErr_Occurred()) SWIG_fail;
29394 }
29395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29396 return resultobj;
29397 fail:
29398 return NULL;
29399 }
29400
29401
29402 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29403 PyObject *resultobj;
29404 wxWindow *arg1 = (wxWindow *) 0 ;
29405 int result;
29406 PyObject * obj0 = 0 ;
29407 char *kwnames[] = {
29408 (char *) "self", NULL
29409 };
29410
29411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29413 if (SWIG_arg_fail(1)) SWIG_fail;
29414 {
29415 PyThreadState* __tstate = wxPyBeginAllowThreads();
29416 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29417
29418 wxPyEndAllowThreads(__tstate);
29419 if (PyErr_Occurred()) SWIG_fail;
29420 }
29421 {
29422 resultobj = SWIG_From_int((int)(result));
29423 }
29424 return resultobj;
29425 fail:
29426 return NULL;
29427 }
29428
29429
29430 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29431 PyObject *resultobj;
29432 wxWindow *arg1 = (wxWindow *) 0 ;
29433 int result;
29434 PyObject * obj0 = 0 ;
29435 char *kwnames[] = {
29436 (char *) "self", NULL
29437 };
29438
29439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29441 if (SWIG_arg_fail(1)) SWIG_fail;
29442 {
29443 PyThreadState* __tstate = wxPyBeginAllowThreads();
29444 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29445
29446 wxPyEndAllowThreads(__tstate);
29447 if (PyErr_Occurred()) SWIG_fail;
29448 }
29449 {
29450 resultobj = SWIG_From_int((int)(result));
29451 }
29452 return resultobj;
29453 fail:
29454 return NULL;
29455 }
29456
29457
29458 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29459 PyObject *resultobj;
29460 wxWindow *arg1 = (wxWindow *) 0 ;
29461 wxString *arg2 = 0 ;
29462 int *arg3 = (int *) 0 ;
29463 int *arg4 = (int *) 0 ;
29464 bool temp2 = false ;
29465 int temp3 ;
29466 int res3 = 0 ;
29467 int temp4 ;
29468 int res4 = 0 ;
29469 PyObject * obj0 = 0 ;
29470 PyObject * obj1 = 0 ;
29471 char *kwnames[] = {
29472 (char *) "self",(char *) "string", NULL
29473 };
29474
29475 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29476 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29479 if (SWIG_arg_fail(1)) SWIG_fail;
29480 {
29481 arg2 = wxString_in_helper(obj1);
29482 if (arg2 == NULL) SWIG_fail;
29483 temp2 = true;
29484 }
29485 {
29486 PyThreadState* __tstate = wxPyBeginAllowThreads();
29487 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29488
29489 wxPyEndAllowThreads(__tstate);
29490 if (PyErr_Occurred()) SWIG_fail;
29491 }
29492 Py_INCREF(Py_None); resultobj = Py_None;
29493 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29494 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29495 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29496 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29497 {
29498 if (temp2)
29499 delete arg2;
29500 }
29501 return resultobj;
29502 fail:
29503 {
29504 if (temp2)
29505 delete arg2;
29506 }
29507 return NULL;
29508 }
29509
29510
29511 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29512 PyObject *resultobj;
29513 wxWindow *arg1 = (wxWindow *) 0 ;
29514 wxString *arg2 = 0 ;
29515 int *arg3 = (int *) 0 ;
29516 int *arg4 = (int *) 0 ;
29517 int *arg5 = (int *) 0 ;
29518 int *arg6 = (int *) 0 ;
29519 wxFont *arg7 = (wxFont *) NULL ;
29520 bool temp2 = false ;
29521 int temp3 ;
29522 int res3 = 0 ;
29523 int temp4 ;
29524 int res4 = 0 ;
29525 int temp5 ;
29526 int res5 = 0 ;
29527 int temp6 ;
29528 int res6 = 0 ;
29529 PyObject * obj0 = 0 ;
29530 PyObject * obj1 = 0 ;
29531 PyObject * obj2 = 0 ;
29532 char *kwnames[] = {
29533 (char *) "self",(char *) "string",(char *) "font", NULL
29534 };
29535
29536 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29537 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29538 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29539 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29542 if (SWIG_arg_fail(1)) SWIG_fail;
29543 {
29544 arg2 = wxString_in_helper(obj1);
29545 if (arg2 == NULL) SWIG_fail;
29546 temp2 = true;
29547 }
29548 if (obj2) {
29549 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29550 if (SWIG_arg_fail(7)) SWIG_fail;
29551 }
29552 {
29553 PyThreadState* __tstate = wxPyBeginAllowThreads();
29554 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29555
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 Py_INCREF(Py_None); resultobj = Py_None;
29560 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29561 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29562 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29563 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29564 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29565 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29566 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29567 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29568 {
29569 if (temp2)
29570 delete arg2;
29571 }
29572 return resultobj;
29573 fail:
29574 {
29575 if (temp2)
29576 delete arg2;
29577 }
29578 return NULL;
29579 }
29580
29581
29582 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29583 PyObject *resultobj;
29584 wxWindow *arg1 = (wxWindow *) 0 ;
29585 int *arg2 = (int *) 0 ;
29586 int *arg3 = (int *) 0 ;
29587 int temp2 ;
29588 int res2 = 0 ;
29589 int temp3 ;
29590 int res3 = 0 ;
29591 PyObject * obj0 = 0 ;
29592 PyObject * obj1 = 0 ;
29593 PyObject * obj2 = 0 ;
29594 char *kwnames[] = {
29595 (char *) "self",(char *) "x",(char *) "y", NULL
29596 };
29597
29598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29600 if (SWIG_arg_fail(1)) SWIG_fail;
29601 {
29602 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29603 temp2 = SWIG_As_int(obj1);
29604 if (SWIG_arg_fail(2)) SWIG_fail;
29605 arg2 = &temp2;
29606 res2 = SWIG_NEWOBJ;
29607 }
29608 }
29609 {
29610 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29611 temp3 = SWIG_As_int(obj2);
29612 if (SWIG_arg_fail(3)) SWIG_fail;
29613 arg3 = &temp3;
29614 res3 = SWIG_NEWOBJ;
29615 }
29616 }
29617 {
29618 PyThreadState* __tstate = wxPyBeginAllowThreads();
29619 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29620
29621 wxPyEndAllowThreads(__tstate);
29622 if (PyErr_Occurred()) SWIG_fail;
29623 }
29624 Py_INCREF(Py_None); resultobj = Py_None;
29625 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29626 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29627 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29628 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29629 return resultobj;
29630 fail:
29631 return NULL;
29632 }
29633
29634
29635 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29636 PyObject *resultobj;
29637 wxWindow *arg1 = (wxWindow *) 0 ;
29638 int *arg2 = (int *) 0 ;
29639 int *arg3 = (int *) 0 ;
29640 int temp2 ;
29641 int res2 = 0 ;
29642 int temp3 ;
29643 int res3 = 0 ;
29644 PyObject * obj0 = 0 ;
29645 PyObject * obj1 = 0 ;
29646 PyObject * obj2 = 0 ;
29647 char *kwnames[] = {
29648 (char *) "self",(char *) "x",(char *) "y", NULL
29649 };
29650
29651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29653 if (SWIG_arg_fail(1)) SWIG_fail;
29654 {
29655 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29656 temp2 = SWIG_As_int(obj1);
29657 if (SWIG_arg_fail(2)) SWIG_fail;
29658 arg2 = &temp2;
29659 res2 = SWIG_NEWOBJ;
29660 }
29661 }
29662 {
29663 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29664 temp3 = SWIG_As_int(obj2);
29665 if (SWIG_arg_fail(3)) SWIG_fail;
29666 arg3 = &temp3;
29667 res3 = SWIG_NEWOBJ;
29668 }
29669 }
29670 {
29671 PyThreadState* __tstate = wxPyBeginAllowThreads();
29672 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29673
29674 wxPyEndAllowThreads(__tstate);
29675 if (PyErr_Occurred()) SWIG_fail;
29676 }
29677 Py_INCREF(Py_None); resultobj = Py_None;
29678 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29679 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29680 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29681 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29682 return resultobj;
29683 fail:
29684 return NULL;
29685 }
29686
29687
29688 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29689 PyObject *resultobj;
29690 wxWindow *arg1 = (wxWindow *) 0 ;
29691 wxPoint *arg2 = 0 ;
29692 wxPoint result;
29693 wxPoint temp2 ;
29694 PyObject * obj0 = 0 ;
29695 PyObject * obj1 = 0 ;
29696 char *kwnames[] = {
29697 (char *) "self",(char *) "pt", NULL
29698 };
29699
29700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
29701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29702 if (SWIG_arg_fail(1)) SWIG_fail;
29703 {
29704 arg2 = &temp2;
29705 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29706 }
29707 {
29708 PyThreadState* __tstate = wxPyBeginAllowThreads();
29709 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
29710
29711 wxPyEndAllowThreads(__tstate);
29712 if (PyErr_Occurred()) SWIG_fail;
29713 }
29714 {
29715 wxPoint * resultptr;
29716 resultptr = new wxPoint((wxPoint &)(result));
29717 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29718 }
29719 return resultobj;
29720 fail:
29721 return NULL;
29722 }
29723
29724
29725 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
29726 PyObject *resultobj;
29727 wxWindow *arg1 = (wxWindow *) 0 ;
29728 wxPoint *arg2 = 0 ;
29729 wxPoint result;
29730 wxPoint temp2 ;
29731 PyObject * obj0 = 0 ;
29732 PyObject * obj1 = 0 ;
29733 char *kwnames[] = {
29734 (char *) "self",(char *) "pt", NULL
29735 };
29736
29737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
29738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29739 if (SWIG_arg_fail(1)) SWIG_fail;
29740 {
29741 arg2 = &temp2;
29742 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29743 }
29744 {
29745 PyThreadState* __tstate = wxPyBeginAllowThreads();
29746 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
29747
29748 wxPyEndAllowThreads(__tstate);
29749 if (PyErr_Occurred()) SWIG_fail;
29750 }
29751 {
29752 wxPoint * resultptr;
29753 resultptr = new wxPoint((wxPoint &)(result));
29754 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29755 }
29756 return resultobj;
29757 fail:
29758 return NULL;
29759 }
29760
29761
29762 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
29763 PyObject *resultobj;
29764 wxWindow *arg1 = (wxWindow *) 0 ;
29765 int arg2 ;
29766 int arg3 ;
29767 wxHitTest result;
29768 PyObject * obj0 = 0 ;
29769 PyObject * obj1 = 0 ;
29770 PyObject * obj2 = 0 ;
29771 char *kwnames[] = {
29772 (char *) "self",(char *) "x",(char *) "y", NULL
29773 };
29774
29775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29777 if (SWIG_arg_fail(1)) SWIG_fail;
29778 {
29779 arg2 = (int)(SWIG_As_int(obj1));
29780 if (SWIG_arg_fail(2)) SWIG_fail;
29781 }
29782 {
29783 arg3 = (int)(SWIG_As_int(obj2));
29784 if (SWIG_arg_fail(3)) SWIG_fail;
29785 }
29786 {
29787 PyThreadState* __tstate = wxPyBeginAllowThreads();
29788 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
29789
29790 wxPyEndAllowThreads(__tstate);
29791 if (PyErr_Occurred()) SWIG_fail;
29792 }
29793 resultobj = SWIG_From_int((result));
29794 return resultobj;
29795 fail:
29796 return NULL;
29797 }
29798
29799
29800 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
29801 PyObject *resultobj;
29802 wxWindow *arg1 = (wxWindow *) 0 ;
29803 wxPoint *arg2 = 0 ;
29804 wxHitTest result;
29805 wxPoint temp2 ;
29806 PyObject * obj0 = 0 ;
29807 PyObject * obj1 = 0 ;
29808 char *kwnames[] = {
29809 (char *) "self",(char *) "pt", NULL
29810 };
29811
29812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
29813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29814 if (SWIG_arg_fail(1)) SWIG_fail;
29815 {
29816 arg2 = &temp2;
29817 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29818 }
29819 {
29820 PyThreadState* __tstate = wxPyBeginAllowThreads();
29821 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
29822
29823 wxPyEndAllowThreads(__tstate);
29824 if (PyErr_Occurred()) SWIG_fail;
29825 }
29826 resultobj = SWIG_From_int((result));
29827 return resultobj;
29828 fail:
29829 return NULL;
29830 }
29831
29832
29833 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
29834 PyObject *resultobj;
29835 wxWindow *arg1 = (wxWindow *) 0 ;
29836 long arg2 ;
29837 wxBorder result;
29838 PyObject * obj0 = 0 ;
29839 PyObject * obj1 = 0 ;
29840
29841 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
29842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29843 if (SWIG_arg_fail(1)) SWIG_fail;
29844 {
29845 arg2 = (long)(SWIG_As_long(obj1));
29846 if (SWIG_arg_fail(2)) SWIG_fail;
29847 }
29848 {
29849 PyThreadState* __tstate = wxPyBeginAllowThreads();
29850 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
29851
29852 wxPyEndAllowThreads(__tstate);
29853 if (PyErr_Occurred()) SWIG_fail;
29854 }
29855 resultobj = SWIG_From_int((result));
29856 return resultobj;
29857 fail:
29858 return NULL;
29859 }
29860
29861
29862 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
29863 PyObject *resultobj;
29864 wxWindow *arg1 = (wxWindow *) 0 ;
29865 wxBorder result;
29866 PyObject * obj0 = 0 ;
29867
29868 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
29869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29870 if (SWIG_arg_fail(1)) SWIG_fail;
29871 {
29872 PyThreadState* __tstate = wxPyBeginAllowThreads();
29873 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
29874
29875 wxPyEndAllowThreads(__tstate);
29876 if (PyErr_Occurred()) SWIG_fail;
29877 }
29878 resultobj = SWIG_From_int((result));
29879 return resultobj;
29880 fail:
29881 return NULL;
29882 }
29883
29884
29885 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
29886 int argc;
29887 PyObject *argv[3];
29888 int ii;
29889
29890 argc = PyObject_Length(args);
29891 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29892 argv[ii] = PyTuple_GetItem(args,ii);
29893 }
29894 if (argc == 1) {
29895 int _v;
29896 {
29897 void *ptr;
29898 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29899 _v = 0;
29900 PyErr_Clear();
29901 } else {
29902 _v = 1;
29903 }
29904 }
29905 if (_v) {
29906 return _wrap_Window_GetBorder__SWIG_1(self,args);
29907 }
29908 }
29909 if (argc == 2) {
29910 int _v;
29911 {
29912 void *ptr;
29913 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29914 _v = 0;
29915 PyErr_Clear();
29916 } else {
29917 _v = 1;
29918 }
29919 }
29920 if (_v) {
29921 _v = SWIG_Check_long(argv[1]);
29922 if (_v) {
29923 return _wrap_Window_GetBorder__SWIG_0(self,args);
29924 }
29925 }
29926 }
29927
29928 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
29929 return NULL;
29930 }
29931
29932
29933 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
29934 PyObject *resultobj;
29935 wxWindow *arg1 = (wxWindow *) 0 ;
29936 long arg2 = (long) wxUPDATE_UI_NONE ;
29937 PyObject * obj0 = 0 ;
29938 PyObject * obj1 = 0 ;
29939 char *kwnames[] = {
29940 (char *) "self",(char *) "flags", NULL
29941 };
29942
29943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
29944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29945 if (SWIG_arg_fail(1)) SWIG_fail;
29946 if (obj1) {
29947 {
29948 arg2 = (long)(SWIG_As_long(obj1));
29949 if (SWIG_arg_fail(2)) SWIG_fail;
29950 }
29951 }
29952 {
29953 PyThreadState* __tstate = wxPyBeginAllowThreads();
29954 (arg1)->UpdateWindowUI(arg2);
29955
29956 wxPyEndAllowThreads(__tstate);
29957 if (PyErr_Occurred()) SWIG_fail;
29958 }
29959 Py_INCREF(Py_None); resultobj = Py_None;
29960 return resultobj;
29961 fail:
29962 return NULL;
29963 }
29964
29965
29966 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
29967 PyObject *resultobj;
29968 wxWindow *arg1 = (wxWindow *) 0 ;
29969 wxMenu *arg2 = (wxMenu *) 0 ;
29970 int arg3 = (int) -1 ;
29971 int arg4 = (int) -1 ;
29972 bool result;
29973 PyObject * obj0 = 0 ;
29974 PyObject * obj1 = 0 ;
29975 PyObject * obj2 = 0 ;
29976 PyObject * obj3 = 0 ;
29977 char *kwnames[] = {
29978 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
29979 };
29980
29981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29983 if (SWIG_arg_fail(1)) SWIG_fail;
29984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
29985 if (SWIG_arg_fail(2)) SWIG_fail;
29986 if (obj2) {
29987 {
29988 arg3 = (int)(SWIG_As_int(obj2));
29989 if (SWIG_arg_fail(3)) SWIG_fail;
29990 }
29991 }
29992 if (obj3) {
29993 {
29994 arg4 = (int)(SWIG_As_int(obj3));
29995 if (SWIG_arg_fail(4)) SWIG_fail;
29996 }
29997 }
29998 {
29999 PyThreadState* __tstate = wxPyBeginAllowThreads();
30000 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30001
30002 wxPyEndAllowThreads(__tstate);
30003 if (PyErr_Occurred()) SWIG_fail;
30004 }
30005 {
30006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30007 }
30008 return resultobj;
30009 fail:
30010 return NULL;
30011 }
30012
30013
30014 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30015 PyObject *resultobj;
30016 wxWindow *arg1 = (wxWindow *) 0 ;
30017 wxMenu *arg2 = (wxMenu *) 0 ;
30018 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30019 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30020 bool result;
30021 wxPoint temp3 ;
30022 PyObject * obj0 = 0 ;
30023 PyObject * obj1 = 0 ;
30024 PyObject * obj2 = 0 ;
30025 char *kwnames[] = {
30026 (char *) "self",(char *) "menu",(char *) "pos", NULL
30027 };
30028
30029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30031 if (SWIG_arg_fail(1)) SWIG_fail;
30032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30033 if (SWIG_arg_fail(2)) SWIG_fail;
30034 if (obj2) {
30035 {
30036 arg3 = &temp3;
30037 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30038 }
30039 }
30040 {
30041 PyThreadState* __tstate = wxPyBeginAllowThreads();
30042 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30043
30044 wxPyEndAllowThreads(__tstate);
30045 if (PyErr_Occurred()) SWIG_fail;
30046 }
30047 {
30048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30049 }
30050 return resultobj;
30051 fail:
30052 return NULL;
30053 }
30054
30055
30056 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30057 PyObject *resultobj;
30058 wxWindow *arg1 = (wxWindow *) 0 ;
30059 long result;
30060 PyObject * obj0 = 0 ;
30061 char *kwnames[] = {
30062 (char *) "self", NULL
30063 };
30064
30065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30067 if (SWIG_arg_fail(1)) SWIG_fail;
30068 {
30069 PyThreadState* __tstate = wxPyBeginAllowThreads();
30070 result = (long)wxWindow_GetHandle(arg1);
30071
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 {
30076 resultobj = SWIG_From_long((long)(result));
30077 }
30078 return resultobj;
30079 fail:
30080 return NULL;
30081 }
30082
30083
30084 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30085 PyObject *resultobj;
30086 wxWindow *arg1 = (wxWindow *) 0 ;
30087 long arg2 ;
30088 PyObject * obj0 = 0 ;
30089 PyObject * obj1 = 0 ;
30090 char *kwnames[] = {
30091 (char *) "self",(char *) "handle", NULL
30092 };
30093
30094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30096 if (SWIG_arg_fail(1)) SWIG_fail;
30097 {
30098 arg2 = (long)(SWIG_As_long(obj1));
30099 if (SWIG_arg_fail(2)) SWIG_fail;
30100 }
30101 {
30102 PyThreadState* __tstate = wxPyBeginAllowThreads();
30103 wxWindow_AssociateHandle(arg1,arg2);
30104
30105 wxPyEndAllowThreads(__tstate);
30106 if (PyErr_Occurred()) SWIG_fail;
30107 }
30108 Py_INCREF(Py_None); resultobj = Py_None;
30109 return resultobj;
30110 fail:
30111 return NULL;
30112 }
30113
30114
30115 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30116 PyObject *resultobj;
30117 wxWindow *arg1 = (wxWindow *) 0 ;
30118 PyObject * obj0 = 0 ;
30119 char *kwnames[] = {
30120 (char *) "self", NULL
30121 };
30122
30123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30125 if (SWIG_arg_fail(1)) SWIG_fail;
30126 {
30127 PyThreadState* __tstate = wxPyBeginAllowThreads();
30128 (arg1)->DissociateHandle();
30129
30130 wxPyEndAllowThreads(__tstate);
30131 if (PyErr_Occurred()) SWIG_fail;
30132 }
30133 Py_INCREF(Py_None); resultobj = Py_None;
30134 return resultobj;
30135 fail:
30136 return NULL;
30137 }
30138
30139
30140 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30141 PyObject *resultobj;
30142 wxWindow *arg1 = (wxWindow *) 0 ;
30143 wxPaintEvent *arg2 = 0 ;
30144 PyObject * obj0 = 0 ;
30145 PyObject * obj1 = 0 ;
30146 char *kwnames[] = {
30147 (char *) "self",(char *) "event", NULL
30148 };
30149
30150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30152 if (SWIG_arg_fail(1)) SWIG_fail;
30153 {
30154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30155 if (SWIG_arg_fail(2)) SWIG_fail;
30156 if (arg2 == NULL) {
30157 SWIG_null_ref("wxPaintEvent");
30158 }
30159 if (SWIG_arg_fail(2)) SWIG_fail;
30160 }
30161 {
30162 PyThreadState* __tstate = wxPyBeginAllowThreads();
30163 (arg1)->OnPaint(*arg2);
30164
30165 wxPyEndAllowThreads(__tstate);
30166 if (PyErr_Occurred()) SWIG_fail;
30167 }
30168 Py_INCREF(Py_None); resultobj = Py_None;
30169 return resultobj;
30170 fail:
30171 return NULL;
30172 }
30173
30174
30175 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30176 PyObject *resultobj;
30177 wxWindow *arg1 = (wxWindow *) 0 ;
30178 int arg2 ;
30179 bool result;
30180 PyObject * obj0 = 0 ;
30181 PyObject * obj1 = 0 ;
30182 char *kwnames[] = {
30183 (char *) "self",(char *) "orient", NULL
30184 };
30185
30186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30188 if (SWIG_arg_fail(1)) SWIG_fail;
30189 {
30190 arg2 = (int)(SWIG_As_int(obj1));
30191 if (SWIG_arg_fail(2)) SWIG_fail;
30192 }
30193 {
30194 PyThreadState* __tstate = wxPyBeginAllowThreads();
30195 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30196
30197 wxPyEndAllowThreads(__tstate);
30198 if (PyErr_Occurred()) SWIG_fail;
30199 }
30200 {
30201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30202 }
30203 return resultobj;
30204 fail:
30205 return NULL;
30206 }
30207
30208
30209 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30210 PyObject *resultobj;
30211 wxWindow *arg1 = (wxWindow *) 0 ;
30212 int arg2 ;
30213 int arg3 ;
30214 int arg4 ;
30215 int arg5 ;
30216 bool arg6 = (bool) true ;
30217 PyObject * obj0 = 0 ;
30218 PyObject * obj1 = 0 ;
30219 PyObject * obj2 = 0 ;
30220 PyObject * obj3 = 0 ;
30221 PyObject * obj4 = 0 ;
30222 PyObject * obj5 = 0 ;
30223 char *kwnames[] = {
30224 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30225 };
30226
30227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30229 if (SWIG_arg_fail(1)) SWIG_fail;
30230 {
30231 arg2 = (int)(SWIG_As_int(obj1));
30232 if (SWIG_arg_fail(2)) SWIG_fail;
30233 }
30234 {
30235 arg3 = (int)(SWIG_As_int(obj2));
30236 if (SWIG_arg_fail(3)) SWIG_fail;
30237 }
30238 {
30239 arg4 = (int)(SWIG_As_int(obj3));
30240 if (SWIG_arg_fail(4)) SWIG_fail;
30241 }
30242 {
30243 arg5 = (int)(SWIG_As_int(obj4));
30244 if (SWIG_arg_fail(5)) SWIG_fail;
30245 }
30246 if (obj5) {
30247 {
30248 arg6 = (bool)(SWIG_As_bool(obj5));
30249 if (SWIG_arg_fail(6)) SWIG_fail;
30250 }
30251 }
30252 {
30253 PyThreadState* __tstate = wxPyBeginAllowThreads();
30254 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30255
30256 wxPyEndAllowThreads(__tstate);
30257 if (PyErr_Occurred()) SWIG_fail;
30258 }
30259 Py_INCREF(Py_None); resultobj = Py_None;
30260 return resultobj;
30261 fail:
30262 return NULL;
30263 }
30264
30265
30266 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30267 PyObject *resultobj;
30268 wxWindow *arg1 = (wxWindow *) 0 ;
30269 int arg2 ;
30270 int arg3 ;
30271 bool arg4 = (bool) true ;
30272 PyObject * obj0 = 0 ;
30273 PyObject * obj1 = 0 ;
30274 PyObject * obj2 = 0 ;
30275 PyObject * obj3 = 0 ;
30276 char *kwnames[] = {
30277 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30278 };
30279
30280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30282 if (SWIG_arg_fail(1)) SWIG_fail;
30283 {
30284 arg2 = (int)(SWIG_As_int(obj1));
30285 if (SWIG_arg_fail(2)) SWIG_fail;
30286 }
30287 {
30288 arg3 = (int)(SWIG_As_int(obj2));
30289 if (SWIG_arg_fail(3)) SWIG_fail;
30290 }
30291 if (obj3) {
30292 {
30293 arg4 = (bool)(SWIG_As_bool(obj3));
30294 if (SWIG_arg_fail(4)) SWIG_fail;
30295 }
30296 }
30297 {
30298 PyThreadState* __tstate = wxPyBeginAllowThreads();
30299 (arg1)->SetScrollPos(arg2,arg3,arg4);
30300
30301 wxPyEndAllowThreads(__tstate);
30302 if (PyErr_Occurred()) SWIG_fail;
30303 }
30304 Py_INCREF(Py_None); resultobj = Py_None;
30305 return resultobj;
30306 fail:
30307 return NULL;
30308 }
30309
30310
30311 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30312 PyObject *resultobj;
30313 wxWindow *arg1 = (wxWindow *) 0 ;
30314 int arg2 ;
30315 int result;
30316 PyObject * obj0 = 0 ;
30317 PyObject * obj1 = 0 ;
30318 char *kwnames[] = {
30319 (char *) "self",(char *) "orientation", NULL
30320 };
30321
30322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30324 if (SWIG_arg_fail(1)) SWIG_fail;
30325 {
30326 arg2 = (int)(SWIG_As_int(obj1));
30327 if (SWIG_arg_fail(2)) SWIG_fail;
30328 }
30329 {
30330 PyThreadState* __tstate = wxPyBeginAllowThreads();
30331 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30332
30333 wxPyEndAllowThreads(__tstate);
30334 if (PyErr_Occurred()) SWIG_fail;
30335 }
30336 {
30337 resultobj = SWIG_From_int((int)(result));
30338 }
30339 return resultobj;
30340 fail:
30341 return NULL;
30342 }
30343
30344
30345 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30346 PyObject *resultobj;
30347 wxWindow *arg1 = (wxWindow *) 0 ;
30348 int arg2 ;
30349 int result;
30350 PyObject * obj0 = 0 ;
30351 PyObject * obj1 = 0 ;
30352 char *kwnames[] = {
30353 (char *) "self",(char *) "orientation", NULL
30354 };
30355
30356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30358 if (SWIG_arg_fail(1)) SWIG_fail;
30359 {
30360 arg2 = (int)(SWIG_As_int(obj1));
30361 if (SWIG_arg_fail(2)) SWIG_fail;
30362 }
30363 {
30364 PyThreadState* __tstate = wxPyBeginAllowThreads();
30365 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30366
30367 wxPyEndAllowThreads(__tstate);
30368 if (PyErr_Occurred()) SWIG_fail;
30369 }
30370 {
30371 resultobj = SWIG_From_int((int)(result));
30372 }
30373 return resultobj;
30374 fail:
30375 return NULL;
30376 }
30377
30378
30379 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30380 PyObject *resultobj;
30381 wxWindow *arg1 = (wxWindow *) 0 ;
30382 int arg2 ;
30383 int result;
30384 PyObject * obj0 = 0 ;
30385 PyObject * obj1 = 0 ;
30386 char *kwnames[] = {
30387 (char *) "self",(char *) "orientation", NULL
30388 };
30389
30390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30392 if (SWIG_arg_fail(1)) SWIG_fail;
30393 {
30394 arg2 = (int)(SWIG_As_int(obj1));
30395 if (SWIG_arg_fail(2)) SWIG_fail;
30396 }
30397 {
30398 PyThreadState* __tstate = wxPyBeginAllowThreads();
30399 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30400
30401 wxPyEndAllowThreads(__tstate);
30402 if (PyErr_Occurred()) SWIG_fail;
30403 }
30404 {
30405 resultobj = SWIG_From_int((int)(result));
30406 }
30407 return resultobj;
30408 fail:
30409 return NULL;
30410 }
30411
30412
30413 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30414 PyObject *resultobj;
30415 wxWindow *arg1 = (wxWindow *) 0 ;
30416 int arg2 ;
30417 int arg3 ;
30418 wxRect *arg4 = (wxRect *) NULL ;
30419 PyObject * obj0 = 0 ;
30420 PyObject * obj1 = 0 ;
30421 PyObject * obj2 = 0 ;
30422 PyObject * obj3 = 0 ;
30423 char *kwnames[] = {
30424 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30425 };
30426
30427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30429 if (SWIG_arg_fail(1)) SWIG_fail;
30430 {
30431 arg2 = (int)(SWIG_As_int(obj1));
30432 if (SWIG_arg_fail(2)) SWIG_fail;
30433 }
30434 {
30435 arg3 = (int)(SWIG_As_int(obj2));
30436 if (SWIG_arg_fail(3)) SWIG_fail;
30437 }
30438 if (obj3) {
30439 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30440 if (SWIG_arg_fail(4)) SWIG_fail;
30441 }
30442 {
30443 PyThreadState* __tstate = wxPyBeginAllowThreads();
30444 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30445
30446 wxPyEndAllowThreads(__tstate);
30447 if (PyErr_Occurred()) SWIG_fail;
30448 }
30449 Py_INCREF(Py_None); resultobj = Py_None;
30450 return resultobj;
30451 fail:
30452 return NULL;
30453 }
30454
30455
30456 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30457 PyObject *resultobj;
30458 wxWindow *arg1 = (wxWindow *) 0 ;
30459 int arg2 ;
30460 bool result;
30461 PyObject * obj0 = 0 ;
30462 PyObject * obj1 = 0 ;
30463 char *kwnames[] = {
30464 (char *) "self",(char *) "lines", NULL
30465 };
30466
30467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30469 if (SWIG_arg_fail(1)) SWIG_fail;
30470 {
30471 arg2 = (int)(SWIG_As_int(obj1));
30472 if (SWIG_arg_fail(2)) SWIG_fail;
30473 }
30474 {
30475 PyThreadState* __tstate = wxPyBeginAllowThreads();
30476 result = (bool)(arg1)->ScrollLines(arg2);
30477
30478 wxPyEndAllowThreads(__tstate);
30479 if (PyErr_Occurred()) SWIG_fail;
30480 }
30481 {
30482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30483 }
30484 return resultobj;
30485 fail:
30486 return NULL;
30487 }
30488
30489
30490 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30491 PyObject *resultobj;
30492 wxWindow *arg1 = (wxWindow *) 0 ;
30493 int arg2 ;
30494 bool result;
30495 PyObject * obj0 = 0 ;
30496 PyObject * obj1 = 0 ;
30497 char *kwnames[] = {
30498 (char *) "self",(char *) "pages", NULL
30499 };
30500
30501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30503 if (SWIG_arg_fail(1)) SWIG_fail;
30504 {
30505 arg2 = (int)(SWIG_As_int(obj1));
30506 if (SWIG_arg_fail(2)) SWIG_fail;
30507 }
30508 {
30509 PyThreadState* __tstate = wxPyBeginAllowThreads();
30510 result = (bool)(arg1)->ScrollPages(arg2);
30511
30512 wxPyEndAllowThreads(__tstate);
30513 if (PyErr_Occurred()) SWIG_fail;
30514 }
30515 {
30516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30517 }
30518 return resultobj;
30519 fail:
30520 return NULL;
30521 }
30522
30523
30524 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30525 PyObject *resultobj;
30526 wxWindow *arg1 = (wxWindow *) 0 ;
30527 bool result;
30528 PyObject * obj0 = 0 ;
30529 char *kwnames[] = {
30530 (char *) "self", NULL
30531 };
30532
30533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30535 if (SWIG_arg_fail(1)) SWIG_fail;
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 result = (bool)(arg1)->LineUp();
30539
30540 wxPyEndAllowThreads(__tstate);
30541 if (PyErr_Occurred()) SWIG_fail;
30542 }
30543 {
30544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30545 }
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30553 PyObject *resultobj;
30554 wxWindow *arg1 = (wxWindow *) 0 ;
30555 bool result;
30556 PyObject * obj0 = 0 ;
30557 char *kwnames[] = {
30558 (char *) "self", NULL
30559 };
30560
30561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30563 if (SWIG_arg_fail(1)) SWIG_fail;
30564 {
30565 PyThreadState* __tstate = wxPyBeginAllowThreads();
30566 result = (bool)(arg1)->LineDown();
30567
30568 wxPyEndAllowThreads(__tstate);
30569 if (PyErr_Occurred()) SWIG_fail;
30570 }
30571 {
30572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30573 }
30574 return resultobj;
30575 fail:
30576 return NULL;
30577 }
30578
30579
30580 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30581 PyObject *resultobj;
30582 wxWindow *arg1 = (wxWindow *) 0 ;
30583 bool result;
30584 PyObject * obj0 = 0 ;
30585 char *kwnames[] = {
30586 (char *) "self", NULL
30587 };
30588
30589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30591 if (SWIG_arg_fail(1)) SWIG_fail;
30592 {
30593 PyThreadState* __tstate = wxPyBeginAllowThreads();
30594 result = (bool)(arg1)->PageUp();
30595
30596 wxPyEndAllowThreads(__tstate);
30597 if (PyErr_Occurred()) SWIG_fail;
30598 }
30599 {
30600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30601 }
30602 return resultobj;
30603 fail:
30604 return NULL;
30605 }
30606
30607
30608 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30609 PyObject *resultobj;
30610 wxWindow *arg1 = (wxWindow *) 0 ;
30611 bool result;
30612 PyObject * obj0 = 0 ;
30613 char *kwnames[] = {
30614 (char *) "self", NULL
30615 };
30616
30617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30619 if (SWIG_arg_fail(1)) SWIG_fail;
30620 {
30621 PyThreadState* __tstate = wxPyBeginAllowThreads();
30622 result = (bool)(arg1)->PageDown();
30623
30624 wxPyEndAllowThreads(__tstate);
30625 if (PyErr_Occurred()) SWIG_fail;
30626 }
30627 {
30628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30629 }
30630 return resultobj;
30631 fail:
30632 return NULL;
30633 }
30634
30635
30636 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30637 PyObject *resultobj;
30638 wxWindow *arg1 = (wxWindow *) 0 ;
30639 wxString *arg2 = 0 ;
30640 bool temp2 = false ;
30641 PyObject * obj0 = 0 ;
30642 PyObject * obj1 = 0 ;
30643 char *kwnames[] = {
30644 (char *) "self",(char *) "text", NULL
30645 };
30646
30647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30649 if (SWIG_arg_fail(1)) SWIG_fail;
30650 {
30651 arg2 = wxString_in_helper(obj1);
30652 if (arg2 == NULL) SWIG_fail;
30653 temp2 = true;
30654 }
30655 {
30656 PyThreadState* __tstate = wxPyBeginAllowThreads();
30657 (arg1)->SetHelpText((wxString const &)*arg2);
30658
30659 wxPyEndAllowThreads(__tstate);
30660 if (PyErr_Occurred()) SWIG_fail;
30661 }
30662 Py_INCREF(Py_None); resultobj = Py_None;
30663 {
30664 if (temp2)
30665 delete arg2;
30666 }
30667 return resultobj;
30668 fail:
30669 {
30670 if (temp2)
30671 delete arg2;
30672 }
30673 return NULL;
30674 }
30675
30676
30677 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30678 PyObject *resultobj;
30679 wxWindow *arg1 = (wxWindow *) 0 ;
30680 wxString *arg2 = 0 ;
30681 bool temp2 = false ;
30682 PyObject * obj0 = 0 ;
30683 PyObject * obj1 = 0 ;
30684 char *kwnames[] = {
30685 (char *) "self",(char *) "text", NULL
30686 };
30687
30688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30690 if (SWIG_arg_fail(1)) SWIG_fail;
30691 {
30692 arg2 = wxString_in_helper(obj1);
30693 if (arg2 == NULL) SWIG_fail;
30694 temp2 = true;
30695 }
30696 {
30697 PyThreadState* __tstate = wxPyBeginAllowThreads();
30698 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30699
30700 wxPyEndAllowThreads(__tstate);
30701 if (PyErr_Occurred()) SWIG_fail;
30702 }
30703 Py_INCREF(Py_None); resultobj = Py_None;
30704 {
30705 if (temp2)
30706 delete arg2;
30707 }
30708 return resultobj;
30709 fail:
30710 {
30711 if (temp2)
30712 delete arg2;
30713 }
30714 return NULL;
30715 }
30716
30717
30718 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30719 PyObject *resultobj;
30720 wxWindow *arg1 = (wxWindow *) 0 ;
30721 wxString result;
30722 PyObject * obj0 = 0 ;
30723 char *kwnames[] = {
30724 (char *) "self", NULL
30725 };
30726
30727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
30728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30729 if (SWIG_arg_fail(1)) SWIG_fail;
30730 {
30731 PyThreadState* __tstate = wxPyBeginAllowThreads();
30732 result = ((wxWindow const *)arg1)->GetHelpText();
30733
30734 wxPyEndAllowThreads(__tstate);
30735 if (PyErr_Occurred()) SWIG_fail;
30736 }
30737 {
30738 #if wxUSE_UNICODE
30739 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30740 #else
30741 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30742 #endif
30743 }
30744 return resultobj;
30745 fail:
30746 return NULL;
30747 }
30748
30749
30750 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
30751 PyObject *resultobj;
30752 wxWindow *arg1 = (wxWindow *) 0 ;
30753 wxString *arg2 = 0 ;
30754 bool temp2 = false ;
30755 PyObject * obj0 = 0 ;
30756 PyObject * obj1 = 0 ;
30757 char *kwnames[] = {
30758 (char *) "self",(char *) "tip", NULL
30759 };
30760
30761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
30762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30763 if (SWIG_arg_fail(1)) SWIG_fail;
30764 {
30765 arg2 = wxString_in_helper(obj1);
30766 if (arg2 == NULL) SWIG_fail;
30767 temp2 = true;
30768 }
30769 {
30770 PyThreadState* __tstate = wxPyBeginAllowThreads();
30771 (arg1)->SetToolTip((wxString const &)*arg2);
30772
30773 wxPyEndAllowThreads(__tstate);
30774 if (PyErr_Occurred()) SWIG_fail;
30775 }
30776 Py_INCREF(Py_None); resultobj = Py_None;
30777 {
30778 if (temp2)
30779 delete arg2;
30780 }
30781 return resultobj;
30782 fail:
30783 {
30784 if (temp2)
30785 delete arg2;
30786 }
30787 return NULL;
30788 }
30789
30790
30791 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30792 PyObject *resultobj;
30793 wxWindow *arg1 = (wxWindow *) 0 ;
30794 wxToolTip *arg2 = (wxToolTip *) 0 ;
30795 PyObject * obj0 = 0 ;
30796 PyObject * obj1 = 0 ;
30797 char *kwnames[] = {
30798 (char *) "self",(char *) "tip", NULL
30799 };
30800
30801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
30802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30803 if (SWIG_arg_fail(1)) SWIG_fail;
30804 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
30805 if (SWIG_arg_fail(2)) SWIG_fail;
30806 {
30807 PyThreadState* __tstate = wxPyBeginAllowThreads();
30808 (arg1)->SetToolTip(arg2);
30809
30810 wxPyEndAllowThreads(__tstate);
30811 if (PyErr_Occurred()) SWIG_fail;
30812 }
30813 Py_INCREF(Py_None); resultobj = Py_None;
30814 return resultobj;
30815 fail:
30816 return NULL;
30817 }
30818
30819
30820 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30821 PyObject *resultobj;
30822 wxWindow *arg1 = (wxWindow *) 0 ;
30823 wxToolTip *result;
30824 PyObject * obj0 = 0 ;
30825 char *kwnames[] = {
30826 (char *) "self", NULL
30827 };
30828
30829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
30830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30831 if (SWIG_arg_fail(1)) SWIG_fail;
30832 {
30833 PyThreadState* __tstate = wxPyBeginAllowThreads();
30834 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
30835
30836 wxPyEndAllowThreads(__tstate);
30837 if (PyErr_Occurred()) SWIG_fail;
30838 }
30839 {
30840 resultobj = wxPyMake_wxObject(result, 0);
30841 }
30842 return resultobj;
30843 fail:
30844 return NULL;
30845 }
30846
30847
30848 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30849 PyObject *resultobj;
30850 wxWindow *arg1 = (wxWindow *) 0 ;
30851 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
30852 PyObject * obj0 = 0 ;
30853 PyObject * obj1 = 0 ;
30854 char *kwnames[] = {
30855 (char *) "self",(char *) "dropTarget", NULL
30856 };
30857
30858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
30859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30860 if (SWIG_arg_fail(1)) SWIG_fail;
30861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30862 if (SWIG_arg_fail(2)) SWIG_fail;
30863 {
30864 PyThreadState* __tstate = wxPyBeginAllowThreads();
30865 (arg1)->SetDropTarget(arg2);
30866
30867 wxPyEndAllowThreads(__tstate);
30868 if (PyErr_Occurred()) SWIG_fail;
30869 }
30870 Py_INCREF(Py_None); resultobj = Py_None;
30871 return resultobj;
30872 fail:
30873 return NULL;
30874 }
30875
30876
30877 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30878 PyObject *resultobj;
30879 wxWindow *arg1 = (wxWindow *) 0 ;
30880 wxPyDropTarget *result;
30881 PyObject * obj0 = 0 ;
30882 char *kwnames[] = {
30883 (char *) "self", NULL
30884 };
30885
30886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
30887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30888 if (SWIG_arg_fail(1)) SWIG_fail;
30889 {
30890 PyThreadState* __tstate = wxPyBeginAllowThreads();
30891 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
30892
30893 wxPyEndAllowThreads(__tstate);
30894 if (PyErr_Occurred()) SWIG_fail;
30895 }
30896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
30897 return resultobj;
30898 fail:
30899 return NULL;
30900 }
30901
30902
30903 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
30904 PyObject *resultobj;
30905 wxWindow *arg1 = (wxWindow *) 0 ;
30906 bool arg2 ;
30907 PyObject * obj0 = 0 ;
30908 PyObject * obj1 = 0 ;
30909 char *kwnames[] = {
30910 (char *) "self",(char *) "accept", NULL
30911 };
30912
30913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
30914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30915 if (SWIG_arg_fail(1)) SWIG_fail;
30916 {
30917 arg2 = (bool)(SWIG_As_bool(obj1));
30918 if (SWIG_arg_fail(2)) SWIG_fail;
30919 }
30920 {
30921 PyThreadState* __tstate = wxPyBeginAllowThreads();
30922 (arg1)->DragAcceptFiles(arg2);
30923
30924 wxPyEndAllowThreads(__tstate);
30925 if (PyErr_Occurred()) SWIG_fail;
30926 }
30927 Py_INCREF(Py_None); resultobj = Py_None;
30928 return resultobj;
30929 fail:
30930 return NULL;
30931 }
30932
30933
30934 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30935 PyObject *resultobj;
30936 wxWindow *arg1 = (wxWindow *) 0 ;
30937 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
30938 PyObject * obj0 = 0 ;
30939 PyObject * obj1 = 0 ;
30940 char *kwnames[] = {
30941 (char *) "self",(char *) "constraints", NULL
30942 };
30943
30944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
30945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30946 if (SWIG_arg_fail(1)) SWIG_fail;
30947 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
30948 if (SWIG_arg_fail(2)) SWIG_fail;
30949 {
30950 PyThreadState* __tstate = wxPyBeginAllowThreads();
30951 (arg1)->SetConstraints(arg2);
30952
30953 wxPyEndAllowThreads(__tstate);
30954 if (PyErr_Occurred()) SWIG_fail;
30955 }
30956 Py_INCREF(Py_None); resultobj = Py_None;
30957 return resultobj;
30958 fail:
30959 return NULL;
30960 }
30961
30962
30963 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30964 PyObject *resultobj;
30965 wxWindow *arg1 = (wxWindow *) 0 ;
30966 wxLayoutConstraints *result;
30967 PyObject * obj0 = 0 ;
30968 char *kwnames[] = {
30969 (char *) "self", NULL
30970 };
30971
30972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
30973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30974 if (SWIG_arg_fail(1)) SWIG_fail;
30975 {
30976 PyThreadState* __tstate = wxPyBeginAllowThreads();
30977 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
30978
30979 wxPyEndAllowThreads(__tstate);
30980 if (PyErr_Occurred()) SWIG_fail;
30981 }
30982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
30983 return resultobj;
30984 fail:
30985 return NULL;
30986 }
30987
30988
30989 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30990 PyObject *resultobj;
30991 wxWindow *arg1 = (wxWindow *) 0 ;
30992 bool arg2 ;
30993 PyObject * obj0 = 0 ;
30994 PyObject * obj1 = 0 ;
30995 char *kwnames[] = {
30996 (char *) "self",(char *) "autoLayout", NULL
30997 };
30998
30999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31001 if (SWIG_arg_fail(1)) SWIG_fail;
31002 {
31003 arg2 = (bool)(SWIG_As_bool(obj1));
31004 if (SWIG_arg_fail(2)) SWIG_fail;
31005 }
31006 {
31007 PyThreadState* __tstate = wxPyBeginAllowThreads();
31008 (arg1)->SetAutoLayout(arg2);
31009
31010 wxPyEndAllowThreads(__tstate);
31011 if (PyErr_Occurred()) SWIG_fail;
31012 }
31013 Py_INCREF(Py_None); resultobj = Py_None;
31014 return resultobj;
31015 fail:
31016 return NULL;
31017 }
31018
31019
31020 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31021 PyObject *resultobj;
31022 wxWindow *arg1 = (wxWindow *) 0 ;
31023 bool result;
31024 PyObject * obj0 = 0 ;
31025 char *kwnames[] = {
31026 (char *) "self", NULL
31027 };
31028
31029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31031 if (SWIG_arg_fail(1)) SWIG_fail;
31032 {
31033 PyThreadState* __tstate = wxPyBeginAllowThreads();
31034 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31035
31036 wxPyEndAllowThreads(__tstate);
31037 if (PyErr_Occurred()) SWIG_fail;
31038 }
31039 {
31040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31041 }
31042 return resultobj;
31043 fail:
31044 return NULL;
31045 }
31046
31047
31048 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31049 PyObject *resultobj;
31050 wxWindow *arg1 = (wxWindow *) 0 ;
31051 bool result;
31052 PyObject * obj0 = 0 ;
31053 char *kwnames[] = {
31054 (char *) "self", NULL
31055 };
31056
31057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31059 if (SWIG_arg_fail(1)) SWIG_fail;
31060 {
31061 PyThreadState* __tstate = wxPyBeginAllowThreads();
31062 result = (bool)(arg1)->Layout();
31063
31064 wxPyEndAllowThreads(__tstate);
31065 if (PyErr_Occurred()) SWIG_fail;
31066 }
31067 {
31068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31069 }
31070 return resultobj;
31071 fail:
31072 return NULL;
31073 }
31074
31075
31076 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31077 PyObject *resultobj;
31078 wxWindow *arg1 = (wxWindow *) 0 ;
31079 wxSizer *arg2 = (wxSizer *) 0 ;
31080 bool arg3 = (bool) true ;
31081 PyObject * obj0 = 0 ;
31082 PyObject * obj1 = 0 ;
31083 PyObject * obj2 = 0 ;
31084 char *kwnames[] = {
31085 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31086 };
31087
31088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31090 if (SWIG_arg_fail(1)) SWIG_fail;
31091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31092 if (SWIG_arg_fail(2)) SWIG_fail;
31093 if (obj2) {
31094 {
31095 arg3 = (bool)(SWIG_As_bool(obj2));
31096 if (SWIG_arg_fail(3)) SWIG_fail;
31097 }
31098 }
31099 {
31100 PyThreadState* __tstate = wxPyBeginAllowThreads();
31101 (arg1)->SetSizer(arg2,arg3);
31102
31103 wxPyEndAllowThreads(__tstate);
31104 if (PyErr_Occurred()) SWIG_fail;
31105 }
31106 Py_INCREF(Py_None); resultobj = Py_None;
31107 return resultobj;
31108 fail:
31109 return NULL;
31110 }
31111
31112
31113 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31114 PyObject *resultobj;
31115 wxWindow *arg1 = (wxWindow *) 0 ;
31116 wxSizer *arg2 = (wxSizer *) 0 ;
31117 bool arg3 = (bool) true ;
31118 PyObject * obj0 = 0 ;
31119 PyObject * obj1 = 0 ;
31120 PyObject * obj2 = 0 ;
31121 char *kwnames[] = {
31122 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31123 };
31124
31125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31127 if (SWIG_arg_fail(1)) SWIG_fail;
31128 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31129 if (SWIG_arg_fail(2)) SWIG_fail;
31130 if (obj2) {
31131 {
31132 arg3 = (bool)(SWIG_As_bool(obj2));
31133 if (SWIG_arg_fail(3)) SWIG_fail;
31134 }
31135 }
31136 {
31137 PyThreadState* __tstate = wxPyBeginAllowThreads();
31138 (arg1)->SetSizerAndFit(arg2,arg3);
31139
31140 wxPyEndAllowThreads(__tstate);
31141 if (PyErr_Occurred()) SWIG_fail;
31142 }
31143 Py_INCREF(Py_None); resultobj = Py_None;
31144 return resultobj;
31145 fail:
31146 return NULL;
31147 }
31148
31149
31150 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31151 PyObject *resultobj;
31152 wxWindow *arg1 = (wxWindow *) 0 ;
31153 wxSizer *result;
31154 PyObject * obj0 = 0 ;
31155 char *kwnames[] = {
31156 (char *) "self", NULL
31157 };
31158
31159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31161 if (SWIG_arg_fail(1)) SWIG_fail;
31162 {
31163 PyThreadState* __tstate = wxPyBeginAllowThreads();
31164 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31165
31166 wxPyEndAllowThreads(__tstate);
31167 if (PyErr_Occurred()) SWIG_fail;
31168 }
31169 {
31170 resultobj = wxPyMake_wxSizer(result, 0);
31171 }
31172 return resultobj;
31173 fail:
31174 return NULL;
31175 }
31176
31177
31178 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31179 PyObject *resultobj;
31180 wxWindow *arg1 = (wxWindow *) 0 ;
31181 wxSizer *arg2 = (wxSizer *) 0 ;
31182 PyObject * obj0 = 0 ;
31183 PyObject * obj1 = 0 ;
31184 char *kwnames[] = {
31185 (char *) "self",(char *) "sizer", NULL
31186 };
31187
31188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31190 if (SWIG_arg_fail(1)) SWIG_fail;
31191 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31192 if (SWIG_arg_fail(2)) SWIG_fail;
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 (arg1)->SetContainingSizer(arg2);
31196
31197 wxPyEndAllowThreads(__tstate);
31198 if (PyErr_Occurred()) SWIG_fail;
31199 }
31200 Py_INCREF(Py_None); resultobj = Py_None;
31201 return resultobj;
31202 fail:
31203 return NULL;
31204 }
31205
31206
31207 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31208 PyObject *resultobj;
31209 wxWindow *arg1 = (wxWindow *) 0 ;
31210 wxSizer *result;
31211 PyObject * obj0 = 0 ;
31212 char *kwnames[] = {
31213 (char *) "self", NULL
31214 };
31215
31216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31218 if (SWIG_arg_fail(1)) SWIG_fail;
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31222
31223 wxPyEndAllowThreads(__tstate);
31224 if (PyErr_Occurred()) SWIG_fail;
31225 }
31226 {
31227 resultobj = wxPyMake_wxSizer(result, 0);
31228 }
31229 return resultobj;
31230 fail:
31231 return NULL;
31232 }
31233
31234
31235 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31236 PyObject *resultobj;
31237 wxWindow *arg1 = (wxWindow *) 0 ;
31238 PyObject * obj0 = 0 ;
31239 char *kwnames[] = {
31240 (char *) "self", NULL
31241 };
31242
31243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31245 if (SWIG_arg_fail(1)) SWIG_fail;
31246 {
31247 PyThreadState* __tstate = wxPyBeginAllowThreads();
31248 (arg1)->InheritAttributes();
31249
31250 wxPyEndAllowThreads(__tstate);
31251 if (PyErr_Occurred()) SWIG_fail;
31252 }
31253 Py_INCREF(Py_None); resultobj = Py_None;
31254 return resultobj;
31255 fail:
31256 return NULL;
31257 }
31258
31259
31260 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31261 PyObject *resultobj;
31262 wxWindow *arg1 = (wxWindow *) 0 ;
31263 bool result;
31264 PyObject * obj0 = 0 ;
31265 char *kwnames[] = {
31266 (char *) "self", NULL
31267 };
31268
31269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31271 if (SWIG_arg_fail(1)) SWIG_fail;
31272 {
31273 PyThreadState* __tstate = wxPyBeginAllowThreads();
31274 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31275
31276 wxPyEndAllowThreads(__tstate);
31277 if (PyErr_Occurred()) SWIG_fail;
31278 }
31279 {
31280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31281 }
31282 return resultobj;
31283 fail:
31284 return NULL;
31285 }
31286
31287
31288 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31289 PyObject *obj;
31290 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31291 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31292 Py_INCREF(obj);
31293 return Py_BuildValue((char *)"");
31294 }
31295 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31296 PyObject *resultobj;
31297 long arg1 ;
31298 wxWindow *arg2 = (wxWindow *) NULL ;
31299 wxWindow *result;
31300 PyObject * obj0 = 0 ;
31301 PyObject * obj1 = 0 ;
31302 char *kwnames[] = {
31303 (char *) "id",(char *) "parent", NULL
31304 };
31305
31306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31307 {
31308 arg1 = (long)(SWIG_As_long(obj0));
31309 if (SWIG_arg_fail(1)) SWIG_fail;
31310 }
31311 if (obj1) {
31312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31313 if (SWIG_arg_fail(2)) SWIG_fail;
31314 }
31315 {
31316 if (!wxPyCheckForApp()) SWIG_fail;
31317 PyThreadState* __tstate = wxPyBeginAllowThreads();
31318 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31319
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 {
31324 resultobj = wxPyMake_wxObject(result, 0);
31325 }
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31333 PyObject *resultobj;
31334 wxString *arg1 = 0 ;
31335 wxWindow *arg2 = (wxWindow *) NULL ;
31336 wxWindow *result;
31337 bool temp1 = false ;
31338 PyObject * obj0 = 0 ;
31339 PyObject * obj1 = 0 ;
31340 char *kwnames[] = {
31341 (char *) "name",(char *) "parent", NULL
31342 };
31343
31344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31345 {
31346 arg1 = wxString_in_helper(obj0);
31347 if (arg1 == NULL) SWIG_fail;
31348 temp1 = true;
31349 }
31350 if (obj1) {
31351 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31352 if (SWIG_arg_fail(2)) SWIG_fail;
31353 }
31354 {
31355 if (!wxPyCheckForApp()) SWIG_fail;
31356 PyThreadState* __tstate = wxPyBeginAllowThreads();
31357 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31358
31359 wxPyEndAllowThreads(__tstate);
31360 if (PyErr_Occurred()) SWIG_fail;
31361 }
31362 {
31363 resultobj = wxPyMake_wxObject(result, 0);
31364 }
31365 {
31366 if (temp1)
31367 delete arg1;
31368 }
31369 return resultobj;
31370 fail:
31371 {
31372 if (temp1)
31373 delete arg1;
31374 }
31375 return NULL;
31376 }
31377
31378
31379 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31380 PyObject *resultobj;
31381 wxString *arg1 = 0 ;
31382 wxWindow *arg2 = (wxWindow *) NULL ;
31383 wxWindow *result;
31384 bool temp1 = false ;
31385 PyObject * obj0 = 0 ;
31386 PyObject * obj1 = 0 ;
31387 char *kwnames[] = {
31388 (char *) "label",(char *) "parent", NULL
31389 };
31390
31391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31392 {
31393 arg1 = wxString_in_helper(obj0);
31394 if (arg1 == NULL) SWIG_fail;
31395 temp1 = true;
31396 }
31397 if (obj1) {
31398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31399 if (SWIG_arg_fail(2)) SWIG_fail;
31400 }
31401 {
31402 if (!wxPyCheckForApp()) SWIG_fail;
31403 PyThreadState* __tstate = wxPyBeginAllowThreads();
31404 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31405
31406 wxPyEndAllowThreads(__tstate);
31407 if (PyErr_Occurred()) SWIG_fail;
31408 }
31409 {
31410 resultobj = wxPyMake_wxObject(result, 0);
31411 }
31412 {
31413 if (temp1)
31414 delete arg1;
31415 }
31416 return resultobj;
31417 fail:
31418 {
31419 if (temp1)
31420 delete arg1;
31421 }
31422 return NULL;
31423 }
31424
31425
31426 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31427 PyObject *resultobj;
31428 wxWindow *arg1 = (wxWindow *) 0 ;
31429 unsigned long arg2 ;
31430 wxWindow *result;
31431 PyObject * obj0 = 0 ;
31432 PyObject * obj1 = 0 ;
31433 char *kwnames[] = {
31434 (char *) "parent",(char *) "_hWnd", NULL
31435 };
31436
31437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31439 if (SWIG_arg_fail(1)) SWIG_fail;
31440 {
31441 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31442 if (SWIG_arg_fail(2)) SWIG_fail;
31443 }
31444 {
31445 PyThreadState* __tstate = wxPyBeginAllowThreads();
31446 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31447
31448 wxPyEndAllowThreads(__tstate);
31449 if (PyErr_Occurred()) SWIG_fail;
31450 }
31451 {
31452 resultobj = wxPyMake_wxObject(result, 0);
31453 }
31454 return resultobj;
31455 fail:
31456 return NULL;
31457 }
31458
31459
31460 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31461 PyObject *resultobj;
31462 wxValidator *result;
31463 char *kwnames[] = {
31464 NULL
31465 };
31466
31467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31468 {
31469 PyThreadState* __tstate = wxPyBeginAllowThreads();
31470 result = (wxValidator *)new wxValidator();
31471
31472 wxPyEndAllowThreads(__tstate);
31473 if (PyErr_Occurred()) SWIG_fail;
31474 }
31475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31476 return resultobj;
31477 fail:
31478 return NULL;
31479 }
31480
31481
31482 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31483 PyObject *resultobj;
31484 wxValidator *arg1 = (wxValidator *) 0 ;
31485 wxValidator *result;
31486 PyObject * obj0 = 0 ;
31487 char *kwnames[] = {
31488 (char *) "self", NULL
31489 };
31490
31491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31493 if (SWIG_arg_fail(1)) SWIG_fail;
31494 {
31495 PyThreadState* __tstate = wxPyBeginAllowThreads();
31496 result = (wxValidator *)(arg1)->Clone();
31497
31498 wxPyEndAllowThreads(__tstate);
31499 if (PyErr_Occurred()) SWIG_fail;
31500 }
31501 {
31502 resultobj = wxPyMake_wxObject(result, 0);
31503 }
31504 return resultobj;
31505 fail:
31506 return NULL;
31507 }
31508
31509
31510 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31511 PyObject *resultobj;
31512 wxValidator *arg1 = (wxValidator *) 0 ;
31513 wxWindow *arg2 = (wxWindow *) 0 ;
31514 bool result;
31515 PyObject * obj0 = 0 ;
31516 PyObject * obj1 = 0 ;
31517 char *kwnames[] = {
31518 (char *) "self",(char *) "parent", NULL
31519 };
31520
31521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31523 if (SWIG_arg_fail(1)) SWIG_fail;
31524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31525 if (SWIG_arg_fail(2)) SWIG_fail;
31526 {
31527 PyThreadState* __tstate = wxPyBeginAllowThreads();
31528 result = (bool)(arg1)->Validate(arg2);
31529
31530 wxPyEndAllowThreads(__tstate);
31531 if (PyErr_Occurred()) SWIG_fail;
31532 }
31533 {
31534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31535 }
31536 return resultobj;
31537 fail:
31538 return NULL;
31539 }
31540
31541
31542 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31543 PyObject *resultobj;
31544 wxValidator *arg1 = (wxValidator *) 0 ;
31545 bool result;
31546 PyObject * obj0 = 0 ;
31547 char *kwnames[] = {
31548 (char *) "self", NULL
31549 };
31550
31551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31553 if (SWIG_arg_fail(1)) SWIG_fail;
31554 {
31555 PyThreadState* __tstate = wxPyBeginAllowThreads();
31556 result = (bool)(arg1)->TransferToWindow();
31557
31558 wxPyEndAllowThreads(__tstate);
31559 if (PyErr_Occurred()) SWIG_fail;
31560 }
31561 {
31562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31563 }
31564 return resultobj;
31565 fail:
31566 return NULL;
31567 }
31568
31569
31570 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31571 PyObject *resultobj;
31572 wxValidator *arg1 = (wxValidator *) 0 ;
31573 bool result;
31574 PyObject * obj0 = 0 ;
31575 char *kwnames[] = {
31576 (char *) "self", NULL
31577 };
31578
31579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31581 if (SWIG_arg_fail(1)) SWIG_fail;
31582 {
31583 PyThreadState* __tstate = wxPyBeginAllowThreads();
31584 result = (bool)(arg1)->TransferFromWindow();
31585
31586 wxPyEndAllowThreads(__tstate);
31587 if (PyErr_Occurred()) SWIG_fail;
31588 }
31589 {
31590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31591 }
31592 return resultobj;
31593 fail:
31594 return NULL;
31595 }
31596
31597
31598 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31599 PyObject *resultobj;
31600 wxValidator *arg1 = (wxValidator *) 0 ;
31601 wxWindow *result;
31602 PyObject * obj0 = 0 ;
31603 char *kwnames[] = {
31604 (char *) "self", NULL
31605 };
31606
31607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31609 if (SWIG_arg_fail(1)) SWIG_fail;
31610 {
31611 PyThreadState* __tstate = wxPyBeginAllowThreads();
31612 result = (wxWindow *)(arg1)->GetWindow();
31613
31614 wxPyEndAllowThreads(__tstate);
31615 if (PyErr_Occurred()) SWIG_fail;
31616 }
31617 {
31618 resultobj = wxPyMake_wxObject(result, 0);
31619 }
31620 return resultobj;
31621 fail:
31622 return NULL;
31623 }
31624
31625
31626 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31627 PyObject *resultobj;
31628 wxValidator *arg1 = (wxValidator *) 0 ;
31629 wxWindow *arg2 = (wxWindow *) 0 ;
31630 PyObject * obj0 = 0 ;
31631 PyObject * obj1 = 0 ;
31632 char *kwnames[] = {
31633 (char *) "self",(char *) "window", NULL
31634 };
31635
31636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31638 if (SWIG_arg_fail(1)) SWIG_fail;
31639 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31640 if (SWIG_arg_fail(2)) SWIG_fail;
31641 {
31642 PyThreadState* __tstate = wxPyBeginAllowThreads();
31643 (arg1)->SetWindow(arg2);
31644
31645 wxPyEndAllowThreads(__tstate);
31646 if (PyErr_Occurred()) SWIG_fail;
31647 }
31648 Py_INCREF(Py_None); resultobj = Py_None;
31649 return resultobj;
31650 fail:
31651 return NULL;
31652 }
31653
31654
31655 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31656 PyObject *resultobj;
31657 bool result;
31658 char *kwnames[] = {
31659 NULL
31660 };
31661
31662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31663 {
31664 PyThreadState* __tstate = wxPyBeginAllowThreads();
31665 result = (bool)wxValidator::IsSilent();
31666
31667 wxPyEndAllowThreads(__tstate);
31668 if (PyErr_Occurred()) SWIG_fail;
31669 }
31670 {
31671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31672 }
31673 return resultobj;
31674 fail:
31675 return NULL;
31676 }
31677
31678
31679 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31680 PyObject *resultobj;
31681 int arg1 = (int) true ;
31682 PyObject * obj0 = 0 ;
31683 char *kwnames[] = {
31684 (char *) "doIt", NULL
31685 };
31686
31687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31688 if (obj0) {
31689 {
31690 arg1 = (int)(SWIG_As_int(obj0));
31691 if (SWIG_arg_fail(1)) SWIG_fail;
31692 }
31693 }
31694 {
31695 PyThreadState* __tstate = wxPyBeginAllowThreads();
31696 wxValidator::SetBellOnError(arg1);
31697
31698 wxPyEndAllowThreads(__tstate);
31699 if (PyErr_Occurred()) SWIG_fail;
31700 }
31701 Py_INCREF(Py_None); resultobj = Py_None;
31702 return resultobj;
31703 fail:
31704 return NULL;
31705 }
31706
31707
31708 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31709 PyObject *obj;
31710 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31711 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31712 Py_INCREF(obj);
31713 return Py_BuildValue((char *)"");
31714 }
31715 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31716 PyObject *resultobj;
31717 wxPyValidator *result;
31718 char *kwnames[] = {
31719 NULL
31720 };
31721
31722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31723 {
31724 PyThreadState* __tstate = wxPyBeginAllowThreads();
31725 result = (wxPyValidator *)new wxPyValidator();
31726
31727 wxPyEndAllowThreads(__tstate);
31728 if (PyErr_Occurred()) SWIG_fail;
31729 }
31730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31731 return resultobj;
31732 fail:
31733 return NULL;
31734 }
31735
31736
31737 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31738 PyObject *resultobj;
31739 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31740 PyObject *arg2 = (PyObject *) 0 ;
31741 PyObject *arg3 = (PyObject *) 0 ;
31742 int arg4 = (int) true ;
31743 PyObject * obj0 = 0 ;
31744 PyObject * obj1 = 0 ;
31745 PyObject * obj2 = 0 ;
31746 PyObject * obj3 = 0 ;
31747 char *kwnames[] = {
31748 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
31749 };
31750
31751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
31753 if (SWIG_arg_fail(1)) SWIG_fail;
31754 arg2 = obj1;
31755 arg3 = obj2;
31756 if (obj3) {
31757 {
31758 arg4 = (int)(SWIG_As_int(obj3));
31759 if (SWIG_arg_fail(4)) SWIG_fail;
31760 }
31761 }
31762 {
31763 PyThreadState* __tstate = wxPyBeginAllowThreads();
31764 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
31765
31766 wxPyEndAllowThreads(__tstate);
31767 if (PyErr_Occurred()) SWIG_fail;
31768 }
31769 Py_INCREF(Py_None); resultobj = Py_None;
31770 return resultobj;
31771 fail:
31772 return NULL;
31773 }
31774
31775
31776 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
31777 PyObject *obj;
31778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31779 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
31780 Py_INCREF(obj);
31781 return Py_BuildValue((char *)"");
31782 }
31783 static int _wrap_DefaultValidator_set(PyObject *) {
31784 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
31785 return 1;
31786 }
31787
31788
31789 static PyObject *_wrap_DefaultValidator_get(void) {
31790 PyObject *pyobj;
31791
31792 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
31793 return pyobj;
31794 }
31795
31796
31797 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
31798 PyObject *resultobj;
31799 wxString const &arg1_defvalue = wxPyEmptyString ;
31800 wxString *arg1 = (wxString *) &arg1_defvalue ;
31801 long arg2 = (long) 0 ;
31802 wxMenu *result;
31803 bool temp1 = false ;
31804 PyObject * obj0 = 0 ;
31805 PyObject * obj1 = 0 ;
31806 char *kwnames[] = {
31807 (char *) "title",(char *) "style", NULL
31808 };
31809
31810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
31811 if (obj0) {
31812 {
31813 arg1 = wxString_in_helper(obj0);
31814 if (arg1 == NULL) SWIG_fail;
31815 temp1 = true;
31816 }
31817 }
31818 if (obj1) {
31819 {
31820 arg2 = (long)(SWIG_As_long(obj1));
31821 if (SWIG_arg_fail(2)) SWIG_fail;
31822 }
31823 }
31824 {
31825 if (!wxPyCheckForApp()) SWIG_fail;
31826 PyThreadState* __tstate = wxPyBeginAllowThreads();
31827 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
31828
31829 wxPyEndAllowThreads(__tstate);
31830 if (PyErr_Occurred()) SWIG_fail;
31831 }
31832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
31833 {
31834 if (temp1)
31835 delete arg1;
31836 }
31837 return resultobj;
31838 fail:
31839 {
31840 if (temp1)
31841 delete arg1;
31842 }
31843 return NULL;
31844 }
31845
31846
31847 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
31848 PyObject *resultobj;
31849 wxMenu *arg1 = (wxMenu *) 0 ;
31850 int arg2 ;
31851 wxString *arg3 = 0 ;
31852 wxString const &arg4_defvalue = wxPyEmptyString ;
31853 wxString *arg4 = (wxString *) &arg4_defvalue ;
31854 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
31855 wxMenuItem *result;
31856 bool temp3 = false ;
31857 bool temp4 = false ;
31858 PyObject * obj0 = 0 ;
31859 PyObject * obj1 = 0 ;
31860 PyObject * obj2 = 0 ;
31861 PyObject * obj3 = 0 ;
31862 PyObject * obj4 = 0 ;
31863 char *kwnames[] = {
31864 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
31865 };
31866
31867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
31868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31869 if (SWIG_arg_fail(1)) SWIG_fail;
31870 {
31871 arg2 = (int)(SWIG_As_int(obj1));
31872 if (SWIG_arg_fail(2)) SWIG_fail;
31873 }
31874 {
31875 arg3 = wxString_in_helper(obj2);
31876 if (arg3 == NULL) SWIG_fail;
31877 temp3 = true;
31878 }
31879 if (obj3) {
31880 {
31881 arg4 = wxString_in_helper(obj3);
31882 if (arg4 == NULL) SWIG_fail;
31883 temp4 = true;
31884 }
31885 }
31886 if (obj4) {
31887 {
31888 arg5 = (wxItemKind)(SWIG_As_int(obj4));
31889 if (SWIG_arg_fail(5)) SWIG_fail;
31890 }
31891 }
31892 {
31893 PyThreadState* __tstate = wxPyBeginAllowThreads();
31894 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
31895
31896 wxPyEndAllowThreads(__tstate);
31897 if (PyErr_Occurred()) SWIG_fail;
31898 }
31899 {
31900 resultobj = wxPyMake_wxObject(result, 0);
31901 }
31902 {
31903 if (temp3)
31904 delete arg3;
31905 }
31906 {
31907 if (temp4)
31908 delete arg4;
31909 }
31910 return resultobj;
31911 fail:
31912 {
31913 if (temp3)
31914 delete arg3;
31915 }
31916 {
31917 if (temp4)
31918 delete arg4;
31919 }
31920 return NULL;
31921 }
31922
31923
31924 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
31925 PyObject *resultobj;
31926 wxMenu *arg1 = (wxMenu *) 0 ;
31927 wxMenuItem *result;
31928 PyObject * obj0 = 0 ;
31929 char *kwnames[] = {
31930 (char *) "self", NULL
31931 };
31932
31933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
31934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31935 if (SWIG_arg_fail(1)) SWIG_fail;
31936 {
31937 PyThreadState* __tstate = wxPyBeginAllowThreads();
31938 result = (wxMenuItem *)(arg1)->AppendSeparator();
31939
31940 wxPyEndAllowThreads(__tstate);
31941 if (PyErr_Occurred()) SWIG_fail;
31942 }
31943 {
31944 resultobj = wxPyMake_wxObject(result, 0);
31945 }
31946 return resultobj;
31947 fail:
31948 return NULL;
31949 }
31950
31951
31952 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
31953 PyObject *resultobj;
31954 wxMenu *arg1 = (wxMenu *) 0 ;
31955 int arg2 ;
31956 wxString *arg3 = 0 ;
31957 wxString const &arg4_defvalue = wxPyEmptyString ;
31958 wxString *arg4 = (wxString *) &arg4_defvalue ;
31959 wxMenuItem *result;
31960 bool temp3 = false ;
31961 bool temp4 = false ;
31962 PyObject * obj0 = 0 ;
31963 PyObject * obj1 = 0 ;
31964 PyObject * obj2 = 0 ;
31965 PyObject * obj3 = 0 ;
31966 char *kwnames[] = {
31967 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31968 };
31969
31970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31972 if (SWIG_arg_fail(1)) SWIG_fail;
31973 {
31974 arg2 = (int)(SWIG_As_int(obj1));
31975 if (SWIG_arg_fail(2)) SWIG_fail;
31976 }
31977 {
31978 arg3 = wxString_in_helper(obj2);
31979 if (arg3 == NULL) SWIG_fail;
31980 temp3 = true;
31981 }
31982 if (obj3) {
31983 {
31984 arg4 = wxString_in_helper(obj3);
31985 if (arg4 == NULL) SWIG_fail;
31986 temp4 = true;
31987 }
31988 }
31989 {
31990 PyThreadState* __tstate = wxPyBeginAllowThreads();
31991 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
31992
31993 wxPyEndAllowThreads(__tstate);
31994 if (PyErr_Occurred()) SWIG_fail;
31995 }
31996 {
31997 resultobj = wxPyMake_wxObject(result, 0);
31998 }
31999 {
32000 if (temp3)
32001 delete arg3;
32002 }
32003 {
32004 if (temp4)
32005 delete arg4;
32006 }
32007 return resultobj;
32008 fail:
32009 {
32010 if (temp3)
32011 delete arg3;
32012 }
32013 {
32014 if (temp4)
32015 delete arg4;
32016 }
32017 return NULL;
32018 }
32019
32020
32021 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32022 PyObject *resultobj;
32023 wxMenu *arg1 = (wxMenu *) 0 ;
32024 int arg2 ;
32025 wxString *arg3 = 0 ;
32026 wxString const &arg4_defvalue = wxPyEmptyString ;
32027 wxString *arg4 = (wxString *) &arg4_defvalue ;
32028 wxMenuItem *result;
32029 bool temp3 = false ;
32030 bool temp4 = false ;
32031 PyObject * obj0 = 0 ;
32032 PyObject * obj1 = 0 ;
32033 PyObject * obj2 = 0 ;
32034 PyObject * obj3 = 0 ;
32035 char *kwnames[] = {
32036 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32037 };
32038
32039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32041 if (SWIG_arg_fail(1)) SWIG_fail;
32042 {
32043 arg2 = (int)(SWIG_As_int(obj1));
32044 if (SWIG_arg_fail(2)) SWIG_fail;
32045 }
32046 {
32047 arg3 = wxString_in_helper(obj2);
32048 if (arg3 == NULL) SWIG_fail;
32049 temp3 = true;
32050 }
32051 if (obj3) {
32052 {
32053 arg4 = wxString_in_helper(obj3);
32054 if (arg4 == NULL) SWIG_fail;
32055 temp4 = true;
32056 }
32057 }
32058 {
32059 PyThreadState* __tstate = wxPyBeginAllowThreads();
32060 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32061
32062 wxPyEndAllowThreads(__tstate);
32063 if (PyErr_Occurred()) SWIG_fail;
32064 }
32065 {
32066 resultobj = wxPyMake_wxObject(result, 0);
32067 }
32068 {
32069 if (temp3)
32070 delete arg3;
32071 }
32072 {
32073 if (temp4)
32074 delete arg4;
32075 }
32076 return resultobj;
32077 fail:
32078 {
32079 if (temp3)
32080 delete arg3;
32081 }
32082 {
32083 if (temp4)
32084 delete arg4;
32085 }
32086 return NULL;
32087 }
32088
32089
32090 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32091 PyObject *resultobj;
32092 wxMenu *arg1 = (wxMenu *) 0 ;
32093 int arg2 ;
32094 wxString *arg3 = 0 ;
32095 wxMenu *arg4 = (wxMenu *) 0 ;
32096 wxString const &arg5_defvalue = wxPyEmptyString ;
32097 wxString *arg5 = (wxString *) &arg5_defvalue ;
32098 wxMenuItem *result;
32099 bool temp3 = false ;
32100 bool temp5 = false ;
32101 PyObject * obj0 = 0 ;
32102 PyObject * obj1 = 0 ;
32103 PyObject * obj2 = 0 ;
32104 PyObject * obj3 = 0 ;
32105 PyObject * obj4 = 0 ;
32106 char *kwnames[] = {
32107 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32108 };
32109
32110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 {
32114 arg2 = (int)(SWIG_As_int(obj1));
32115 if (SWIG_arg_fail(2)) SWIG_fail;
32116 }
32117 {
32118 arg3 = wxString_in_helper(obj2);
32119 if (arg3 == NULL) SWIG_fail;
32120 temp3 = true;
32121 }
32122 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32123 if (SWIG_arg_fail(4)) SWIG_fail;
32124 if (obj4) {
32125 {
32126 arg5 = wxString_in_helper(obj4);
32127 if (arg5 == NULL) SWIG_fail;
32128 temp5 = true;
32129 }
32130 }
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32134
32135 wxPyEndAllowThreads(__tstate);
32136 if (PyErr_Occurred()) SWIG_fail;
32137 }
32138 {
32139 resultobj = wxPyMake_wxObject(result, 0);
32140 }
32141 {
32142 if (temp3)
32143 delete arg3;
32144 }
32145 {
32146 if (temp5)
32147 delete arg5;
32148 }
32149 return resultobj;
32150 fail:
32151 {
32152 if (temp3)
32153 delete arg3;
32154 }
32155 {
32156 if (temp5)
32157 delete arg5;
32158 }
32159 return NULL;
32160 }
32161
32162
32163 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32164 PyObject *resultobj;
32165 wxMenu *arg1 = (wxMenu *) 0 ;
32166 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32167 wxMenuItem *result;
32168 PyObject * obj0 = 0 ;
32169 PyObject * obj1 = 0 ;
32170 char *kwnames[] = {
32171 (char *) "self",(char *) "item", NULL
32172 };
32173
32174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32176 if (SWIG_arg_fail(1)) SWIG_fail;
32177 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32178 if (SWIG_arg_fail(2)) SWIG_fail;
32179 {
32180 PyThreadState* __tstate = wxPyBeginAllowThreads();
32181 result = (wxMenuItem *)(arg1)->Append(arg2);
32182
32183 wxPyEndAllowThreads(__tstate);
32184 if (PyErr_Occurred()) SWIG_fail;
32185 }
32186 {
32187 resultobj = wxPyMake_wxObject(result, 0);
32188 }
32189 return resultobj;
32190 fail:
32191 return NULL;
32192 }
32193
32194
32195 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32196 PyObject *resultobj;
32197 wxMenu *arg1 = (wxMenu *) 0 ;
32198 PyObject * obj0 = 0 ;
32199 char *kwnames[] = {
32200 (char *) "self", NULL
32201 };
32202
32203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32205 if (SWIG_arg_fail(1)) SWIG_fail;
32206 {
32207 PyThreadState* __tstate = wxPyBeginAllowThreads();
32208 (arg1)->Break();
32209
32210 wxPyEndAllowThreads(__tstate);
32211 if (PyErr_Occurred()) SWIG_fail;
32212 }
32213 Py_INCREF(Py_None); resultobj = Py_None;
32214 return resultobj;
32215 fail:
32216 return NULL;
32217 }
32218
32219
32220 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32221 PyObject *resultobj;
32222 wxMenu *arg1 = (wxMenu *) 0 ;
32223 size_t arg2 ;
32224 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32225 wxMenuItem *result;
32226 PyObject * obj0 = 0 ;
32227 PyObject * obj1 = 0 ;
32228 PyObject * obj2 = 0 ;
32229 char *kwnames[] = {
32230 (char *) "self",(char *) "pos",(char *) "item", NULL
32231 };
32232
32233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32235 if (SWIG_arg_fail(1)) SWIG_fail;
32236 {
32237 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32238 if (SWIG_arg_fail(2)) SWIG_fail;
32239 }
32240 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32241 if (SWIG_arg_fail(3)) SWIG_fail;
32242 {
32243 PyThreadState* __tstate = wxPyBeginAllowThreads();
32244 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32245
32246 wxPyEndAllowThreads(__tstate);
32247 if (PyErr_Occurred()) SWIG_fail;
32248 }
32249 {
32250 resultobj = wxPyMake_wxObject(result, 0);
32251 }
32252 return resultobj;
32253 fail:
32254 return NULL;
32255 }
32256
32257
32258 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32259 PyObject *resultobj;
32260 wxMenu *arg1 = (wxMenu *) 0 ;
32261 size_t arg2 ;
32262 int arg3 ;
32263 wxString *arg4 = 0 ;
32264 wxString const &arg5_defvalue = wxPyEmptyString ;
32265 wxString *arg5 = (wxString *) &arg5_defvalue ;
32266 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32267 wxMenuItem *result;
32268 bool temp4 = false ;
32269 bool temp5 = false ;
32270 PyObject * obj0 = 0 ;
32271 PyObject * obj1 = 0 ;
32272 PyObject * obj2 = 0 ;
32273 PyObject * obj3 = 0 ;
32274 PyObject * obj4 = 0 ;
32275 PyObject * obj5 = 0 ;
32276 char *kwnames[] = {
32277 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32278 };
32279
32280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32282 if (SWIG_arg_fail(1)) SWIG_fail;
32283 {
32284 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32285 if (SWIG_arg_fail(2)) SWIG_fail;
32286 }
32287 {
32288 arg3 = (int)(SWIG_As_int(obj2));
32289 if (SWIG_arg_fail(3)) SWIG_fail;
32290 }
32291 {
32292 arg4 = wxString_in_helper(obj3);
32293 if (arg4 == NULL) SWIG_fail;
32294 temp4 = true;
32295 }
32296 if (obj4) {
32297 {
32298 arg5 = wxString_in_helper(obj4);
32299 if (arg5 == NULL) SWIG_fail;
32300 temp5 = true;
32301 }
32302 }
32303 if (obj5) {
32304 {
32305 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32306 if (SWIG_arg_fail(6)) SWIG_fail;
32307 }
32308 }
32309 {
32310 PyThreadState* __tstate = wxPyBeginAllowThreads();
32311 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32312
32313 wxPyEndAllowThreads(__tstate);
32314 if (PyErr_Occurred()) SWIG_fail;
32315 }
32316 {
32317 resultobj = wxPyMake_wxObject(result, 0);
32318 }
32319 {
32320 if (temp4)
32321 delete arg4;
32322 }
32323 {
32324 if (temp5)
32325 delete arg5;
32326 }
32327 return resultobj;
32328 fail:
32329 {
32330 if (temp4)
32331 delete arg4;
32332 }
32333 {
32334 if (temp5)
32335 delete arg5;
32336 }
32337 return NULL;
32338 }
32339
32340
32341 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32342 PyObject *resultobj;
32343 wxMenu *arg1 = (wxMenu *) 0 ;
32344 size_t arg2 ;
32345 wxMenuItem *result;
32346 PyObject * obj0 = 0 ;
32347 PyObject * obj1 = 0 ;
32348 char *kwnames[] = {
32349 (char *) "self",(char *) "pos", NULL
32350 };
32351
32352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32354 if (SWIG_arg_fail(1)) SWIG_fail;
32355 {
32356 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32357 if (SWIG_arg_fail(2)) SWIG_fail;
32358 }
32359 {
32360 PyThreadState* __tstate = wxPyBeginAllowThreads();
32361 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32362
32363 wxPyEndAllowThreads(__tstate);
32364 if (PyErr_Occurred()) SWIG_fail;
32365 }
32366 {
32367 resultobj = wxPyMake_wxObject(result, 0);
32368 }
32369 return resultobj;
32370 fail:
32371 return NULL;
32372 }
32373
32374
32375 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32376 PyObject *resultobj;
32377 wxMenu *arg1 = (wxMenu *) 0 ;
32378 size_t arg2 ;
32379 int arg3 ;
32380 wxString *arg4 = 0 ;
32381 wxString const &arg5_defvalue = wxPyEmptyString ;
32382 wxString *arg5 = (wxString *) &arg5_defvalue ;
32383 wxMenuItem *result;
32384 bool temp4 = false ;
32385 bool temp5 = false ;
32386 PyObject * obj0 = 0 ;
32387 PyObject * obj1 = 0 ;
32388 PyObject * obj2 = 0 ;
32389 PyObject * obj3 = 0 ;
32390 PyObject * obj4 = 0 ;
32391 char *kwnames[] = {
32392 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32393 };
32394
32395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32397 if (SWIG_arg_fail(1)) SWIG_fail;
32398 {
32399 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32400 if (SWIG_arg_fail(2)) SWIG_fail;
32401 }
32402 {
32403 arg3 = (int)(SWIG_As_int(obj2));
32404 if (SWIG_arg_fail(3)) SWIG_fail;
32405 }
32406 {
32407 arg4 = wxString_in_helper(obj3);
32408 if (arg4 == NULL) SWIG_fail;
32409 temp4 = true;
32410 }
32411 if (obj4) {
32412 {
32413 arg5 = wxString_in_helper(obj4);
32414 if (arg5 == NULL) SWIG_fail;
32415 temp5 = true;
32416 }
32417 }
32418 {
32419 PyThreadState* __tstate = wxPyBeginAllowThreads();
32420 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32421
32422 wxPyEndAllowThreads(__tstate);
32423 if (PyErr_Occurred()) SWIG_fail;
32424 }
32425 {
32426 resultobj = wxPyMake_wxObject(result, 0);
32427 }
32428 {
32429 if (temp4)
32430 delete arg4;
32431 }
32432 {
32433 if (temp5)
32434 delete arg5;
32435 }
32436 return resultobj;
32437 fail:
32438 {
32439 if (temp4)
32440 delete arg4;
32441 }
32442 {
32443 if (temp5)
32444 delete arg5;
32445 }
32446 return NULL;
32447 }
32448
32449
32450 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32451 PyObject *resultobj;
32452 wxMenu *arg1 = (wxMenu *) 0 ;
32453 size_t arg2 ;
32454 int arg3 ;
32455 wxString *arg4 = 0 ;
32456 wxString const &arg5_defvalue = wxPyEmptyString ;
32457 wxString *arg5 = (wxString *) &arg5_defvalue ;
32458 wxMenuItem *result;
32459 bool temp4 = false ;
32460 bool temp5 = false ;
32461 PyObject * obj0 = 0 ;
32462 PyObject * obj1 = 0 ;
32463 PyObject * obj2 = 0 ;
32464 PyObject * obj3 = 0 ;
32465 PyObject * obj4 = 0 ;
32466 char *kwnames[] = {
32467 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32468 };
32469
32470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32472 if (SWIG_arg_fail(1)) SWIG_fail;
32473 {
32474 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32475 if (SWIG_arg_fail(2)) SWIG_fail;
32476 }
32477 {
32478 arg3 = (int)(SWIG_As_int(obj2));
32479 if (SWIG_arg_fail(3)) SWIG_fail;
32480 }
32481 {
32482 arg4 = wxString_in_helper(obj3);
32483 if (arg4 == NULL) SWIG_fail;
32484 temp4 = true;
32485 }
32486 if (obj4) {
32487 {
32488 arg5 = wxString_in_helper(obj4);
32489 if (arg5 == NULL) SWIG_fail;
32490 temp5 = true;
32491 }
32492 }
32493 {
32494 PyThreadState* __tstate = wxPyBeginAllowThreads();
32495 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32496
32497 wxPyEndAllowThreads(__tstate);
32498 if (PyErr_Occurred()) SWIG_fail;
32499 }
32500 {
32501 resultobj = wxPyMake_wxObject(result, 0);
32502 }
32503 {
32504 if (temp4)
32505 delete arg4;
32506 }
32507 {
32508 if (temp5)
32509 delete arg5;
32510 }
32511 return resultobj;
32512 fail:
32513 {
32514 if (temp4)
32515 delete arg4;
32516 }
32517 {
32518 if (temp5)
32519 delete arg5;
32520 }
32521 return NULL;
32522 }
32523
32524
32525 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32526 PyObject *resultobj;
32527 wxMenu *arg1 = (wxMenu *) 0 ;
32528 size_t arg2 ;
32529 int arg3 ;
32530 wxString *arg4 = 0 ;
32531 wxMenu *arg5 = (wxMenu *) 0 ;
32532 wxString const &arg6_defvalue = wxPyEmptyString ;
32533 wxString *arg6 = (wxString *) &arg6_defvalue ;
32534 wxMenuItem *result;
32535 bool temp4 = false ;
32536 bool temp6 = false ;
32537 PyObject * obj0 = 0 ;
32538 PyObject * obj1 = 0 ;
32539 PyObject * obj2 = 0 ;
32540 PyObject * obj3 = 0 ;
32541 PyObject * obj4 = 0 ;
32542 PyObject * obj5 = 0 ;
32543 char *kwnames[] = {
32544 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32545 };
32546
32547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32549 if (SWIG_arg_fail(1)) SWIG_fail;
32550 {
32551 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32552 if (SWIG_arg_fail(2)) SWIG_fail;
32553 }
32554 {
32555 arg3 = (int)(SWIG_As_int(obj2));
32556 if (SWIG_arg_fail(3)) SWIG_fail;
32557 }
32558 {
32559 arg4 = wxString_in_helper(obj3);
32560 if (arg4 == NULL) SWIG_fail;
32561 temp4 = true;
32562 }
32563 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32564 if (SWIG_arg_fail(5)) SWIG_fail;
32565 if (obj5) {
32566 {
32567 arg6 = wxString_in_helper(obj5);
32568 if (arg6 == NULL) SWIG_fail;
32569 temp6 = true;
32570 }
32571 }
32572 {
32573 PyThreadState* __tstate = wxPyBeginAllowThreads();
32574 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32575
32576 wxPyEndAllowThreads(__tstate);
32577 if (PyErr_Occurred()) SWIG_fail;
32578 }
32579 {
32580 resultobj = wxPyMake_wxObject(result, 0);
32581 }
32582 {
32583 if (temp4)
32584 delete arg4;
32585 }
32586 {
32587 if (temp6)
32588 delete arg6;
32589 }
32590 return resultobj;
32591 fail:
32592 {
32593 if (temp4)
32594 delete arg4;
32595 }
32596 {
32597 if (temp6)
32598 delete arg6;
32599 }
32600 return NULL;
32601 }
32602
32603
32604 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32605 PyObject *resultobj;
32606 wxMenu *arg1 = (wxMenu *) 0 ;
32607 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32608 wxMenuItem *result;
32609 PyObject * obj0 = 0 ;
32610 PyObject * obj1 = 0 ;
32611 char *kwnames[] = {
32612 (char *) "self",(char *) "item", NULL
32613 };
32614
32615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32617 if (SWIG_arg_fail(1)) SWIG_fail;
32618 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32619 if (SWIG_arg_fail(2)) SWIG_fail;
32620 {
32621 PyThreadState* __tstate = wxPyBeginAllowThreads();
32622 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32623
32624 wxPyEndAllowThreads(__tstate);
32625 if (PyErr_Occurred()) SWIG_fail;
32626 }
32627 {
32628 resultobj = wxPyMake_wxObject(result, 0);
32629 }
32630 return resultobj;
32631 fail:
32632 return NULL;
32633 }
32634
32635
32636 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32637 PyObject *resultobj;
32638 wxMenu *arg1 = (wxMenu *) 0 ;
32639 int arg2 ;
32640 wxString *arg3 = 0 ;
32641 wxString const &arg4_defvalue = wxPyEmptyString ;
32642 wxString *arg4 = (wxString *) &arg4_defvalue ;
32643 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32644 wxMenuItem *result;
32645 bool temp3 = false ;
32646 bool temp4 = false ;
32647 PyObject * obj0 = 0 ;
32648 PyObject * obj1 = 0 ;
32649 PyObject * obj2 = 0 ;
32650 PyObject * obj3 = 0 ;
32651 PyObject * obj4 = 0 ;
32652 char *kwnames[] = {
32653 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32654 };
32655
32656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32658 if (SWIG_arg_fail(1)) SWIG_fail;
32659 {
32660 arg2 = (int)(SWIG_As_int(obj1));
32661 if (SWIG_arg_fail(2)) SWIG_fail;
32662 }
32663 {
32664 arg3 = wxString_in_helper(obj2);
32665 if (arg3 == NULL) SWIG_fail;
32666 temp3 = true;
32667 }
32668 if (obj3) {
32669 {
32670 arg4 = wxString_in_helper(obj3);
32671 if (arg4 == NULL) SWIG_fail;
32672 temp4 = true;
32673 }
32674 }
32675 if (obj4) {
32676 {
32677 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32678 if (SWIG_arg_fail(5)) SWIG_fail;
32679 }
32680 }
32681 {
32682 PyThreadState* __tstate = wxPyBeginAllowThreads();
32683 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32684
32685 wxPyEndAllowThreads(__tstate);
32686 if (PyErr_Occurred()) SWIG_fail;
32687 }
32688 {
32689 resultobj = wxPyMake_wxObject(result, 0);
32690 }
32691 {
32692 if (temp3)
32693 delete arg3;
32694 }
32695 {
32696 if (temp4)
32697 delete arg4;
32698 }
32699 return resultobj;
32700 fail:
32701 {
32702 if (temp3)
32703 delete arg3;
32704 }
32705 {
32706 if (temp4)
32707 delete arg4;
32708 }
32709 return NULL;
32710 }
32711
32712
32713 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32714 PyObject *resultobj;
32715 wxMenu *arg1 = (wxMenu *) 0 ;
32716 wxMenuItem *result;
32717 PyObject * obj0 = 0 ;
32718 char *kwnames[] = {
32719 (char *) "self", NULL
32720 };
32721
32722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32724 if (SWIG_arg_fail(1)) SWIG_fail;
32725 {
32726 PyThreadState* __tstate = wxPyBeginAllowThreads();
32727 result = (wxMenuItem *)(arg1)->PrependSeparator();
32728
32729 wxPyEndAllowThreads(__tstate);
32730 if (PyErr_Occurred()) SWIG_fail;
32731 }
32732 {
32733 resultobj = wxPyMake_wxObject(result, 0);
32734 }
32735 return resultobj;
32736 fail:
32737 return NULL;
32738 }
32739
32740
32741 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32742 PyObject *resultobj;
32743 wxMenu *arg1 = (wxMenu *) 0 ;
32744 int arg2 ;
32745 wxString *arg3 = 0 ;
32746 wxString const &arg4_defvalue = wxPyEmptyString ;
32747 wxString *arg4 = (wxString *) &arg4_defvalue ;
32748 wxMenuItem *result;
32749 bool temp3 = false ;
32750 bool temp4 = false ;
32751 PyObject * obj0 = 0 ;
32752 PyObject * obj1 = 0 ;
32753 PyObject * obj2 = 0 ;
32754 PyObject * obj3 = 0 ;
32755 char *kwnames[] = {
32756 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32757 };
32758
32759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32761 if (SWIG_arg_fail(1)) SWIG_fail;
32762 {
32763 arg2 = (int)(SWIG_As_int(obj1));
32764 if (SWIG_arg_fail(2)) SWIG_fail;
32765 }
32766 {
32767 arg3 = wxString_in_helper(obj2);
32768 if (arg3 == NULL) SWIG_fail;
32769 temp3 = true;
32770 }
32771 if (obj3) {
32772 {
32773 arg4 = wxString_in_helper(obj3);
32774 if (arg4 == NULL) SWIG_fail;
32775 temp4 = true;
32776 }
32777 }
32778 {
32779 PyThreadState* __tstate = wxPyBeginAllowThreads();
32780 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32781
32782 wxPyEndAllowThreads(__tstate);
32783 if (PyErr_Occurred()) SWIG_fail;
32784 }
32785 {
32786 resultobj = wxPyMake_wxObject(result, 0);
32787 }
32788 {
32789 if (temp3)
32790 delete arg3;
32791 }
32792 {
32793 if (temp4)
32794 delete arg4;
32795 }
32796 return resultobj;
32797 fail:
32798 {
32799 if (temp3)
32800 delete arg3;
32801 }
32802 {
32803 if (temp4)
32804 delete arg4;
32805 }
32806 return NULL;
32807 }
32808
32809
32810 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32811 PyObject *resultobj;
32812 wxMenu *arg1 = (wxMenu *) 0 ;
32813 int arg2 ;
32814 wxString *arg3 = 0 ;
32815 wxString const &arg4_defvalue = wxPyEmptyString ;
32816 wxString *arg4 = (wxString *) &arg4_defvalue ;
32817 wxMenuItem *result;
32818 bool temp3 = false ;
32819 bool temp4 = false ;
32820 PyObject * obj0 = 0 ;
32821 PyObject * obj1 = 0 ;
32822 PyObject * obj2 = 0 ;
32823 PyObject * obj3 = 0 ;
32824 char *kwnames[] = {
32825 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32826 };
32827
32828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32830 if (SWIG_arg_fail(1)) SWIG_fail;
32831 {
32832 arg2 = (int)(SWIG_As_int(obj1));
32833 if (SWIG_arg_fail(2)) SWIG_fail;
32834 }
32835 {
32836 arg3 = wxString_in_helper(obj2);
32837 if (arg3 == NULL) SWIG_fail;
32838 temp3 = true;
32839 }
32840 if (obj3) {
32841 {
32842 arg4 = wxString_in_helper(obj3);
32843 if (arg4 == NULL) SWIG_fail;
32844 temp4 = true;
32845 }
32846 }
32847 {
32848 PyThreadState* __tstate = wxPyBeginAllowThreads();
32849 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32850
32851 wxPyEndAllowThreads(__tstate);
32852 if (PyErr_Occurred()) SWIG_fail;
32853 }
32854 {
32855 resultobj = wxPyMake_wxObject(result, 0);
32856 }
32857 {
32858 if (temp3)
32859 delete arg3;
32860 }
32861 {
32862 if (temp4)
32863 delete arg4;
32864 }
32865 return resultobj;
32866 fail:
32867 {
32868 if (temp3)
32869 delete arg3;
32870 }
32871 {
32872 if (temp4)
32873 delete arg4;
32874 }
32875 return NULL;
32876 }
32877
32878
32879 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32880 PyObject *resultobj;
32881 wxMenu *arg1 = (wxMenu *) 0 ;
32882 int arg2 ;
32883 wxString *arg3 = 0 ;
32884 wxMenu *arg4 = (wxMenu *) 0 ;
32885 wxString const &arg5_defvalue = wxPyEmptyString ;
32886 wxString *arg5 = (wxString *) &arg5_defvalue ;
32887 wxMenuItem *result;
32888 bool temp3 = false ;
32889 bool temp5 = false ;
32890 PyObject * obj0 = 0 ;
32891 PyObject * obj1 = 0 ;
32892 PyObject * obj2 = 0 ;
32893 PyObject * obj3 = 0 ;
32894 PyObject * obj4 = 0 ;
32895 char *kwnames[] = {
32896 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32897 };
32898
32899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 arg3 = wxString_in_helper(obj2);
32908 if (arg3 == NULL) SWIG_fail;
32909 temp3 = true;
32910 }
32911 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32912 if (SWIG_arg_fail(4)) SWIG_fail;
32913 if (obj4) {
32914 {
32915 arg5 = wxString_in_helper(obj4);
32916 if (arg5 == NULL) SWIG_fail;
32917 temp5 = true;
32918 }
32919 }
32920 {
32921 PyThreadState* __tstate = wxPyBeginAllowThreads();
32922 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32923
32924 wxPyEndAllowThreads(__tstate);
32925 if (PyErr_Occurred()) SWIG_fail;
32926 }
32927 {
32928 resultobj = wxPyMake_wxObject(result, 0);
32929 }
32930 {
32931 if (temp3)
32932 delete arg3;
32933 }
32934 {
32935 if (temp5)
32936 delete arg5;
32937 }
32938 return resultobj;
32939 fail:
32940 {
32941 if (temp3)
32942 delete arg3;
32943 }
32944 {
32945 if (temp5)
32946 delete arg5;
32947 }
32948 return NULL;
32949 }
32950
32951
32952 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
32953 PyObject *resultobj;
32954 wxMenu *arg1 = (wxMenu *) 0 ;
32955 int arg2 ;
32956 wxMenuItem *result;
32957 PyObject * obj0 = 0 ;
32958 PyObject * obj1 = 0 ;
32959 char *kwnames[] = {
32960 (char *) "self",(char *) "id", NULL
32961 };
32962
32963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
32964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32965 if (SWIG_arg_fail(1)) SWIG_fail;
32966 {
32967 arg2 = (int)(SWIG_As_int(obj1));
32968 if (SWIG_arg_fail(2)) SWIG_fail;
32969 }
32970 {
32971 PyThreadState* __tstate = wxPyBeginAllowThreads();
32972 result = (wxMenuItem *)(arg1)->Remove(arg2);
32973
32974 wxPyEndAllowThreads(__tstate);
32975 if (PyErr_Occurred()) SWIG_fail;
32976 }
32977 {
32978 resultobj = wxPyMake_wxObject(result, 0);
32979 }
32980 return resultobj;
32981 fail:
32982 return NULL;
32983 }
32984
32985
32986 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
32987 PyObject *resultobj;
32988 wxMenu *arg1 = (wxMenu *) 0 ;
32989 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32990 wxMenuItem *result;
32991 PyObject * obj0 = 0 ;
32992 PyObject * obj1 = 0 ;
32993 char *kwnames[] = {
32994 (char *) "self",(char *) "item", NULL
32995 };
32996
32997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
32998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32999 if (SWIG_arg_fail(1)) SWIG_fail;
33000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33001 if (SWIG_arg_fail(2)) SWIG_fail;
33002 {
33003 PyThreadState* __tstate = wxPyBeginAllowThreads();
33004 result = (wxMenuItem *)(arg1)->Remove(arg2);
33005
33006 wxPyEndAllowThreads(__tstate);
33007 if (PyErr_Occurred()) SWIG_fail;
33008 }
33009 {
33010 resultobj = wxPyMake_wxObject(result, 0);
33011 }
33012 return resultobj;
33013 fail:
33014 return NULL;
33015 }
33016
33017
33018 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33019 PyObject *resultobj;
33020 wxMenu *arg1 = (wxMenu *) 0 ;
33021 int arg2 ;
33022 bool result;
33023 PyObject * obj0 = 0 ;
33024 PyObject * obj1 = 0 ;
33025 char *kwnames[] = {
33026 (char *) "self",(char *) "id", NULL
33027 };
33028
33029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33031 if (SWIG_arg_fail(1)) SWIG_fail;
33032 {
33033 arg2 = (int)(SWIG_As_int(obj1));
33034 if (SWIG_arg_fail(2)) SWIG_fail;
33035 }
33036 {
33037 PyThreadState* __tstate = wxPyBeginAllowThreads();
33038 result = (bool)(arg1)->Delete(arg2);
33039
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 {
33044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33045 }
33046 return resultobj;
33047 fail:
33048 return NULL;
33049 }
33050
33051
33052 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33053 PyObject *resultobj;
33054 wxMenu *arg1 = (wxMenu *) 0 ;
33055 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33056 bool result;
33057 PyObject * obj0 = 0 ;
33058 PyObject * obj1 = 0 ;
33059 char *kwnames[] = {
33060 (char *) "self",(char *) "item", NULL
33061 };
33062
33063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33065 if (SWIG_arg_fail(1)) SWIG_fail;
33066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33067 if (SWIG_arg_fail(2)) SWIG_fail;
33068 {
33069 PyThreadState* __tstate = wxPyBeginAllowThreads();
33070 result = (bool)(arg1)->Delete(arg2);
33071
33072 wxPyEndAllowThreads(__tstate);
33073 if (PyErr_Occurred()) SWIG_fail;
33074 }
33075 {
33076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33077 }
33078 return resultobj;
33079 fail:
33080 return NULL;
33081 }
33082
33083
33084 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33085 PyObject *resultobj;
33086 wxMenu *arg1 = (wxMenu *) 0 ;
33087 PyObject * obj0 = 0 ;
33088 char *kwnames[] = {
33089 (char *) "self", NULL
33090 };
33091
33092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33094 if (SWIG_arg_fail(1)) SWIG_fail;
33095 {
33096 PyThreadState* __tstate = wxPyBeginAllowThreads();
33097 wxMenu_Destroy(arg1);
33098
33099 wxPyEndAllowThreads(__tstate);
33100 if (PyErr_Occurred()) SWIG_fail;
33101 }
33102 Py_INCREF(Py_None); resultobj = Py_None;
33103 return resultobj;
33104 fail:
33105 return NULL;
33106 }
33107
33108
33109 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33110 PyObject *resultobj;
33111 wxMenu *arg1 = (wxMenu *) 0 ;
33112 int arg2 ;
33113 bool result;
33114 PyObject * obj0 = 0 ;
33115 PyObject * obj1 = 0 ;
33116 char *kwnames[] = {
33117 (char *) "self",(char *) "id", NULL
33118 };
33119
33120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
33125 if (SWIG_arg_fail(2)) SWIG_fail;
33126 }
33127 {
33128 PyThreadState* __tstate = wxPyBeginAllowThreads();
33129 result = (bool)(arg1)->Destroy(arg2);
33130
33131 wxPyEndAllowThreads(__tstate);
33132 if (PyErr_Occurred()) SWIG_fail;
33133 }
33134 {
33135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33136 }
33137 return resultobj;
33138 fail:
33139 return NULL;
33140 }
33141
33142
33143 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33144 PyObject *resultobj;
33145 wxMenu *arg1 = (wxMenu *) 0 ;
33146 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33147 bool result;
33148 PyObject * obj0 = 0 ;
33149 PyObject * obj1 = 0 ;
33150 char *kwnames[] = {
33151 (char *) "self",(char *) "item", NULL
33152 };
33153
33154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33156 if (SWIG_arg_fail(1)) SWIG_fail;
33157 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33158 if (SWIG_arg_fail(2)) SWIG_fail;
33159 {
33160 PyThreadState* __tstate = wxPyBeginAllowThreads();
33161 result = (bool)(arg1)->Destroy(arg2);
33162
33163 wxPyEndAllowThreads(__tstate);
33164 if (PyErr_Occurred()) SWIG_fail;
33165 }
33166 {
33167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33168 }
33169 return resultobj;
33170 fail:
33171 return NULL;
33172 }
33173
33174
33175 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33176 PyObject *resultobj;
33177 wxMenu *arg1 = (wxMenu *) 0 ;
33178 size_t result;
33179 PyObject * obj0 = 0 ;
33180 char *kwnames[] = {
33181 (char *) "self", NULL
33182 };
33183
33184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33186 if (SWIG_arg_fail(1)) SWIG_fail;
33187 {
33188 PyThreadState* __tstate = wxPyBeginAllowThreads();
33189 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33190
33191 wxPyEndAllowThreads(__tstate);
33192 if (PyErr_Occurred()) SWIG_fail;
33193 }
33194 {
33195 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33196 }
33197 return resultobj;
33198 fail:
33199 return NULL;
33200 }
33201
33202
33203 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33204 PyObject *resultobj;
33205 wxMenu *arg1 = (wxMenu *) 0 ;
33206 PyObject *result;
33207 PyObject * obj0 = 0 ;
33208 char *kwnames[] = {
33209 (char *) "self", NULL
33210 };
33211
33212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33214 if (SWIG_arg_fail(1)) SWIG_fail;
33215 {
33216 PyThreadState* __tstate = wxPyBeginAllowThreads();
33217 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33218
33219 wxPyEndAllowThreads(__tstate);
33220 if (PyErr_Occurred()) SWIG_fail;
33221 }
33222 resultobj = result;
33223 return resultobj;
33224 fail:
33225 return NULL;
33226 }
33227
33228
33229 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33230 PyObject *resultobj;
33231 wxMenu *arg1 = (wxMenu *) 0 ;
33232 wxString *arg2 = 0 ;
33233 int result;
33234 bool temp2 = false ;
33235 PyObject * obj0 = 0 ;
33236 PyObject * obj1 = 0 ;
33237 char *kwnames[] = {
33238 (char *) "self",(char *) "item", NULL
33239 };
33240
33241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33243 if (SWIG_arg_fail(1)) SWIG_fail;
33244 {
33245 arg2 = wxString_in_helper(obj1);
33246 if (arg2 == NULL) SWIG_fail;
33247 temp2 = true;
33248 }
33249 {
33250 PyThreadState* __tstate = wxPyBeginAllowThreads();
33251 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33252
33253 wxPyEndAllowThreads(__tstate);
33254 if (PyErr_Occurred()) SWIG_fail;
33255 }
33256 {
33257 resultobj = SWIG_From_int((int)(result));
33258 }
33259 {
33260 if (temp2)
33261 delete arg2;
33262 }
33263 return resultobj;
33264 fail:
33265 {
33266 if (temp2)
33267 delete arg2;
33268 }
33269 return NULL;
33270 }
33271
33272
33273 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33274 PyObject *resultobj;
33275 wxMenu *arg1 = (wxMenu *) 0 ;
33276 int arg2 ;
33277 wxMenuItem *result;
33278 PyObject * obj0 = 0 ;
33279 PyObject * obj1 = 0 ;
33280 char *kwnames[] = {
33281 (char *) "self",(char *) "id", NULL
33282 };
33283
33284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33286 if (SWIG_arg_fail(1)) SWIG_fail;
33287 {
33288 arg2 = (int)(SWIG_As_int(obj1));
33289 if (SWIG_arg_fail(2)) SWIG_fail;
33290 }
33291 {
33292 PyThreadState* __tstate = wxPyBeginAllowThreads();
33293 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33294
33295 wxPyEndAllowThreads(__tstate);
33296 if (PyErr_Occurred()) SWIG_fail;
33297 }
33298 {
33299 resultobj = wxPyMake_wxObject(result, 0);
33300 }
33301 return resultobj;
33302 fail:
33303 return NULL;
33304 }
33305
33306
33307 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33308 PyObject *resultobj;
33309 wxMenu *arg1 = (wxMenu *) 0 ;
33310 size_t arg2 ;
33311 wxMenuItem *result;
33312 PyObject * obj0 = 0 ;
33313 PyObject * obj1 = 0 ;
33314 char *kwnames[] = {
33315 (char *) "self",(char *) "position", NULL
33316 };
33317
33318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33320 if (SWIG_arg_fail(1)) SWIG_fail;
33321 {
33322 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33323 if (SWIG_arg_fail(2)) SWIG_fail;
33324 }
33325 {
33326 PyThreadState* __tstate = wxPyBeginAllowThreads();
33327 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33328
33329 wxPyEndAllowThreads(__tstate);
33330 if (PyErr_Occurred()) SWIG_fail;
33331 }
33332 {
33333 resultobj = wxPyMake_wxObject(result, 0);
33334 }
33335 return resultobj;
33336 fail:
33337 return NULL;
33338 }
33339
33340
33341 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33342 PyObject *resultobj;
33343 wxMenu *arg1 = (wxMenu *) 0 ;
33344 int arg2 ;
33345 bool arg3 ;
33346 PyObject * obj0 = 0 ;
33347 PyObject * obj1 = 0 ;
33348 PyObject * obj2 = 0 ;
33349 char *kwnames[] = {
33350 (char *) "self",(char *) "id",(char *) "enable", NULL
33351 };
33352
33353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33355 if (SWIG_arg_fail(1)) SWIG_fail;
33356 {
33357 arg2 = (int)(SWIG_As_int(obj1));
33358 if (SWIG_arg_fail(2)) SWIG_fail;
33359 }
33360 {
33361 arg3 = (bool)(SWIG_As_bool(obj2));
33362 if (SWIG_arg_fail(3)) SWIG_fail;
33363 }
33364 {
33365 PyThreadState* __tstate = wxPyBeginAllowThreads();
33366 (arg1)->Enable(arg2,arg3);
33367
33368 wxPyEndAllowThreads(__tstate);
33369 if (PyErr_Occurred()) SWIG_fail;
33370 }
33371 Py_INCREF(Py_None); resultobj = Py_None;
33372 return resultobj;
33373 fail:
33374 return NULL;
33375 }
33376
33377
33378 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33379 PyObject *resultobj;
33380 wxMenu *arg1 = (wxMenu *) 0 ;
33381 int arg2 ;
33382 bool result;
33383 PyObject * obj0 = 0 ;
33384 PyObject * obj1 = 0 ;
33385 char *kwnames[] = {
33386 (char *) "self",(char *) "id", NULL
33387 };
33388
33389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33391 if (SWIG_arg_fail(1)) SWIG_fail;
33392 {
33393 arg2 = (int)(SWIG_As_int(obj1));
33394 if (SWIG_arg_fail(2)) SWIG_fail;
33395 }
33396 {
33397 PyThreadState* __tstate = wxPyBeginAllowThreads();
33398 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33399
33400 wxPyEndAllowThreads(__tstate);
33401 if (PyErr_Occurred()) SWIG_fail;
33402 }
33403 {
33404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33405 }
33406 return resultobj;
33407 fail:
33408 return NULL;
33409 }
33410
33411
33412 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33413 PyObject *resultobj;
33414 wxMenu *arg1 = (wxMenu *) 0 ;
33415 int arg2 ;
33416 bool arg3 ;
33417 PyObject * obj0 = 0 ;
33418 PyObject * obj1 = 0 ;
33419 PyObject * obj2 = 0 ;
33420 char *kwnames[] = {
33421 (char *) "self",(char *) "id",(char *) "check", NULL
33422 };
33423
33424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33426 if (SWIG_arg_fail(1)) SWIG_fail;
33427 {
33428 arg2 = (int)(SWIG_As_int(obj1));
33429 if (SWIG_arg_fail(2)) SWIG_fail;
33430 }
33431 {
33432 arg3 = (bool)(SWIG_As_bool(obj2));
33433 if (SWIG_arg_fail(3)) SWIG_fail;
33434 }
33435 {
33436 PyThreadState* __tstate = wxPyBeginAllowThreads();
33437 (arg1)->Check(arg2,arg3);
33438
33439 wxPyEndAllowThreads(__tstate);
33440 if (PyErr_Occurred()) SWIG_fail;
33441 }
33442 Py_INCREF(Py_None); resultobj = Py_None;
33443 return resultobj;
33444 fail:
33445 return NULL;
33446 }
33447
33448
33449 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33450 PyObject *resultobj;
33451 wxMenu *arg1 = (wxMenu *) 0 ;
33452 int arg2 ;
33453 bool result;
33454 PyObject * obj0 = 0 ;
33455 PyObject * obj1 = 0 ;
33456 char *kwnames[] = {
33457 (char *) "self",(char *) "id", NULL
33458 };
33459
33460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33462 if (SWIG_arg_fail(1)) SWIG_fail;
33463 {
33464 arg2 = (int)(SWIG_As_int(obj1));
33465 if (SWIG_arg_fail(2)) SWIG_fail;
33466 }
33467 {
33468 PyThreadState* __tstate = wxPyBeginAllowThreads();
33469 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33470
33471 wxPyEndAllowThreads(__tstate);
33472 if (PyErr_Occurred()) SWIG_fail;
33473 }
33474 {
33475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33476 }
33477 return resultobj;
33478 fail:
33479 return NULL;
33480 }
33481
33482
33483 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33484 PyObject *resultobj;
33485 wxMenu *arg1 = (wxMenu *) 0 ;
33486 int arg2 ;
33487 wxString *arg3 = 0 ;
33488 bool temp3 = false ;
33489 PyObject * obj0 = 0 ;
33490 PyObject * obj1 = 0 ;
33491 PyObject * obj2 = 0 ;
33492 char *kwnames[] = {
33493 (char *) "self",(char *) "id",(char *) "label", NULL
33494 };
33495
33496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33498 if (SWIG_arg_fail(1)) SWIG_fail;
33499 {
33500 arg2 = (int)(SWIG_As_int(obj1));
33501 if (SWIG_arg_fail(2)) SWIG_fail;
33502 }
33503 {
33504 arg3 = wxString_in_helper(obj2);
33505 if (arg3 == NULL) SWIG_fail;
33506 temp3 = true;
33507 }
33508 {
33509 PyThreadState* __tstate = wxPyBeginAllowThreads();
33510 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33511
33512 wxPyEndAllowThreads(__tstate);
33513 if (PyErr_Occurred()) SWIG_fail;
33514 }
33515 Py_INCREF(Py_None); resultobj = Py_None;
33516 {
33517 if (temp3)
33518 delete arg3;
33519 }
33520 return resultobj;
33521 fail:
33522 {
33523 if (temp3)
33524 delete arg3;
33525 }
33526 return NULL;
33527 }
33528
33529
33530 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33531 PyObject *resultobj;
33532 wxMenu *arg1 = (wxMenu *) 0 ;
33533 int arg2 ;
33534 wxString result;
33535 PyObject * obj0 = 0 ;
33536 PyObject * obj1 = 0 ;
33537 char *kwnames[] = {
33538 (char *) "self",(char *) "id", NULL
33539 };
33540
33541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33543 if (SWIG_arg_fail(1)) SWIG_fail;
33544 {
33545 arg2 = (int)(SWIG_As_int(obj1));
33546 if (SWIG_arg_fail(2)) SWIG_fail;
33547 }
33548 {
33549 PyThreadState* __tstate = wxPyBeginAllowThreads();
33550 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33551
33552 wxPyEndAllowThreads(__tstate);
33553 if (PyErr_Occurred()) SWIG_fail;
33554 }
33555 {
33556 #if wxUSE_UNICODE
33557 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33558 #else
33559 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33560 #endif
33561 }
33562 return resultobj;
33563 fail:
33564 return NULL;
33565 }
33566
33567
33568 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33569 PyObject *resultobj;
33570 wxMenu *arg1 = (wxMenu *) 0 ;
33571 int arg2 ;
33572 wxString *arg3 = 0 ;
33573 bool temp3 = false ;
33574 PyObject * obj0 = 0 ;
33575 PyObject * obj1 = 0 ;
33576 PyObject * obj2 = 0 ;
33577 char *kwnames[] = {
33578 (char *) "self",(char *) "id",(char *) "helpString", NULL
33579 };
33580
33581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33583 if (SWIG_arg_fail(1)) SWIG_fail;
33584 {
33585 arg2 = (int)(SWIG_As_int(obj1));
33586 if (SWIG_arg_fail(2)) SWIG_fail;
33587 }
33588 {
33589 arg3 = wxString_in_helper(obj2);
33590 if (arg3 == NULL) SWIG_fail;
33591 temp3 = true;
33592 }
33593 {
33594 PyThreadState* __tstate = wxPyBeginAllowThreads();
33595 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33596
33597 wxPyEndAllowThreads(__tstate);
33598 if (PyErr_Occurred()) SWIG_fail;
33599 }
33600 Py_INCREF(Py_None); resultobj = Py_None;
33601 {
33602 if (temp3)
33603 delete arg3;
33604 }
33605 return resultobj;
33606 fail:
33607 {
33608 if (temp3)
33609 delete arg3;
33610 }
33611 return NULL;
33612 }
33613
33614
33615 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33616 PyObject *resultobj;
33617 wxMenu *arg1 = (wxMenu *) 0 ;
33618 int arg2 ;
33619 wxString result;
33620 PyObject * obj0 = 0 ;
33621 PyObject * obj1 = 0 ;
33622 char *kwnames[] = {
33623 (char *) "self",(char *) "id", NULL
33624 };
33625
33626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33628 if (SWIG_arg_fail(1)) SWIG_fail;
33629 {
33630 arg2 = (int)(SWIG_As_int(obj1));
33631 if (SWIG_arg_fail(2)) SWIG_fail;
33632 }
33633 {
33634 PyThreadState* __tstate = wxPyBeginAllowThreads();
33635 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33636
33637 wxPyEndAllowThreads(__tstate);
33638 if (PyErr_Occurred()) SWIG_fail;
33639 }
33640 {
33641 #if wxUSE_UNICODE
33642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33643 #else
33644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33645 #endif
33646 }
33647 return resultobj;
33648 fail:
33649 return NULL;
33650 }
33651
33652
33653 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33654 PyObject *resultobj;
33655 wxMenu *arg1 = (wxMenu *) 0 ;
33656 wxString *arg2 = 0 ;
33657 bool temp2 = false ;
33658 PyObject * obj0 = 0 ;
33659 PyObject * obj1 = 0 ;
33660 char *kwnames[] = {
33661 (char *) "self",(char *) "title", NULL
33662 };
33663
33664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33666 if (SWIG_arg_fail(1)) SWIG_fail;
33667 {
33668 arg2 = wxString_in_helper(obj1);
33669 if (arg2 == NULL) SWIG_fail;
33670 temp2 = true;
33671 }
33672 {
33673 PyThreadState* __tstate = wxPyBeginAllowThreads();
33674 (arg1)->SetTitle((wxString const &)*arg2);
33675
33676 wxPyEndAllowThreads(__tstate);
33677 if (PyErr_Occurred()) SWIG_fail;
33678 }
33679 Py_INCREF(Py_None); resultobj = Py_None;
33680 {
33681 if (temp2)
33682 delete arg2;
33683 }
33684 return resultobj;
33685 fail:
33686 {
33687 if (temp2)
33688 delete arg2;
33689 }
33690 return NULL;
33691 }
33692
33693
33694 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33695 PyObject *resultobj;
33696 wxMenu *arg1 = (wxMenu *) 0 ;
33697 wxString result;
33698 PyObject * obj0 = 0 ;
33699 char *kwnames[] = {
33700 (char *) "self", NULL
33701 };
33702
33703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33705 if (SWIG_arg_fail(1)) SWIG_fail;
33706 {
33707 PyThreadState* __tstate = wxPyBeginAllowThreads();
33708 result = ((wxMenu const *)arg1)->GetTitle();
33709
33710 wxPyEndAllowThreads(__tstate);
33711 if (PyErr_Occurred()) SWIG_fail;
33712 }
33713 {
33714 #if wxUSE_UNICODE
33715 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33716 #else
33717 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33718 #endif
33719 }
33720 return resultobj;
33721 fail:
33722 return NULL;
33723 }
33724
33725
33726 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33727 PyObject *resultobj;
33728 wxMenu *arg1 = (wxMenu *) 0 ;
33729 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33730 PyObject * obj0 = 0 ;
33731 PyObject * obj1 = 0 ;
33732 char *kwnames[] = {
33733 (char *) "self",(char *) "handler", NULL
33734 };
33735
33736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33738 if (SWIG_arg_fail(1)) SWIG_fail;
33739 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33740 if (SWIG_arg_fail(2)) SWIG_fail;
33741 {
33742 PyThreadState* __tstate = wxPyBeginAllowThreads();
33743 (arg1)->SetEventHandler(arg2);
33744
33745 wxPyEndAllowThreads(__tstate);
33746 if (PyErr_Occurred()) SWIG_fail;
33747 }
33748 Py_INCREF(Py_None); resultobj = Py_None;
33749 return resultobj;
33750 fail:
33751 return NULL;
33752 }
33753
33754
33755 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33756 PyObject *resultobj;
33757 wxMenu *arg1 = (wxMenu *) 0 ;
33758 wxEvtHandler *result;
33759 PyObject * obj0 = 0 ;
33760 char *kwnames[] = {
33761 (char *) "self", NULL
33762 };
33763
33764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
33765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33766 if (SWIG_arg_fail(1)) SWIG_fail;
33767 {
33768 PyThreadState* __tstate = wxPyBeginAllowThreads();
33769 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
33770
33771 wxPyEndAllowThreads(__tstate);
33772 if (PyErr_Occurred()) SWIG_fail;
33773 }
33774 {
33775 resultobj = wxPyMake_wxObject(result, 0);
33776 }
33777 return resultobj;
33778 fail:
33779 return NULL;
33780 }
33781
33782
33783 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33784 PyObject *resultobj;
33785 wxMenu *arg1 = (wxMenu *) 0 ;
33786 wxWindow *arg2 = (wxWindow *) 0 ;
33787 PyObject * obj0 = 0 ;
33788 PyObject * obj1 = 0 ;
33789 char *kwnames[] = {
33790 (char *) "self",(char *) "win", NULL
33791 };
33792
33793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
33794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33795 if (SWIG_arg_fail(1)) SWIG_fail;
33796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33797 if (SWIG_arg_fail(2)) SWIG_fail;
33798 {
33799 PyThreadState* __tstate = wxPyBeginAllowThreads();
33800 (arg1)->SetInvokingWindow(arg2);
33801
33802 wxPyEndAllowThreads(__tstate);
33803 if (PyErr_Occurred()) SWIG_fail;
33804 }
33805 Py_INCREF(Py_None); resultobj = Py_None;
33806 return resultobj;
33807 fail:
33808 return NULL;
33809 }
33810
33811
33812 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33813 PyObject *resultobj;
33814 wxMenu *arg1 = (wxMenu *) 0 ;
33815 wxWindow *result;
33816 PyObject * obj0 = 0 ;
33817 char *kwnames[] = {
33818 (char *) "self", NULL
33819 };
33820
33821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
33822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33823 if (SWIG_arg_fail(1)) SWIG_fail;
33824 {
33825 PyThreadState* __tstate = wxPyBeginAllowThreads();
33826 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
33827
33828 wxPyEndAllowThreads(__tstate);
33829 if (PyErr_Occurred()) SWIG_fail;
33830 }
33831 {
33832 resultobj = wxPyMake_wxObject(result, 0);
33833 }
33834 return resultobj;
33835 fail:
33836 return NULL;
33837 }
33838
33839
33840 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
33841 PyObject *resultobj;
33842 wxMenu *arg1 = (wxMenu *) 0 ;
33843 long result;
33844 PyObject * obj0 = 0 ;
33845 char *kwnames[] = {
33846 (char *) "self", NULL
33847 };
33848
33849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
33850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33851 if (SWIG_arg_fail(1)) SWIG_fail;
33852 {
33853 PyThreadState* __tstate = wxPyBeginAllowThreads();
33854 result = (long)((wxMenu const *)arg1)->GetStyle();
33855
33856 wxPyEndAllowThreads(__tstate);
33857 if (PyErr_Occurred()) SWIG_fail;
33858 }
33859 {
33860 resultobj = SWIG_From_long((long)(result));
33861 }
33862 return resultobj;
33863 fail:
33864 return NULL;
33865 }
33866
33867
33868 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
33869 PyObject *resultobj;
33870 wxMenu *arg1 = (wxMenu *) 0 ;
33871 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
33872 PyObject * obj0 = 0 ;
33873 PyObject * obj1 = 0 ;
33874 char *kwnames[] = {
33875 (char *) "self",(char *) "source", NULL
33876 };
33877
33878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
33879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33880 if (SWIG_arg_fail(1)) SWIG_fail;
33881 if (obj1) {
33882 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33883 if (SWIG_arg_fail(2)) SWIG_fail;
33884 }
33885 {
33886 PyThreadState* __tstate = wxPyBeginAllowThreads();
33887 (arg1)->UpdateUI(arg2);
33888
33889 wxPyEndAllowThreads(__tstate);
33890 if (PyErr_Occurred()) SWIG_fail;
33891 }
33892 Py_INCREF(Py_None); resultobj = Py_None;
33893 return resultobj;
33894 fail:
33895 return NULL;
33896 }
33897
33898
33899 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
33900 PyObject *resultobj;
33901 wxMenu *arg1 = (wxMenu *) 0 ;
33902 wxMenuBar *result;
33903 PyObject * obj0 = 0 ;
33904 char *kwnames[] = {
33905 (char *) "self", NULL
33906 };
33907
33908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
33909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33910 if (SWIG_arg_fail(1)) SWIG_fail;
33911 {
33912 PyThreadState* __tstate = wxPyBeginAllowThreads();
33913 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
33914
33915 wxPyEndAllowThreads(__tstate);
33916 if (PyErr_Occurred()) SWIG_fail;
33917 }
33918 {
33919 resultobj = wxPyMake_wxObject(result, 0);
33920 }
33921 return resultobj;
33922 fail:
33923 return NULL;
33924 }
33925
33926
33927 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
33928 PyObject *resultobj;
33929 wxMenu *arg1 = (wxMenu *) 0 ;
33930 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
33931 PyObject * obj0 = 0 ;
33932 PyObject * obj1 = 0 ;
33933 char *kwnames[] = {
33934 (char *) "self",(char *) "menubar", NULL
33935 };
33936
33937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
33938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33939 if (SWIG_arg_fail(1)) SWIG_fail;
33940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
33941 if (SWIG_arg_fail(2)) SWIG_fail;
33942 {
33943 PyThreadState* __tstate = wxPyBeginAllowThreads();
33944 (arg1)->Attach(arg2);
33945
33946 wxPyEndAllowThreads(__tstate);
33947 if (PyErr_Occurred()) SWIG_fail;
33948 }
33949 Py_INCREF(Py_None); resultobj = Py_None;
33950 return resultobj;
33951 fail:
33952 return NULL;
33953 }
33954
33955
33956 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
33957 PyObject *resultobj;
33958 wxMenu *arg1 = (wxMenu *) 0 ;
33959 PyObject * obj0 = 0 ;
33960 char *kwnames[] = {
33961 (char *) "self", NULL
33962 };
33963
33964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
33965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33966 if (SWIG_arg_fail(1)) SWIG_fail;
33967 {
33968 PyThreadState* __tstate = wxPyBeginAllowThreads();
33969 (arg1)->Detach();
33970
33971 wxPyEndAllowThreads(__tstate);
33972 if (PyErr_Occurred()) SWIG_fail;
33973 }
33974 Py_INCREF(Py_None); resultobj = Py_None;
33975 return resultobj;
33976 fail:
33977 return NULL;
33978 }
33979
33980
33981 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
33982 PyObject *resultobj;
33983 wxMenu *arg1 = (wxMenu *) 0 ;
33984 bool result;
33985 PyObject * obj0 = 0 ;
33986 char *kwnames[] = {
33987 (char *) "self", NULL
33988 };
33989
33990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
33991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33992 if (SWIG_arg_fail(1)) SWIG_fail;
33993 {
33994 PyThreadState* __tstate = wxPyBeginAllowThreads();
33995 result = (bool)((wxMenu const *)arg1)->IsAttached();
33996
33997 wxPyEndAllowThreads(__tstate);
33998 if (PyErr_Occurred()) SWIG_fail;
33999 }
34000 {
34001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34002 }
34003 return resultobj;
34004 fail:
34005 return NULL;
34006 }
34007
34008
34009 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34010 PyObject *resultobj;
34011 wxMenu *arg1 = (wxMenu *) 0 ;
34012 wxMenu *arg2 = (wxMenu *) 0 ;
34013 PyObject * obj0 = 0 ;
34014 PyObject * obj1 = 0 ;
34015 char *kwnames[] = {
34016 (char *) "self",(char *) "parent", NULL
34017 };
34018
34019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34021 if (SWIG_arg_fail(1)) SWIG_fail;
34022 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34023 if (SWIG_arg_fail(2)) SWIG_fail;
34024 {
34025 PyThreadState* __tstate = wxPyBeginAllowThreads();
34026 (arg1)->SetParent(arg2);
34027
34028 wxPyEndAllowThreads(__tstate);
34029 if (PyErr_Occurred()) SWIG_fail;
34030 }
34031 Py_INCREF(Py_None); resultobj = Py_None;
34032 return resultobj;
34033 fail:
34034 return NULL;
34035 }
34036
34037
34038 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34039 PyObject *resultobj;
34040 wxMenu *arg1 = (wxMenu *) 0 ;
34041 wxMenu *result;
34042 PyObject * obj0 = 0 ;
34043 char *kwnames[] = {
34044 (char *) "self", NULL
34045 };
34046
34047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34049 if (SWIG_arg_fail(1)) SWIG_fail;
34050 {
34051 PyThreadState* __tstate = wxPyBeginAllowThreads();
34052 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34053
34054 wxPyEndAllowThreads(__tstate);
34055 if (PyErr_Occurred()) SWIG_fail;
34056 }
34057 {
34058 resultobj = wxPyMake_wxObject(result, 0);
34059 }
34060 return resultobj;
34061 fail:
34062 return NULL;
34063 }
34064
34065
34066 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34067 PyObject *obj;
34068 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34069 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34070 Py_INCREF(obj);
34071 return Py_BuildValue((char *)"");
34072 }
34073 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34074 PyObject *resultobj;
34075 long arg1 = (long) 0 ;
34076 wxMenuBar *result;
34077 PyObject * obj0 = 0 ;
34078 char *kwnames[] = {
34079 (char *) "style", NULL
34080 };
34081
34082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34083 if (obj0) {
34084 {
34085 arg1 = (long)(SWIG_As_long(obj0));
34086 if (SWIG_arg_fail(1)) SWIG_fail;
34087 }
34088 }
34089 {
34090 if (!wxPyCheckForApp()) SWIG_fail;
34091 PyThreadState* __tstate = wxPyBeginAllowThreads();
34092 result = (wxMenuBar *)new wxMenuBar(arg1);
34093
34094 wxPyEndAllowThreads(__tstate);
34095 if (PyErr_Occurred()) SWIG_fail;
34096 }
34097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34098 return resultobj;
34099 fail:
34100 return NULL;
34101 }
34102
34103
34104 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34105 PyObject *resultobj;
34106 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34107 wxMenu *arg2 = (wxMenu *) 0 ;
34108 wxString *arg3 = 0 ;
34109 bool result;
34110 bool temp3 = false ;
34111 PyObject * obj0 = 0 ;
34112 PyObject * obj1 = 0 ;
34113 PyObject * obj2 = 0 ;
34114 char *kwnames[] = {
34115 (char *) "self",(char *) "menu",(char *) "title", NULL
34116 };
34117
34118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34120 if (SWIG_arg_fail(1)) SWIG_fail;
34121 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34122 if (SWIG_arg_fail(2)) SWIG_fail;
34123 {
34124 arg3 = wxString_in_helper(obj2);
34125 if (arg3 == NULL) SWIG_fail;
34126 temp3 = true;
34127 }
34128 {
34129 PyThreadState* __tstate = wxPyBeginAllowThreads();
34130 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34131
34132 wxPyEndAllowThreads(__tstate);
34133 if (PyErr_Occurred()) SWIG_fail;
34134 }
34135 {
34136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34137 }
34138 {
34139 if (temp3)
34140 delete arg3;
34141 }
34142 return resultobj;
34143 fail:
34144 {
34145 if (temp3)
34146 delete arg3;
34147 }
34148 return NULL;
34149 }
34150
34151
34152 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34153 PyObject *resultobj;
34154 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34155 size_t arg2 ;
34156 wxMenu *arg3 = (wxMenu *) 0 ;
34157 wxString *arg4 = 0 ;
34158 bool result;
34159 bool temp4 = false ;
34160 PyObject * obj0 = 0 ;
34161 PyObject * obj1 = 0 ;
34162 PyObject * obj2 = 0 ;
34163 PyObject * obj3 = 0 ;
34164 char *kwnames[] = {
34165 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34166 };
34167
34168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34170 if (SWIG_arg_fail(1)) SWIG_fail;
34171 {
34172 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34173 if (SWIG_arg_fail(2)) SWIG_fail;
34174 }
34175 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34176 if (SWIG_arg_fail(3)) SWIG_fail;
34177 {
34178 arg4 = wxString_in_helper(obj3);
34179 if (arg4 == NULL) SWIG_fail;
34180 temp4 = true;
34181 }
34182 {
34183 PyThreadState* __tstate = wxPyBeginAllowThreads();
34184 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34185
34186 wxPyEndAllowThreads(__tstate);
34187 if (PyErr_Occurred()) SWIG_fail;
34188 }
34189 {
34190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34191 }
34192 {
34193 if (temp4)
34194 delete arg4;
34195 }
34196 return resultobj;
34197 fail:
34198 {
34199 if (temp4)
34200 delete arg4;
34201 }
34202 return NULL;
34203 }
34204
34205
34206 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34207 PyObject *resultobj;
34208 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34209 size_t result;
34210 PyObject * obj0 = 0 ;
34211 char *kwnames[] = {
34212 (char *) "self", NULL
34213 };
34214
34215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34217 if (SWIG_arg_fail(1)) SWIG_fail;
34218 {
34219 PyThreadState* __tstate = wxPyBeginAllowThreads();
34220 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34221
34222 wxPyEndAllowThreads(__tstate);
34223 if (PyErr_Occurred()) SWIG_fail;
34224 }
34225 {
34226 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34227 }
34228 return resultobj;
34229 fail:
34230 return NULL;
34231 }
34232
34233
34234 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34235 PyObject *resultobj;
34236 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34237 size_t arg2 ;
34238 wxMenu *result;
34239 PyObject * obj0 = 0 ;
34240 PyObject * obj1 = 0 ;
34241 char *kwnames[] = {
34242 (char *) "self",(char *) "pos", NULL
34243 };
34244
34245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34247 if (SWIG_arg_fail(1)) SWIG_fail;
34248 {
34249 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34250 if (SWIG_arg_fail(2)) SWIG_fail;
34251 }
34252 {
34253 PyThreadState* __tstate = wxPyBeginAllowThreads();
34254 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34255
34256 wxPyEndAllowThreads(__tstate);
34257 if (PyErr_Occurred()) SWIG_fail;
34258 }
34259 {
34260 resultobj = wxPyMake_wxObject(result, 0);
34261 }
34262 return resultobj;
34263 fail:
34264 return NULL;
34265 }
34266
34267
34268 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34269 PyObject *resultobj;
34270 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34271 size_t arg2 ;
34272 wxMenu *arg3 = (wxMenu *) 0 ;
34273 wxString *arg4 = 0 ;
34274 wxMenu *result;
34275 bool temp4 = false ;
34276 PyObject * obj0 = 0 ;
34277 PyObject * obj1 = 0 ;
34278 PyObject * obj2 = 0 ;
34279 PyObject * obj3 = 0 ;
34280 char *kwnames[] = {
34281 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34282 };
34283
34284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34286 if (SWIG_arg_fail(1)) SWIG_fail;
34287 {
34288 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34289 if (SWIG_arg_fail(2)) SWIG_fail;
34290 }
34291 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34292 if (SWIG_arg_fail(3)) SWIG_fail;
34293 {
34294 arg4 = wxString_in_helper(obj3);
34295 if (arg4 == NULL) SWIG_fail;
34296 temp4 = true;
34297 }
34298 {
34299 PyThreadState* __tstate = wxPyBeginAllowThreads();
34300 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34301
34302 wxPyEndAllowThreads(__tstate);
34303 if (PyErr_Occurred()) SWIG_fail;
34304 }
34305 {
34306 resultobj = wxPyMake_wxObject(result, 0);
34307 }
34308 {
34309 if (temp4)
34310 delete arg4;
34311 }
34312 return resultobj;
34313 fail:
34314 {
34315 if (temp4)
34316 delete arg4;
34317 }
34318 return NULL;
34319 }
34320
34321
34322 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34323 PyObject *resultobj;
34324 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34325 size_t arg2 ;
34326 wxMenu *result;
34327 PyObject * obj0 = 0 ;
34328 PyObject * obj1 = 0 ;
34329 char *kwnames[] = {
34330 (char *) "self",(char *) "pos", NULL
34331 };
34332
34333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34335 if (SWIG_arg_fail(1)) SWIG_fail;
34336 {
34337 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34338 if (SWIG_arg_fail(2)) SWIG_fail;
34339 }
34340 {
34341 PyThreadState* __tstate = wxPyBeginAllowThreads();
34342 result = (wxMenu *)(arg1)->Remove(arg2);
34343
34344 wxPyEndAllowThreads(__tstate);
34345 if (PyErr_Occurred()) SWIG_fail;
34346 }
34347 {
34348 resultobj = wxPyMake_wxObject(result, 0);
34349 }
34350 return resultobj;
34351 fail:
34352 return NULL;
34353 }
34354
34355
34356 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34357 PyObject *resultobj;
34358 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34359 size_t arg2 ;
34360 bool arg3 ;
34361 PyObject * obj0 = 0 ;
34362 PyObject * obj1 = 0 ;
34363 PyObject * obj2 = 0 ;
34364 char *kwnames[] = {
34365 (char *) "self",(char *) "pos",(char *) "enable", NULL
34366 };
34367
34368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34370 if (SWIG_arg_fail(1)) SWIG_fail;
34371 {
34372 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34373 if (SWIG_arg_fail(2)) SWIG_fail;
34374 }
34375 {
34376 arg3 = (bool)(SWIG_As_bool(obj2));
34377 if (SWIG_arg_fail(3)) SWIG_fail;
34378 }
34379 {
34380 PyThreadState* __tstate = wxPyBeginAllowThreads();
34381 (arg1)->EnableTop(arg2,arg3);
34382
34383 wxPyEndAllowThreads(__tstate);
34384 if (PyErr_Occurred()) SWIG_fail;
34385 }
34386 Py_INCREF(Py_None); resultobj = Py_None;
34387 return resultobj;
34388 fail:
34389 return NULL;
34390 }
34391
34392
34393 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34394 PyObject *resultobj;
34395 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34396 size_t arg2 ;
34397 bool result;
34398 PyObject * obj0 = 0 ;
34399 PyObject * obj1 = 0 ;
34400 char *kwnames[] = {
34401 (char *) "self",(char *) "pos", NULL
34402 };
34403
34404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34406 if (SWIG_arg_fail(1)) SWIG_fail;
34407 {
34408 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34409 if (SWIG_arg_fail(2)) SWIG_fail;
34410 }
34411 {
34412 PyThreadState* __tstate = wxPyBeginAllowThreads();
34413 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34414
34415 wxPyEndAllowThreads(__tstate);
34416 if (PyErr_Occurred()) SWIG_fail;
34417 }
34418 {
34419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34420 }
34421 return resultobj;
34422 fail:
34423 return NULL;
34424 }
34425
34426
34427 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34428 PyObject *resultobj;
34429 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34430 size_t arg2 ;
34431 wxString *arg3 = 0 ;
34432 bool temp3 = false ;
34433 PyObject * obj0 = 0 ;
34434 PyObject * obj1 = 0 ;
34435 PyObject * obj2 = 0 ;
34436 char *kwnames[] = {
34437 (char *) "self",(char *) "pos",(char *) "label", NULL
34438 };
34439
34440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34442 if (SWIG_arg_fail(1)) SWIG_fail;
34443 {
34444 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34445 if (SWIG_arg_fail(2)) SWIG_fail;
34446 }
34447 {
34448 arg3 = wxString_in_helper(obj2);
34449 if (arg3 == NULL) SWIG_fail;
34450 temp3 = true;
34451 }
34452 {
34453 PyThreadState* __tstate = wxPyBeginAllowThreads();
34454 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34455
34456 wxPyEndAllowThreads(__tstate);
34457 if (PyErr_Occurred()) SWIG_fail;
34458 }
34459 Py_INCREF(Py_None); resultobj = Py_None;
34460 {
34461 if (temp3)
34462 delete arg3;
34463 }
34464 return resultobj;
34465 fail:
34466 {
34467 if (temp3)
34468 delete arg3;
34469 }
34470 return NULL;
34471 }
34472
34473
34474 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34475 PyObject *resultobj;
34476 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34477 size_t arg2 ;
34478 wxString result;
34479 PyObject * obj0 = 0 ;
34480 PyObject * obj1 = 0 ;
34481 char *kwnames[] = {
34482 (char *) "self",(char *) "pos", NULL
34483 };
34484
34485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34487 if (SWIG_arg_fail(1)) SWIG_fail;
34488 {
34489 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34490 if (SWIG_arg_fail(2)) SWIG_fail;
34491 }
34492 {
34493 PyThreadState* __tstate = wxPyBeginAllowThreads();
34494 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34495
34496 wxPyEndAllowThreads(__tstate);
34497 if (PyErr_Occurred()) SWIG_fail;
34498 }
34499 {
34500 #if wxUSE_UNICODE
34501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34502 #else
34503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34504 #endif
34505 }
34506 return resultobj;
34507 fail:
34508 return NULL;
34509 }
34510
34511
34512 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34513 PyObject *resultobj;
34514 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34515 wxString *arg2 = 0 ;
34516 wxString *arg3 = 0 ;
34517 int result;
34518 bool temp2 = false ;
34519 bool temp3 = false ;
34520 PyObject * obj0 = 0 ;
34521 PyObject * obj1 = 0 ;
34522 PyObject * obj2 = 0 ;
34523 char *kwnames[] = {
34524 (char *) "self",(char *) "menu",(char *) "item", NULL
34525 };
34526
34527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34529 if (SWIG_arg_fail(1)) SWIG_fail;
34530 {
34531 arg2 = wxString_in_helper(obj1);
34532 if (arg2 == NULL) SWIG_fail;
34533 temp2 = true;
34534 }
34535 {
34536 arg3 = wxString_in_helper(obj2);
34537 if (arg3 == NULL) SWIG_fail;
34538 temp3 = true;
34539 }
34540 {
34541 PyThreadState* __tstate = wxPyBeginAllowThreads();
34542 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34543
34544 wxPyEndAllowThreads(__tstate);
34545 if (PyErr_Occurred()) SWIG_fail;
34546 }
34547 {
34548 resultobj = SWIG_From_int((int)(result));
34549 }
34550 {
34551 if (temp2)
34552 delete arg2;
34553 }
34554 {
34555 if (temp3)
34556 delete arg3;
34557 }
34558 return resultobj;
34559 fail:
34560 {
34561 if (temp2)
34562 delete arg2;
34563 }
34564 {
34565 if (temp3)
34566 delete arg3;
34567 }
34568 return NULL;
34569 }
34570
34571
34572 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34573 PyObject *resultobj;
34574 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34575 int arg2 ;
34576 wxMenuItem *result;
34577 PyObject * obj0 = 0 ;
34578 PyObject * obj1 = 0 ;
34579 char *kwnames[] = {
34580 (char *) "self",(char *) "id", NULL
34581 };
34582
34583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34585 if (SWIG_arg_fail(1)) SWIG_fail;
34586 {
34587 arg2 = (int)(SWIG_As_int(obj1));
34588 if (SWIG_arg_fail(2)) SWIG_fail;
34589 }
34590 {
34591 PyThreadState* __tstate = wxPyBeginAllowThreads();
34592 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34593
34594 wxPyEndAllowThreads(__tstate);
34595 if (PyErr_Occurred()) SWIG_fail;
34596 }
34597 {
34598 resultobj = wxPyMake_wxObject(result, 0);
34599 }
34600 return resultobj;
34601 fail:
34602 return NULL;
34603 }
34604
34605
34606 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34607 PyObject *resultobj;
34608 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34609 wxString *arg2 = 0 ;
34610 int result;
34611 bool temp2 = false ;
34612 PyObject * obj0 = 0 ;
34613 PyObject * obj1 = 0 ;
34614 char *kwnames[] = {
34615 (char *) "self",(char *) "title", NULL
34616 };
34617
34618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34620 if (SWIG_arg_fail(1)) SWIG_fail;
34621 {
34622 arg2 = wxString_in_helper(obj1);
34623 if (arg2 == NULL) SWIG_fail;
34624 temp2 = true;
34625 }
34626 {
34627 PyThreadState* __tstate = wxPyBeginAllowThreads();
34628 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34629
34630 wxPyEndAllowThreads(__tstate);
34631 if (PyErr_Occurred()) SWIG_fail;
34632 }
34633 {
34634 resultobj = SWIG_From_int((int)(result));
34635 }
34636 {
34637 if (temp2)
34638 delete arg2;
34639 }
34640 return resultobj;
34641 fail:
34642 {
34643 if (temp2)
34644 delete arg2;
34645 }
34646 return NULL;
34647 }
34648
34649
34650 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34651 PyObject *resultobj;
34652 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34653 int arg2 ;
34654 bool arg3 ;
34655 PyObject * obj0 = 0 ;
34656 PyObject * obj1 = 0 ;
34657 PyObject * obj2 = 0 ;
34658 char *kwnames[] = {
34659 (char *) "self",(char *) "id",(char *) "enable", NULL
34660 };
34661
34662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34664 if (SWIG_arg_fail(1)) SWIG_fail;
34665 {
34666 arg2 = (int)(SWIG_As_int(obj1));
34667 if (SWIG_arg_fail(2)) SWIG_fail;
34668 }
34669 {
34670 arg3 = (bool)(SWIG_As_bool(obj2));
34671 if (SWIG_arg_fail(3)) SWIG_fail;
34672 }
34673 {
34674 PyThreadState* __tstate = wxPyBeginAllowThreads();
34675 (arg1)->Enable(arg2,arg3);
34676
34677 wxPyEndAllowThreads(__tstate);
34678 if (PyErr_Occurred()) SWIG_fail;
34679 }
34680 Py_INCREF(Py_None); resultobj = Py_None;
34681 return resultobj;
34682 fail:
34683 return NULL;
34684 }
34685
34686
34687 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34688 PyObject *resultobj;
34689 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34690 int arg2 ;
34691 bool arg3 ;
34692 PyObject * obj0 = 0 ;
34693 PyObject * obj1 = 0 ;
34694 PyObject * obj2 = 0 ;
34695 char *kwnames[] = {
34696 (char *) "self",(char *) "id",(char *) "check", NULL
34697 };
34698
34699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34701 if (SWIG_arg_fail(1)) SWIG_fail;
34702 {
34703 arg2 = (int)(SWIG_As_int(obj1));
34704 if (SWIG_arg_fail(2)) SWIG_fail;
34705 }
34706 {
34707 arg3 = (bool)(SWIG_As_bool(obj2));
34708 if (SWIG_arg_fail(3)) SWIG_fail;
34709 }
34710 {
34711 PyThreadState* __tstate = wxPyBeginAllowThreads();
34712 (arg1)->Check(arg2,arg3);
34713
34714 wxPyEndAllowThreads(__tstate);
34715 if (PyErr_Occurred()) SWIG_fail;
34716 }
34717 Py_INCREF(Py_None); resultobj = Py_None;
34718 return resultobj;
34719 fail:
34720 return NULL;
34721 }
34722
34723
34724 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34725 PyObject *resultobj;
34726 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34727 int arg2 ;
34728 bool result;
34729 PyObject * obj0 = 0 ;
34730 PyObject * obj1 = 0 ;
34731 char *kwnames[] = {
34732 (char *) "self",(char *) "id", NULL
34733 };
34734
34735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34737 if (SWIG_arg_fail(1)) SWIG_fail;
34738 {
34739 arg2 = (int)(SWIG_As_int(obj1));
34740 if (SWIG_arg_fail(2)) SWIG_fail;
34741 }
34742 {
34743 PyThreadState* __tstate = wxPyBeginAllowThreads();
34744 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
34745
34746 wxPyEndAllowThreads(__tstate);
34747 if (PyErr_Occurred()) SWIG_fail;
34748 }
34749 {
34750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34751 }
34752 return resultobj;
34753 fail:
34754 return NULL;
34755 }
34756
34757
34758 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34759 PyObject *resultobj;
34760 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34761 int arg2 ;
34762 bool result;
34763 PyObject * obj0 = 0 ;
34764 PyObject * obj1 = 0 ;
34765 char *kwnames[] = {
34766 (char *) "self",(char *) "id", NULL
34767 };
34768
34769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34771 if (SWIG_arg_fail(1)) SWIG_fail;
34772 {
34773 arg2 = (int)(SWIG_As_int(obj1));
34774 if (SWIG_arg_fail(2)) SWIG_fail;
34775 }
34776 {
34777 PyThreadState* __tstate = wxPyBeginAllowThreads();
34778 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
34779
34780 wxPyEndAllowThreads(__tstate);
34781 if (PyErr_Occurred()) SWIG_fail;
34782 }
34783 {
34784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34785 }
34786 return resultobj;
34787 fail:
34788 return NULL;
34789 }
34790
34791
34792 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34793 PyObject *resultobj;
34794 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34795 int arg2 ;
34796 wxString *arg3 = 0 ;
34797 bool temp3 = false ;
34798 PyObject * obj0 = 0 ;
34799 PyObject * obj1 = 0 ;
34800 PyObject * obj2 = 0 ;
34801 char *kwnames[] = {
34802 (char *) "self",(char *) "id",(char *) "label", NULL
34803 };
34804
34805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34807 if (SWIG_arg_fail(1)) SWIG_fail;
34808 {
34809 arg2 = (int)(SWIG_As_int(obj1));
34810 if (SWIG_arg_fail(2)) SWIG_fail;
34811 }
34812 {
34813 arg3 = wxString_in_helper(obj2);
34814 if (arg3 == NULL) SWIG_fail;
34815 temp3 = true;
34816 }
34817 {
34818 PyThreadState* __tstate = wxPyBeginAllowThreads();
34819 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34820
34821 wxPyEndAllowThreads(__tstate);
34822 if (PyErr_Occurred()) SWIG_fail;
34823 }
34824 Py_INCREF(Py_None); resultobj = Py_None;
34825 {
34826 if (temp3)
34827 delete arg3;
34828 }
34829 return resultobj;
34830 fail:
34831 {
34832 if (temp3)
34833 delete arg3;
34834 }
34835 return NULL;
34836 }
34837
34838
34839 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34840 PyObject *resultobj;
34841 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34842 int arg2 ;
34843 wxString result;
34844 PyObject * obj0 = 0 ;
34845 PyObject * obj1 = 0 ;
34846 char *kwnames[] = {
34847 (char *) "self",(char *) "id", NULL
34848 };
34849
34850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34852 if (SWIG_arg_fail(1)) SWIG_fail;
34853 {
34854 arg2 = (int)(SWIG_As_int(obj1));
34855 if (SWIG_arg_fail(2)) SWIG_fail;
34856 }
34857 {
34858 PyThreadState* __tstate = wxPyBeginAllowThreads();
34859 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
34860
34861 wxPyEndAllowThreads(__tstate);
34862 if (PyErr_Occurred()) SWIG_fail;
34863 }
34864 {
34865 #if wxUSE_UNICODE
34866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34867 #else
34868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34869 #endif
34870 }
34871 return resultobj;
34872 fail:
34873 return NULL;
34874 }
34875
34876
34877 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34878 PyObject *resultobj;
34879 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34880 int arg2 ;
34881 wxString *arg3 = 0 ;
34882 bool temp3 = false ;
34883 PyObject * obj0 = 0 ;
34884 PyObject * obj1 = 0 ;
34885 PyObject * obj2 = 0 ;
34886 char *kwnames[] = {
34887 (char *) "self",(char *) "id",(char *) "helpString", NULL
34888 };
34889
34890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34892 if (SWIG_arg_fail(1)) SWIG_fail;
34893 {
34894 arg2 = (int)(SWIG_As_int(obj1));
34895 if (SWIG_arg_fail(2)) SWIG_fail;
34896 }
34897 {
34898 arg3 = wxString_in_helper(obj2);
34899 if (arg3 == NULL) SWIG_fail;
34900 temp3 = true;
34901 }
34902 {
34903 PyThreadState* __tstate = wxPyBeginAllowThreads();
34904 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34905
34906 wxPyEndAllowThreads(__tstate);
34907 if (PyErr_Occurred()) SWIG_fail;
34908 }
34909 Py_INCREF(Py_None); resultobj = Py_None;
34910 {
34911 if (temp3)
34912 delete arg3;
34913 }
34914 return resultobj;
34915 fail:
34916 {
34917 if (temp3)
34918 delete arg3;
34919 }
34920 return NULL;
34921 }
34922
34923
34924 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34925 PyObject *resultobj;
34926 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34927 int arg2 ;
34928 wxString result;
34929 PyObject * obj0 = 0 ;
34930 PyObject * obj1 = 0 ;
34931 char *kwnames[] = {
34932 (char *) "self",(char *) "id", NULL
34933 };
34934
34935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
34940 if (SWIG_arg_fail(2)) SWIG_fail;
34941 }
34942 {
34943 PyThreadState* __tstate = wxPyBeginAllowThreads();
34944 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
34945
34946 wxPyEndAllowThreads(__tstate);
34947 if (PyErr_Occurred()) SWIG_fail;
34948 }
34949 {
34950 #if wxUSE_UNICODE
34951 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34952 #else
34953 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34954 #endif
34955 }
34956 return resultobj;
34957 fail:
34958 return NULL;
34959 }
34960
34961
34962 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
34963 PyObject *resultobj;
34964 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34965 wxFrame *result;
34966 PyObject * obj0 = 0 ;
34967 char *kwnames[] = {
34968 (char *) "self", NULL
34969 };
34970
34971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
34972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34973 if (SWIG_arg_fail(1)) SWIG_fail;
34974 {
34975 PyThreadState* __tstate = wxPyBeginAllowThreads();
34976 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
34977
34978 wxPyEndAllowThreads(__tstate);
34979 if (PyErr_Occurred()) SWIG_fail;
34980 }
34981 {
34982 resultobj = wxPyMake_wxObject(result, 0);
34983 }
34984 return resultobj;
34985 fail:
34986 return NULL;
34987 }
34988
34989
34990 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34991 PyObject *resultobj;
34992 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34993 bool result;
34994 PyObject * obj0 = 0 ;
34995 char *kwnames[] = {
34996 (char *) "self", NULL
34997 };
34998
34999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35001 if (SWIG_arg_fail(1)) SWIG_fail;
35002 {
35003 PyThreadState* __tstate = wxPyBeginAllowThreads();
35004 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35005
35006 wxPyEndAllowThreads(__tstate);
35007 if (PyErr_Occurred()) SWIG_fail;
35008 }
35009 {
35010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35011 }
35012 return resultobj;
35013 fail:
35014 return NULL;
35015 }
35016
35017
35018 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35019 PyObject *resultobj;
35020 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35021 wxFrame *arg2 = (wxFrame *) 0 ;
35022 PyObject * obj0 = 0 ;
35023 PyObject * obj1 = 0 ;
35024 char *kwnames[] = {
35025 (char *) "self",(char *) "frame", NULL
35026 };
35027
35028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35030 if (SWIG_arg_fail(1)) SWIG_fail;
35031 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35032 if (SWIG_arg_fail(2)) SWIG_fail;
35033 {
35034 PyThreadState* __tstate = wxPyBeginAllowThreads();
35035 (arg1)->Attach(arg2);
35036
35037 wxPyEndAllowThreads(__tstate);
35038 if (PyErr_Occurred()) SWIG_fail;
35039 }
35040 Py_INCREF(Py_None); resultobj = Py_None;
35041 return resultobj;
35042 fail:
35043 return NULL;
35044 }
35045
35046
35047 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35048 PyObject *resultobj;
35049 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35050 PyObject * obj0 = 0 ;
35051 char *kwnames[] = {
35052 (char *) "self", NULL
35053 };
35054
35055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35057 if (SWIG_arg_fail(1)) SWIG_fail;
35058 {
35059 PyThreadState* __tstate = wxPyBeginAllowThreads();
35060 (arg1)->Detach();
35061
35062 wxPyEndAllowThreads(__tstate);
35063 if (PyErr_Occurred()) SWIG_fail;
35064 }
35065 Py_INCREF(Py_None); resultobj = Py_None;
35066 return resultobj;
35067 fail:
35068 return NULL;
35069 }
35070
35071
35072 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35073 PyObject *obj;
35074 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35075 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35076 Py_INCREF(obj);
35077 return Py_BuildValue((char *)"");
35078 }
35079 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35080 PyObject *resultobj;
35081 wxMenu *arg1 = (wxMenu *) NULL ;
35082 int arg2 = (int) wxID_ANY ;
35083 wxString const &arg3_defvalue = wxPyEmptyString ;
35084 wxString *arg3 = (wxString *) &arg3_defvalue ;
35085 wxString const &arg4_defvalue = wxPyEmptyString ;
35086 wxString *arg4 = (wxString *) &arg4_defvalue ;
35087 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35088 wxMenu *arg6 = (wxMenu *) NULL ;
35089 wxMenuItem *result;
35090 bool temp3 = false ;
35091 bool temp4 = false ;
35092 PyObject * obj0 = 0 ;
35093 PyObject * obj1 = 0 ;
35094 PyObject * obj2 = 0 ;
35095 PyObject * obj3 = 0 ;
35096 PyObject * obj4 = 0 ;
35097 PyObject * obj5 = 0 ;
35098 char *kwnames[] = {
35099 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35100 };
35101
35102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35103 if (obj0) {
35104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35105 if (SWIG_arg_fail(1)) SWIG_fail;
35106 }
35107 if (obj1) {
35108 {
35109 arg2 = (int)(SWIG_As_int(obj1));
35110 if (SWIG_arg_fail(2)) SWIG_fail;
35111 }
35112 }
35113 if (obj2) {
35114 {
35115 arg3 = wxString_in_helper(obj2);
35116 if (arg3 == NULL) SWIG_fail;
35117 temp3 = true;
35118 }
35119 }
35120 if (obj3) {
35121 {
35122 arg4 = wxString_in_helper(obj3);
35123 if (arg4 == NULL) SWIG_fail;
35124 temp4 = true;
35125 }
35126 }
35127 if (obj4) {
35128 {
35129 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35130 if (SWIG_arg_fail(5)) SWIG_fail;
35131 }
35132 }
35133 if (obj5) {
35134 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35135 if (SWIG_arg_fail(6)) SWIG_fail;
35136 }
35137 {
35138 PyThreadState* __tstate = wxPyBeginAllowThreads();
35139 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35140
35141 wxPyEndAllowThreads(__tstate);
35142 if (PyErr_Occurred()) SWIG_fail;
35143 }
35144 {
35145 resultobj = wxPyMake_wxObject(result, 1);
35146 }
35147 {
35148 if (temp3)
35149 delete arg3;
35150 }
35151 {
35152 if (temp4)
35153 delete arg4;
35154 }
35155 return resultobj;
35156 fail:
35157 {
35158 if (temp3)
35159 delete arg3;
35160 }
35161 {
35162 if (temp4)
35163 delete arg4;
35164 }
35165 return NULL;
35166 }
35167
35168
35169 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35170 PyObject *resultobj;
35171 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35172 wxMenu *result;
35173 PyObject * obj0 = 0 ;
35174 char *kwnames[] = {
35175 (char *) "self", NULL
35176 };
35177
35178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35180 if (SWIG_arg_fail(1)) SWIG_fail;
35181 {
35182 PyThreadState* __tstate = wxPyBeginAllowThreads();
35183 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35184
35185 wxPyEndAllowThreads(__tstate);
35186 if (PyErr_Occurred()) SWIG_fail;
35187 }
35188 {
35189 resultobj = wxPyMake_wxObject(result, 0);
35190 }
35191 return resultobj;
35192 fail:
35193 return NULL;
35194 }
35195
35196
35197 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35198 PyObject *resultobj;
35199 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35200 wxMenu *arg2 = (wxMenu *) 0 ;
35201 PyObject * obj0 = 0 ;
35202 PyObject * obj1 = 0 ;
35203 char *kwnames[] = {
35204 (char *) "self",(char *) "menu", NULL
35205 };
35206
35207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35209 if (SWIG_arg_fail(1)) SWIG_fail;
35210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35211 if (SWIG_arg_fail(2)) SWIG_fail;
35212 {
35213 PyThreadState* __tstate = wxPyBeginAllowThreads();
35214 (arg1)->SetMenu(arg2);
35215
35216 wxPyEndAllowThreads(__tstate);
35217 if (PyErr_Occurred()) SWIG_fail;
35218 }
35219 Py_INCREF(Py_None); resultobj = Py_None;
35220 return resultobj;
35221 fail:
35222 return NULL;
35223 }
35224
35225
35226 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35227 PyObject *resultobj;
35228 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35229 int arg2 ;
35230 PyObject * obj0 = 0 ;
35231 PyObject * obj1 = 0 ;
35232 char *kwnames[] = {
35233 (char *) "self",(char *) "id", NULL
35234 };
35235
35236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35238 if (SWIG_arg_fail(1)) SWIG_fail;
35239 {
35240 arg2 = (int)(SWIG_As_int(obj1));
35241 if (SWIG_arg_fail(2)) SWIG_fail;
35242 }
35243 {
35244 PyThreadState* __tstate = wxPyBeginAllowThreads();
35245 (arg1)->SetId(arg2);
35246
35247 wxPyEndAllowThreads(__tstate);
35248 if (PyErr_Occurred()) SWIG_fail;
35249 }
35250 Py_INCREF(Py_None); resultobj = Py_None;
35251 return resultobj;
35252 fail:
35253 return NULL;
35254 }
35255
35256
35257 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35258 PyObject *resultobj;
35259 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35260 int result;
35261 PyObject * obj0 = 0 ;
35262 char *kwnames[] = {
35263 (char *) "self", NULL
35264 };
35265
35266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35268 if (SWIG_arg_fail(1)) SWIG_fail;
35269 {
35270 PyThreadState* __tstate = wxPyBeginAllowThreads();
35271 result = (int)((wxMenuItem const *)arg1)->GetId();
35272
35273 wxPyEndAllowThreads(__tstate);
35274 if (PyErr_Occurred()) SWIG_fail;
35275 }
35276 {
35277 resultobj = SWIG_From_int((int)(result));
35278 }
35279 return resultobj;
35280 fail:
35281 return NULL;
35282 }
35283
35284
35285 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35286 PyObject *resultobj;
35287 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35288 bool result;
35289 PyObject * obj0 = 0 ;
35290 char *kwnames[] = {
35291 (char *) "self", NULL
35292 };
35293
35294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35296 if (SWIG_arg_fail(1)) SWIG_fail;
35297 {
35298 PyThreadState* __tstate = wxPyBeginAllowThreads();
35299 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35300
35301 wxPyEndAllowThreads(__tstate);
35302 if (PyErr_Occurred()) SWIG_fail;
35303 }
35304 {
35305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35306 }
35307 return resultobj;
35308 fail:
35309 return NULL;
35310 }
35311
35312
35313 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35314 PyObject *resultobj;
35315 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35316 wxString *arg2 = 0 ;
35317 bool temp2 = false ;
35318 PyObject * obj0 = 0 ;
35319 PyObject * obj1 = 0 ;
35320 char *kwnames[] = {
35321 (char *) "self",(char *) "str", NULL
35322 };
35323
35324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35326 if (SWIG_arg_fail(1)) SWIG_fail;
35327 {
35328 arg2 = wxString_in_helper(obj1);
35329 if (arg2 == NULL) SWIG_fail;
35330 temp2 = true;
35331 }
35332 {
35333 PyThreadState* __tstate = wxPyBeginAllowThreads();
35334 (arg1)->SetText((wxString const &)*arg2);
35335
35336 wxPyEndAllowThreads(__tstate);
35337 if (PyErr_Occurred()) SWIG_fail;
35338 }
35339 Py_INCREF(Py_None); resultobj = Py_None;
35340 {
35341 if (temp2)
35342 delete arg2;
35343 }
35344 return resultobj;
35345 fail:
35346 {
35347 if (temp2)
35348 delete arg2;
35349 }
35350 return NULL;
35351 }
35352
35353
35354 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35355 PyObject *resultobj;
35356 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35357 wxString result;
35358 PyObject * obj0 = 0 ;
35359 char *kwnames[] = {
35360 (char *) "self", NULL
35361 };
35362
35363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35365 if (SWIG_arg_fail(1)) SWIG_fail;
35366 {
35367 PyThreadState* __tstate = wxPyBeginAllowThreads();
35368 result = ((wxMenuItem const *)arg1)->GetLabel();
35369
35370 wxPyEndAllowThreads(__tstate);
35371 if (PyErr_Occurred()) SWIG_fail;
35372 }
35373 {
35374 #if wxUSE_UNICODE
35375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35376 #else
35377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35378 #endif
35379 }
35380 return resultobj;
35381 fail:
35382 return NULL;
35383 }
35384
35385
35386 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35387 PyObject *resultobj;
35388 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35389 wxString *result;
35390 PyObject * obj0 = 0 ;
35391 char *kwnames[] = {
35392 (char *) "self", NULL
35393 };
35394
35395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35397 if (SWIG_arg_fail(1)) SWIG_fail;
35398 {
35399 PyThreadState* __tstate = wxPyBeginAllowThreads();
35400 {
35401 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35402 result = (wxString *) &_result_ref;
35403 }
35404
35405 wxPyEndAllowThreads(__tstate);
35406 if (PyErr_Occurred()) SWIG_fail;
35407 }
35408 {
35409 #if wxUSE_UNICODE
35410 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35411 #else
35412 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35413 #endif
35414 }
35415 return resultobj;
35416 fail:
35417 return NULL;
35418 }
35419
35420
35421 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35422 PyObject *resultobj;
35423 wxString *arg1 = 0 ;
35424 wxString result;
35425 bool temp1 = false ;
35426 PyObject * obj0 = 0 ;
35427 char *kwnames[] = {
35428 (char *) "text", NULL
35429 };
35430
35431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35432 {
35433 arg1 = wxString_in_helper(obj0);
35434 if (arg1 == NULL) SWIG_fail;
35435 temp1 = true;
35436 }
35437 {
35438 PyThreadState* __tstate = wxPyBeginAllowThreads();
35439 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35440
35441 wxPyEndAllowThreads(__tstate);
35442 if (PyErr_Occurred()) SWIG_fail;
35443 }
35444 {
35445 #if wxUSE_UNICODE
35446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35447 #else
35448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35449 #endif
35450 }
35451 {
35452 if (temp1)
35453 delete arg1;
35454 }
35455 return resultobj;
35456 fail:
35457 {
35458 if (temp1)
35459 delete arg1;
35460 }
35461 return NULL;
35462 }
35463
35464
35465 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35466 PyObject *resultobj;
35467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35468 wxItemKind result;
35469 PyObject * obj0 = 0 ;
35470 char *kwnames[] = {
35471 (char *) "self", NULL
35472 };
35473
35474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35476 if (SWIG_arg_fail(1)) SWIG_fail;
35477 {
35478 PyThreadState* __tstate = wxPyBeginAllowThreads();
35479 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35480
35481 wxPyEndAllowThreads(__tstate);
35482 if (PyErr_Occurred()) SWIG_fail;
35483 }
35484 resultobj = SWIG_From_int((result));
35485 return resultobj;
35486 fail:
35487 return NULL;
35488 }
35489
35490
35491 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35492 PyObject *resultobj;
35493 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35494 wxItemKind arg2 ;
35495 PyObject * obj0 = 0 ;
35496 PyObject * obj1 = 0 ;
35497 char *kwnames[] = {
35498 (char *) "self",(char *) "kind", NULL
35499 };
35500
35501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35503 if (SWIG_arg_fail(1)) SWIG_fail;
35504 {
35505 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35506 if (SWIG_arg_fail(2)) SWIG_fail;
35507 }
35508 {
35509 PyThreadState* __tstate = wxPyBeginAllowThreads();
35510 (arg1)->SetKind((wxItemKind )arg2);
35511
35512 wxPyEndAllowThreads(__tstate);
35513 if (PyErr_Occurred()) SWIG_fail;
35514 }
35515 Py_INCREF(Py_None); resultobj = Py_None;
35516 return resultobj;
35517 fail:
35518 return NULL;
35519 }
35520
35521
35522 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35523 PyObject *resultobj;
35524 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35525 bool arg2 ;
35526 PyObject * obj0 = 0 ;
35527 PyObject * obj1 = 0 ;
35528 char *kwnames[] = {
35529 (char *) "self",(char *) "checkable", NULL
35530 };
35531
35532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35534 if (SWIG_arg_fail(1)) SWIG_fail;
35535 {
35536 arg2 = (bool)(SWIG_As_bool(obj1));
35537 if (SWIG_arg_fail(2)) SWIG_fail;
35538 }
35539 {
35540 PyThreadState* __tstate = wxPyBeginAllowThreads();
35541 (arg1)->SetCheckable(arg2);
35542
35543 wxPyEndAllowThreads(__tstate);
35544 if (PyErr_Occurred()) SWIG_fail;
35545 }
35546 Py_INCREF(Py_None); resultobj = Py_None;
35547 return resultobj;
35548 fail:
35549 return NULL;
35550 }
35551
35552
35553 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35554 PyObject *resultobj;
35555 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35556 bool result;
35557 PyObject * obj0 = 0 ;
35558 char *kwnames[] = {
35559 (char *) "self", NULL
35560 };
35561
35562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35564 if (SWIG_arg_fail(1)) SWIG_fail;
35565 {
35566 PyThreadState* __tstate = wxPyBeginAllowThreads();
35567 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35568
35569 wxPyEndAllowThreads(__tstate);
35570 if (PyErr_Occurred()) SWIG_fail;
35571 }
35572 {
35573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35574 }
35575 return resultobj;
35576 fail:
35577 return NULL;
35578 }
35579
35580
35581 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35582 PyObject *resultobj;
35583 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35584 bool result;
35585 PyObject * obj0 = 0 ;
35586 char *kwnames[] = {
35587 (char *) "self", NULL
35588 };
35589
35590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35592 if (SWIG_arg_fail(1)) SWIG_fail;
35593 {
35594 PyThreadState* __tstate = wxPyBeginAllowThreads();
35595 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35596
35597 wxPyEndAllowThreads(__tstate);
35598 if (PyErr_Occurred()) SWIG_fail;
35599 }
35600 {
35601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35602 }
35603 return resultobj;
35604 fail:
35605 return NULL;
35606 }
35607
35608
35609 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35610 PyObject *resultobj;
35611 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35612 wxMenu *arg2 = (wxMenu *) 0 ;
35613 PyObject * obj0 = 0 ;
35614 PyObject * obj1 = 0 ;
35615 char *kwnames[] = {
35616 (char *) "self",(char *) "menu", NULL
35617 };
35618
35619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35621 if (SWIG_arg_fail(1)) SWIG_fail;
35622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35623 if (SWIG_arg_fail(2)) SWIG_fail;
35624 {
35625 PyThreadState* __tstate = wxPyBeginAllowThreads();
35626 (arg1)->SetSubMenu(arg2);
35627
35628 wxPyEndAllowThreads(__tstate);
35629 if (PyErr_Occurred()) SWIG_fail;
35630 }
35631 Py_INCREF(Py_None); resultobj = Py_None;
35632 return resultobj;
35633 fail:
35634 return NULL;
35635 }
35636
35637
35638 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35639 PyObject *resultobj;
35640 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35641 wxMenu *result;
35642 PyObject * obj0 = 0 ;
35643 char *kwnames[] = {
35644 (char *) "self", NULL
35645 };
35646
35647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35649 if (SWIG_arg_fail(1)) SWIG_fail;
35650 {
35651 PyThreadState* __tstate = wxPyBeginAllowThreads();
35652 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35653
35654 wxPyEndAllowThreads(__tstate);
35655 if (PyErr_Occurred()) SWIG_fail;
35656 }
35657 {
35658 resultobj = wxPyMake_wxObject(result, 0);
35659 }
35660 return resultobj;
35661 fail:
35662 return NULL;
35663 }
35664
35665
35666 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35667 PyObject *resultobj;
35668 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35669 bool arg2 = (bool) true ;
35670 PyObject * obj0 = 0 ;
35671 PyObject * obj1 = 0 ;
35672 char *kwnames[] = {
35673 (char *) "self",(char *) "enable", NULL
35674 };
35675
35676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35678 if (SWIG_arg_fail(1)) SWIG_fail;
35679 if (obj1) {
35680 {
35681 arg2 = (bool)(SWIG_As_bool(obj1));
35682 if (SWIG_arg_fail(2)) SWIG_fail;
35683 }
35684 }
35685 {
35686 PyThreadState* __tstate = wxPyBeginAllowThreads();
35687 (arg1)->Enable(arg2);
35688
35689 wxPyEndAllowThreads(__tstate);
35690 if (PyErr_Occurred()) SWIG_fail;
35691 }
35692 Py_INCREF(Py_None); resultobj = Py_None;
35693 return resultobj;
35694 fail:
35695 return NULL;
35696 }
35697
35698
35699 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35700 PyObject *resultobj;
35701 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35702 bool result;
35703 PyObject * obj0 = 0 ;
35704 char *kwnames[] = {
35705 (char *) "self", NULL
35706 };
35707
35708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35710 if (SWIG_arg_fail(1)) SWIG_fail;
35711 {
35712 PyThreadState* __tstate = wxPyBeginAllowThreads();
35713 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35714
35715 wxPyEndAllowThreads(__tstate);
35716 if (PyErr_Occurred()) SWIG_fail;
35717 }
35718 {
35719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35720 }
35721 return resultobj;
35722 fail:
35723 return NULL;
35724 }
35725
35726
35727 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35728 PyObject *resultobj;
35729 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35730 bool arg2 = (bool) true ;
35731 PyObject * obj0 = 0 ;
35732 PyObject * obj1 = 0 ;
35733 char *kwnames[] = {
35734 (char *) "self",(char *) "check", NULL
35735 };
35736
35737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35739 if (SWIG_arg_fail(1)) SWIG_fail;
35740 if (obj1) {
35741 {
35742 arg2 = (bool)(SWIG_As_bool(obj1));
35743 if (SWIG_arg_fail(2)) SWIG_fail;
35744 }
35745 }
35746 {
35747 PyThreadState* __tstate = wxPyBeginAllowThreads();
35748 (arg1)->Check(arg2);
35749
35750 wxPyEndAllowThreads(__tstate);
35751 if (PyErr_Occurred()) SWIG_fail;
35752 }
35753 Py_INCREF(Py_None); resultobj = Py_None;
35754 return resultobj;
35755 fail:
35756 return NULL;
35757 }
35758
35759
35760 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35761 PyObject *resultobj;
35762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35763 bool result;
35764 PyObject * obj0 = 0 ;
35765 char *kwnames[] = {
35766 (char *) "self", NULL
35767 };
35768
35769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
35770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35771 if (SWIG_arg_fail(1)) SWIG_fail;
35772 {
35773 PyThreadState* __tstate = wxPyBeginAllowThreads();
35774 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
35775
35776 wxPyEndAllowThreads(__tstate);
35777 if (PyErr_Occurred()) SWIG_fail;
35778 }
35779 {
35780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35781 }
35782 return resultobj;
35783 fail:
35784 return NULL;
35785 }
35786
35787
35788 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
35789 PyObject *resultobj;
35790 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35791 PyObject * obj0 = 0 ;
35792 char *kwnames[] = {
35793 (char *) "self", NULL
35794 };
35795
35796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
35797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35798 if (SWIG_arg_fail(1)) SWIG_fail;
35799 {
35800 PyThreadState* __tstate = wxPyBeginAllowThreads();
35801 (arg1)->Toggle();
35802
35803 wxPyEndAllowThreads(__tstate);
35804 if (PyErr_Occurred()) SWIG_fail;
35805 }
35806 Py_INCREF(Py_None); resultobj = Py_None;
35807 return resultobj;
35808 fail:
35809 return NULL;
35810 }
35811
35812
35813 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35814 PyObject *resultobj;
35815 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35816 wxString *arg2 = 0 ;
35817 bool temp2 = false ;
35818 PyObject * obj0 = 0 ;
35819 PyObject * obj1 = 0 ;
35820 char *kwnames[] = {
35821 (char *) "self",(char *) "str", NULL
35822 };
35823
35824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
35825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35826 if (SWIG_arg_fail(1)) SWIG_fail;
35827 {
35828 arg2 = wxString_in_helper(obj1);
35829 if (arg2 == NULL) SWIG_fail;
35830 temp2 = true;
35831 }
35832 {
35833 PyThreadState* __tstate = wxPyBeginAllowThreads();
35834 (arg1)->SetHelp((wxString const &)*arg2);
35835
35836 wxPyEndAllowThreads(__tstate);
35837 if (PyErr_Occurred()) SWIG_fail;
35838 }
35839 Py_INCREF(Py_None); resultobj = Py_None;
35840 {
35841 if (temp2)
35842 delete arg2;
35843 }
35844 return resultobj;
35845 fail:
35846 {
35847 if (temp2)
35848 delete arg2;
35849 }
35850 return NULL;
35851 }
35852
35853
35854 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35855 PyObject *resultobj;
35856 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35857 wxString *result;
35858 PyObject * obj0 = 0 ;
35859 char *kwnames[] = {
35860 (char *) "self", NULL
35861 };
35862
35863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
35864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35865 if (SWIG_arg_fail(1)) SWIG_fail;
35866 {
35867 PyThreadState* __tstate = wxPyBeginAllowThreads();
35868 {
35869 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
35870 result = (wxString *) &_result_ref;
35871 }
35872
35873 wxPyEndAllowThreads(__tstate);
35874 if (PyErr_Occurred()) SWIG_fail;
35875 }
35876 {
35877 #if wxUSE_UNICODE
35878 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35879 #else
35880 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35881 #endif
35882 }
35883 return resultobj;
35884 fail:
35885 return NULL;
35886 }
35887
35888
35889 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35890 PyObject *resultobj;
35891 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35892 wxAcceleratorEntry *result;
35893 PyObject * obj0 = 0 ;
35894 char *kwnames[] = {
35895 (char *) "self", NULL
35896 };
35897
35898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
35899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35900 if (SWIG_arg_fail(1)) SWIG_fail;
35901 {
35902 PyThreadState* __tstate = wxPyBeginAllowThreads();
35903 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
35904
35905 wxPyEndAllowThreads(__tstate);
35906 if (PyErr_Occurred()) SWIG_fail;
35907 }
35908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
35909 return resultobj;
35910 fail:
35911 return NULL;
35912 }
35913
35914
35915 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35916 PyObject *resultobj;
35917 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35918 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
35919 PyObject * obj0 = 0 ;
35920 PyObject * obj1 = 0 ;
35921 char *kwnames[] = {
35922 (char *) "self",(char *) "accel", NULL
35923 };
35924
35925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
35926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35927 if (SWIG_arg_fail(1)) SWIG_fail;
35928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
35929 if (SWIG_arg_fail(2)) SWIG_fail;
35930 {
35931 PyThreadState* __tstate = wxPyBeginAllowThreads();
35932 (arg1)->SetAccel(arg2);
35933
35934 wxPyEndAllowThreads(__tstate);
35935 if (PyErr_Occurred()) SWIG_fail;
35936 }
35937 Py_INCREF(Py_None); resultobj = Py_None;
35938 return resultobj;
35939 fail:
35940 return NULL;
35941 }
35942
35943
35944 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
35945 PyObject *resultobj;
35946 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35947 wxFont *arg2 = 0 ;
35948 PyObject * obj0 = 0 ;
35949 PyObject * obj1 = 0 ;
35950 char *kwnames[] = {
35951 (char *) "self",(char *) "font", NULL
35952 };
35953
35954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
35955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35956 if (SWIG_arg_fail(1)) SWIG_fail;
35957 {
35958 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
35959 if (SWIG_arg_fail(2)) SWIG_fail;
35960 if (arg2 == NULL) {
35961 SWIG_null_ref("wxFont");
35962 }
35963 if (SWIG_arg_fail(2)) SWIG_fail;
35964 }
35965 {
35966 PyThreadState* __tstate = wxPyBeginAllowThreads();
35967 (arg1)->SetFont((wxFont const &)*arg2);
35968
35969 wxPyEndAllowThreads(__tstate);
35970 if (PyErr_Occurred()) SWIG_fail;
35971 }
35972 Py_INCREF(Py_None); resultobj = Py_None;
35973 return resultobj;
35974 fail:
35975 return NULL;
35976 }
35977
35978
35979 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
35980 PyObject *resultobj;
35981 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35982 wxFont result;
35983 PyObject * obj0 = 0 ;
35984 char *kwnames[] = {
35985 (char *) "self", NULL
35986 };
35987
35988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
35989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35990 if (SWIG_arg_fail(1)) SWIG_fail;
35991 {
35992 PyThreadState* __tstate = wxPyBeginAllowThreads();
35993 result = (arg1)->GetFont();
35994
35995 wxPyEndAllowThreads(__tstate);
35996 if (PyErr_Occurred()) SWIG_fail;
35997 }
35998 {
35999 wxFont * resultptr;
36000 resultptr = new wxFont((wxFont &)(result));
36001 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36002 }
36003 return resultobj;
36004 fail:
36005 return NULL;
36006 }
36007
36008
36009 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36010 PyObject *resultobj;
36011 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36012 wxColour *arg2 = 0 ;
36013 wxColour temp2 ;
36014 PyObject * obj0 = 0 ;
36015 PyObject * obj1 = 0 ;
36016 char *kwnames[] = {
36017 (char *) "self",(char *) "colText", NULL
36018 };
36019
36020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36022 if (SWIG_arg_fail(1)) SWIG_fail;
36023 {
36024 arg2 = &temp2;
36025 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36026 }
36027 {
36028 PyThreadState* __tstate = wxPyBeginAllowThreads();
36029 (arg1)->SetTextColour((wxColour const &)*arg2);
36030
36031 wxPyEndAllowThreads(__tstate);
36032 if (PyErr_Occurred()) SWIG_fail;
36033 }
36034 Py_INCREF(Py_None); resultobj = Py_None;
36035 return resultobj;
36036 fail:
36037 return NULL;
36038 }
36039
36040
36041 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36042 PyObject *resultobj;
36043 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36044 wxColour result;
36045 PyObject * obj0 = 0 ;
36046 char *kwnames[] = {
36047 (char *) "self", NULL
36048 };
36049
36050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36052 if (SWIG_arg_fail(1)) SWIG_fail;
36053 {
36054 PyThreadState* __tstate = wxPyBeginAllowThreads();
36055 result = (arg1)->GetTextColour();
36056
36057 wxPyEndAllowThreads(__tstate);
36058 if (PyErr_Occurred()) SWIG_fail;
36059 }
36060 {
36061 wxColour * resultptr;
36062 resultptr = new wxColour((wxColour &)(result));
36063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36064 }
36065 return resultobj;
36066 fail:
36067 return NULL;
36068 }
36069
36070
36071 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36072 PyObject *resultobj;
36073 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36074 wxColour *arg2 = 0 ;
36075 wxColour temp2 ;
36076 PyObject * obj0 = 0 ;
36077 PyObject * obj1 = 0 ;
36078 char *kwnames[] = {
36079 (char *) "self",(char *) "colBack", NULL
36080 };
36081
36082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36084 if (SWIG_arg_fail(1)) SWIG_fail;
36085 {
36086 arg2 = &temp2;
36087 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36088 }
36089 {
36090 PyThreadState* __tstate = wxPyBeginAllowThreads();
36091 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36092
36093 wxPyEndAllowThreads(__tstate);
36094 if (PyErr_Occurred()) SWIG_fail;
36095 }
36096 Py_INCREF(Py_None); resultobj = Py_None;
36097 return resultobj;
36098 fail:
36099 return NULL;
36100 }
36101
36102
36103 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36104 PyObject *resultobj;
36105 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36106 wxColour result;
36107 PyObject * obj0 = 0 ;
36108 char *kwnames[] = {
36109 (char *) "self", NULL
36110 };
36111
36112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36114 if (SWIG_arg_fail(1)) SWIG_fail;
36115 {
36116 PyThreadState* __tstate = wxPyBeginAllowThreads();
36117 result = (arg1)->GetBackgroundColour();
36118
36119 wxPyEndAllowThreads(__tstate);
36120 if (PyErr_Occurred()) SWIG_fail;
36121 }
36122 {
36123 wxColour * resultptr;
36124 resultptr = new wxColour((wxColour &)(result));
36125 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36126 }
36127 return resultobj;
36128 fail:
36129 return NULL;
36130 }
36131
36132
36133 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36134 PyObject *resultobj;
36135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36136 wxBitmap *arg2 = 0 ;
36137 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36138 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36139 PyObject * obj0 = 0 ;
36140 PyObject * obj1 = 0 ;
36141 PyObject * obj2 = 0 ;
36142 char *kwnames[] = {
36143 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36144 };
36145
36146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36148 if (SWIG_arg_fail(1)) SWIG_fail;
36149 {
36150 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36151 if (SWIG_arg_fail(2)) SWIG_fail;
36152 if (arg2 == NULL) {
36153 SWIG_null_ref("wxBitmap");
36154 }
36155 if (SWIG_arg_fail(2)) SWIG_fail;
36156 }
36157 if (obj2) {
36158 {
36159 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36160 if (SWIG_arg_fail(3)) SWIG_fail;
36161 if (arg3 == NULL) {
36162 SWIG_null_ref("wxBitmap");
36163 }
36164 if (SWIG_arg_fail(3)) SWIG_fail;
36165 }
36166 }
36167 {
36168 PyThreadState* __tstate = wxPyBeginAllowThreads();
36169 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36170
36171 wxPyEndAllowThreads(__tstate);
36172 if (PyErr_Occurred()) SWIG_fail;
36173 }
36174 Py_INCREF(Py_None); resultobj = Py_None;
36175 return resultobj;
36176 fail:
36177 return NULL;
36178 }
36179
36180
36181 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36182 PyObject *resultobj;
36183 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36184 wxBitmap *arg2 = 0 ;
36185 PyObject * obj0 = 0 ;
36186 PyObject * obj1 = 0 ;
36187 char *kwnames[] = {
36188 (char *) "self",(char *) "bmpDisabled", NULL
36189 };
36190
36191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36193 if (SWIG_arg_fail(1)) SWIG_fail;
36194 {
36195 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36196 if (SWIG_arg_fail(2)) SWIG_fail;
36197 if (arg2 == NULL) {
36198 SWIG_null_ref("wxBitmap");
36199 }
36200 if (SWIG_arg_fail(2)) SWIG_fail;
36201 }
36202 {
36203 PyThreadState* __tstate = wxPyBeginAllowThreads();
36204 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
36205
36206 wxPyEndAllowThreads(__tstate);
36207 if (PyErr_Occurred()) SWIG_fail;
36208 }
36209 Py_INCREF(Py_None); resultobj = Py_None;
36210 return resultobj;
36211 fail:
36212 return NULL;
36213 }
36214
36215
36216 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36217 PyObject *resultobj;
36218 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36219 wxBitmap *result;
36220 PyObject * obj0 = 0 ;
36221 char *kwnames[] = {
36222 (char *) "self", NULL
36223 };
36224
36225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36227 if (SWIG_arg_fail(1)) SWIG_fail;
36228 {
36229 PyThreadState* __tstate = wxPyBeginAllowThreads();
36230 {
36231 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
36232 result = (wxBitmap *) &_result_ref;
36233 }
36234
36235 wxPyEndAllowThreads(__tstate);
36236 if (PyErr_Occurred()) SWIG_fail;
36237 }
36238 {
36239 wxBitmap* resultptr = new wxBitmap(*result);
36240 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36241 }
36242 return resultobj;
36243 fail:
36244 return NULL;
36245 }
36246
36247
36248 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36249 PyObject *resultobj;
36250 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36251 int arg2 ;
36252 PyObject * obj0 = 0 ;
36253 PyObject * obj1 = 0 ;
36254 char *kwnames[] = {
36255 (char *) "self",(char *) "nWidth", NULL
36256 };
36257
36258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36260 if (SWIG_arg_fail(1)) SWIG_fail;
36261 {
36262 arg2 = (int)(SWIG_As_int(obj1));
36263 if (SWIG_arg_fail(2)) SWIG_fail;
36264 }
36265 {
36266 PyThreadState* __tstate = wxPyBeginAllowThreads();
36267 (arg1)->SetMarginWidth(arg2);
36268
36269 wxPyEndAllowThreads(__tstate);
36270 if (PyErr_Occurred()) SWIG_fail;
36271 }
36272 Py_INCREF(Py_None); resultobj = Py_None;
36273 return resultobj;
36274 fail:
36275 return NULL;
36276 }
36277
36278
36279 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36280 PyObject *resultobj;
36281 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36282 int result;
36283 PyObject * obj0 = 0 ;
36284 char *kwnames[] = {
36285 (char *) "self", NULL
36286 };
36287
36288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36290 if (SWIG_arg_fail(1)) SWIG_fail;
36291 {
36292 PyThreadState* __tstate = wxPyBeginAllowThreads();
36293 result = (int)(arg1)->GetMarginWidth();
36294
36295 wxPyEndAllowThreads(__tstate);
36296 if (PyErr_Occurred()) SWIG_fail;
36297 }
36298 {
36299 resultobj = SWIG_From_int((int)(result));
36300 }
36301 return resultobj;
36302 fail:
36303 return NULL;
36304 }
36305
36306
36307 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36308 PyObject *resultobj;
36309 int result;
36310 char *kwnames[] = {
36311 NULL
36312 };
36313
36314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36315 {
36316 PyThreadState* __tstate = wxPyBeginAllowThreads();
36317 result = (int)wxMenuItem::GetDefaultMarginWidth();
36318
36319 wxPyEndAllowThreads(__tstate);
36320 if (PyErr_Occurred()) SWIG_fail;
36321 }
36322 {
36323 resultobj = SWIG_From_int((int)(result));
36324 }
36325 return resultobj;
36326 fail:
36327 return NULL;
36328 }
36329
36330
36331 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36332 PyObject *resultobj;
36333 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36334 bool result;
36335 PyObject * obj0 = 0 ;
36336 char *kwnames[] = {
36337 (char *) "self", NULL
36338 };
36339
36340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36342 if (SWIG_arg_fail(1)) SWIG_fail;
36343 {
36344 PyThreadState* __tstate = wxPyBeginAllowThreads();
36345 result = (bool)(arg1)->IsOwnerDrawn();
36346
36347 wxPyEndAllowThreads(__tstate);
36348 if (PyErr_Occurred()) SWIG_fail;
36349 }
36350 {
36351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36352 }
36353 return resultobj;
36354 fail:
36355 return NULL;
36356 }
36357
36358
36359 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36360 PyObject *resultobj;
36361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36362 bool arg2 = (bool) true ;
36363 PyObject * obj0 = 0 ;
36364 PyObject * obj1 = 0 ;
36365 char *kwnames[] = {
36366 (char *) "self",(char *) "ownerDrawn", NULL
36367 };
36368
36369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36371 if (SWIG_arg_fail(1)) SWIG_fail;
36372 if (obj1) {
36373 {
36374 arg2 = (bool)(SWIG_As_bool(obj1));
36375 if (SWIG_arg_fail(2)) SWIG_fail;
36376 }
36377 }
36378 {
36379 PyThreadState* __tstate = wxPyBeginAllowThreads();
36380 (arg1)->SetOwnerDrawn(arg2);
36381
36382 wxPyEndAllowThreads(__tstate);
36383 if (PyErr_Occurred()) SWIG_fail;
36384 }
36385 Py_INCREF(Py_None); resultobj = Py_None;
36386 return resultobj;
36387 fail:
36388 return NULL;
36389 }
36390
36391
36392 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36393 PyObject *resultobj;
36394 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36395 PyObject * obj0 = 0 ;
36396 char *kwnames[] = {
36397 (char *) "self", NULL
36398 };
36399
36400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36402 if (SWIG_arg_fail(1)) SWIG_fail;
36403 {
36404 PyThreadState* __tstate = wxPyBeginAllowThreads();
36405 (arg1)->ResetOwnerDrawn();
36406
36407 wxPyEndAllowThreads(__tstate);
36408 if (PyErr_Occurred()) SWIG_fail;
36409 }
36410 Py_INCREF(Py_None); resultobj = Py_None;
36411 return resultobj;
36412 fail:
36413 return NULL;
36414 }
36415
36416
36417 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36418 PyObject *resultobj;
36419 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36420 wxBitmap *arg2 = 0 ;
36421 PyObject * obj0 = 0 ;
36422 PyObject * obj1 = 0 ;
36423 char *kwnames[] = {
36424 (char *) "self",(char *) "bitmap", NULL
36425 };
36426
36427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36429 if (SWIG_arg_fail(1)) SWIG_fail;
36430 {
36431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36432 if (SWIG_arg_fail(2)) SWIG_fail;
36433 if (arg2 == NULL) {
36434 SWIG_null_ref("wxBitmap");
36435 }
36436 if (SWIG_arg_fail(2)) SWIG_fail;
36437 }
36438 {
36439 PyThreadState* __tstate = wxPyBeginAllowThreads();
36440 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36441
36442 wxPyEndAllowThreads(__tstate);
36443 if (PyErr_Occurred()) SWIG_fail;
36444 }
36445 Py_INCREF(Py_None); resultobj = Py_None;
36446 return resultobj;
36447 fail:
36448 return NULL;
36449 }
36450
36451
36452 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36453 PyObject *resultobj;
36454 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36455 wxBitmap *result;
36456 PyObject * obj0 = 0 ;
36457 char *kwnames[] = {
36458 (char *) "self", NULL
36459 };
36460
36461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36463 if (SWIG_arg_fail(1)) SWIG_fail;
36464 {
36465 PyThreadState* __tstate = wxPyBeginAllowThreads();
36466 {
36467 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36468 result = (wxBitmap *) &_result_ref;
36469 }
36470
36471 wxPyEndAllowThreads(__tstate);
36472 if (PyErr_Occurred()) SWIG_fail;
36473 }
36474 {
36475 wxBitmap* resultptr = new wxBitmap(*result);
36476 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36477 }
36478 return resultobj;
36479 fail:
36480 return NULL;
36481 }
36482
36483
36484 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36485 PyObject *obj;
36486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36487 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36488 Py_INCREF(obj);
36489 return Py_BuildValue((char *)"");
36490 }
36491 static int _wrap_ControlNameStr_set(PyObject *) {
36492 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36493 return 1;
36494 }
36495
36496
36497 static PyObject *_wrap_ControlNameStr_get(void) {
36498 PyObject *pyobj;
36499
36500 {
36501 #if wxUSE_UNICODE
36502 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36503 #else
36504 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36505 #endif
36506 }
36507 return pyobj;
36508 }
36509
36510
36511 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36512 PyObject *resultobj;
36513 wxWindow *arg1 = (wxWindow *) 0 ;
36514 int arg2 = (int) -1 ;
36515 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36516 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36517 wxSize const &arg4_defvalue = wxDefaultSize ;
36518 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36519 long arg5 = (long) 0 ;
36520 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36521 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36522 wxString const &arg7_defvalue = wxPyControlNameStr ;
36523 wxString *arg7 = (wxString *) &arg7_defvalue ;
36524 wxControl *result;
36525 wxPoint temp3 ;
36526 wxSize temp4 ;
36527 bool temp7 = false ;
36528 PyObject * obj0 = 0 ;
36529 PyObject * obj1 = 0 ;
36530 PyObject * obj2 = 0 ;
36531 PyObject * obj3 = 0 ;
36532 PyObject * obj4 = 0 ;
36533 PyObject * obj5 = 0 ;
36534 PyObject * obj6 = 0 ;
36535 char *kwnames[] = {
36536 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36537 };
36538
36539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36541 if (SWIG_arg_fail(1)) SWIG_fail;
36542 if (obj1) {
36543 {
36544 arg2 = (int)(SWIG_As_int(obj1));
36545 if (SWIG_arg_fail(2)) SWIG_fail;
36546 }
36547 }
36548 if (obj2) {
36549 {
36550 arg3 = &temp3;
36551 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36552 }
36553 }
36554 if (obj3) {
36555 {
36556 arg4 = &temp4;
36557 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36558 }
36559 }
36560 if (obj4) {
36561 {
36562 arg5 = (long)(SWIG_As_long(obj4));
36563 if (SWIG_arg_fail(5)) SWIG_fail;
36564 }
36565 }
36566 if (obj5) {
36567 {
36568 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36569 if (SWIG_arg_fail(6)) SWIG_fail;
36570 if (arg6 == NULL) {
36571 SWIG_null_ref("wxValidator");
36572 }
36573 if (SWIG_arg_fail(6)) SWIG_fail;
36574 }
36575 }
36576 if (obj6) {
36577 {
36578 arg7 = wxString_in_helper(obj6);
36579 if (arg7 == NULL) SWIG_fail;
36580 temp7 = true;
36581 }
36582 }
36583 {
36584 if (!wxPyCheckForApp()) SWIG_fail;
36585 PyThreadState* __tstate = wxPyBeginAllowThreads();
36586 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36587
36588 wxPyEndAllowThreads(__tstate);
36589 if (PyErr_Occurred()) SWIG_fail;
36590 }
36591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36592 {
36593 if (temp7)
36594 delete arg7;
36595 }
36596 return resultobj;
36597 fail:
36598 {
36599 if (temp7)
36600 delete arg7;
36601 }
36602 return NULL;
36603 }
36604
36605
36606 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36607 PyObject *resultobj;
36608 wxControl *result;
36609 char *kwnames[] = {
36610 NULL
36611 };
36612
36613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36614 {
36615 if (!wxPyCheckForApp()) SWIG_fail;
36616 PyThreadState* __tstate = wxPyBeginAllowThreads();
36617 result = (wxControl *)new wxControl();
36618
36619 wxPyEndAllowThreads(__tstate);
36620 if (PyErr_Occurred()) SWIG_fail;
36621 }
36622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36623 return resultobj;
36624 fail:
36625 return NULL;
36626 }
36627
36628
36629 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36630 PyObject *resultobj;
36631 wxControl *arg1 = (wxControl *) 0 ;
36632 wxWindow *arg2 = (wxWindow *) 0 ;
36633 int arg3 = (int) -1 ;
36634 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36635 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36636 wxSize const &arg5_defvalue = wxDefaultSize ;
36637 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36638 long arg6 = (long) 0 ;
36639 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36640 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36641 wxString const &arg8_defvalue = wxPyControlNameStr ;
36642 wxString *arg8 = (wxString *) &arg8_defvalue ;
36643 bool result;
36644 wxPoint temp4 ;
36645 wxSize temp5 ;
36646 bool temp8 = false ;
36647 PyObject * obj0 = 0 ;
36648 PyObject * obj1 = 0 ;
36649 PyObject * obj2 = 0 ;
36650 PyObject * obj3 = 0 ;
36651 PyObject * obj4 = 0 ;
36652 PyObject * obj5 = 0 ;
36653 PyObject * obj6 = 0 ;
36654 PyObject * obj7 = 0 ;
36655 char *kwnames[] = {
36656 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36657 };
36658
36659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36661 if (SWIG_arg_fail(1)) SWIG_fail;
36662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36663 if (SWIG_arg_fail(2)) SWIG_fail;
36664 if (obj2) {
36665 {
36666 arg3 = (int)(SWIG_As_int(obj2));
36667 if (SWIG_arg_fail(3)) SWIG_fail;
36668 }
36669 }
36670 if (obj3) {
36671 {
36672 arg4 = &temp4;
36673 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36674 }
36675 }
36676 if (obj4) {
36677 {
36678 arg5 = &temp5;
36679 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36680 }
36681 }
36682 if (obj5) {
36683 {
36684 arg6 = (long)(SWIG_As_long(obj5));
36685 if (SWIG_arg_fail(6)) SWIG_fail;
36686 }
36687 }
36688 if (obj6) {
36689 {
36690 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36691 if (SWIG_arg_fail(7)) SWIG_fail;
36692 if (arg7 == NULL) {
36693 SWIG_null_ref("wxValidator");
36694 }
36695 if (SWIG_arg_fail(7)) SWIG_fail;
36696 }
36697 }
36698 if (obj7) {
36699 {
36700 arg8 = wxString_in_helper(obj7);
36701 if (arg8 == NULL) SWIG_fail;
36702 temp8 = true;
36703 }
36704 }
36705 {
36706 PyThreadState* __tstate = wxPyBeginAllowThreads();
36707 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36708
36709 wxPyEndAllowThreads(__tstate);
36710 if (PyErr_Occurred()) SWIG_fail;
36711 }
36712 {
36713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36714 }
36715 {
36716 if (temp8)
36717 delete arg8;
36718 }
36719 return resultobj;
36720 fail:
36721 {
36722 if (temp8)
36723 delete arg8;
36724 }
36725 return NULL;
36726 }
36727
36728
36729 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36730 PyObject *resultobj;
36731 wxControl *arg1 = (wxControl *) 0 ;
36732 wxCommandEvent *arg2 = 0 ;
36733 PyObject * obj0 = 0 ;
36734 PyObject * obj1 = 0 ;
36735 char *kwnames[] = {
36736 (char *) "self",(char *) "event", NULL
36737 };
36738
36739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36741 if (SWIG_arg_fail(1)) SWIG_fail;
36742 {
36743 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
36744 if (SWIG_arg_fail(2)) SWIG_fail;
36745 if (arg2 == NULL) {
36746 SWIG_null_ref("wxCommandEvent");
36747 }
36748 if (SWIG_arg_fail(2)) SWIG_fail;
36749 }
36750 {
36751 PyThreadState* __tstate = wxPyBeginAllowThreads();
36752 (arg1)->Command(*arg2);
36753
36754 wxPyEndAllowThreads(__tstate);
36755 if (PyErr_Occurred()) SWIG_fail;
36756 }
36757 Py_INCREF(Py_None); resultobj = Py_None;
36758 return resultobj;
36759 fail:
36760 return NULL;
36761 }
36762
36763
36764 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36765 PyObject *resultobj;
36766 wxControl *arg1 = (wxControl *) 0 ;
36767 wxString result;
36768 PyObject * obj0 = 0 ;
36769 char *kwnames[] = {
36770 (char *) "self", NULL
36771 };
36772
36773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
36774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36775 if (SWIG_arg_fail(1)) SWIG_fail;
36776 {
36777 PyThreadState* __tstate = wxPyBeginAllowThreads();
36778 result = (arg1)->GetLabel();
36779
36780 wxPyEndAllowThreads(__tstate);
36781 if (PyErr_Occurred()) SWIG_fail;
36782 }
36783 {
36784 #if wxUSE_UNICODE
36785 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36786 #else
36787 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36788 #endif
36789 }
36790 return resultobj;
36791 fail:
36792 return NULL;
36793 }
36794
36795
36796 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36797 PyObject *resultobj;
36798 wxControl *arg1 = (wxControl *) 0 ;
36799 wxString *arg2 = 0 ;
36800 bool temp2 = false ;
36801 PyObject * obj0 = 0 ;
36802 PyObject * obj1 = 0 ;
36803 char *kwnames[] = {
36804 (char *) "self",(char *) "label", NULL
36805 };
36806
36807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
36808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36809 if (SWIG_arg_fail(1)) SWIG_fail;
36810 {
36811 arg2 = wxString_in_helper(obj1);
36812 if (arg2 == NULL) SWIG_fail;
36813 temp2 = true;
36814 }
36815 {
36816 PyThreadState* __tstate = wxPyBeginAllowThreads();
36817 (arg1)->SetLabel((wxString const &)*arg2);
36818
36819 wxPyEndAllowThreads(__tstate);
36820 if (PyErr_Occurred()) SWIG_fail;
36821 }
36822 Py_INCREF(Py_None); resultobj = Py_None;
36823 {
36824 if (temp2)
36825 delete arg2;
36826 }
36827 return resultobj;
36828 fail:
36829 {
36830 if (temp2)
36831 delete arg2;
36832 }
36833 return NULL;
36834 }
36835
36836
36837 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
36838 PyObject *resultobj;
36839 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36840 wxVisualAttributes result;
36841 PyObject * obj0 = 0 ;
36842 char *kwnames[] = {
36843 (char *) "variant", NULL
36844 };
36845
36846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
36847 if (obj0) {
36848 {
36849 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
36850 if (SWIG_arg_fail(1)) SWIG_fail;
36851 }
36852 }
36853 {
36854 if (!wxPyCheckForApp()) SWIG_fail;
36855 PyThreadState* __tstate = wxPyBeginAllowThreads();
36856 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
36857
36858 wxPyEndAllowThreads(__tstate);
36859 if (PyErr_Occurred()) SWIG_fail;
36860 }
36861 {
36862 wxVisualAttributes * resultptr;
36863 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
36864 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
36865 }
36866 return resultobj;
36867 fail:
36868 return NULL;
36869 }
36870
36871
36872 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
36873 PyObject *obj;
36874 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36875 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
36876 Py_INCREF(obj);
36877 return Py_BuildValue((char *)"");
36878 }
36879 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
36880 PyObject *resultobj;
36881 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36882 wxString *arg2 = 0 ;
36883 PyObject *arg3 = (PyObject *) NULL ;
36884 int result;
36885 bool temp2 = false ;
36886 PyObject * obj0 = 0 ;
36887 PyObject * obj1 = 0 ;
36888 PyObject * obj2 = 0 ;
36889 char *kwnames[] = {
36890 (char *) "self",(char *) "item",(char *) "clientData", NULL
36891 };
36892
36893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
36894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36895 if (SWIG_arg_fail(1)) SWIG_fail;
36896 {
36897 arg2 = wxString_in_helper(obj1);
36898 if (arg2 == NULL) SWIG_fail;
36899 temp2 = true;
36900 }
36901 if (obj2) {
36902 arg3 = obj2;
36903 }
36904 {
36905 PyThreadState* __tstate = wxPyBeginAllowThreads();
36906 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
36907
36908 wxPyEndAllowThreads(__tstate);
36909 if (PyErr_Occurred()) SWIG_fail;
36910 }
36911 {
36912 resultobj = SWIG_From_int((int)(result));
36913 }
36914 {
36915 if (temp2)
36916 delete arg2;
36917 }
36918 return resultobj;
36919 fail:
36920 {
36921 if (temp2)
36922 delete arg2;
36923 }
36924 return NULL;
36925 }
36926
36927
36928 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
36929 PyObject *resultobj;
36930 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36931 wxArrayString *arg2 = 0 ;
36932 bool temp2 = false ;
36933 PyObject * obj0 = 0 ;
36934 PyObject * obj1 = 0 ;
36935 char *kwnames[] = {
36936 (char *) "self",(char *) "strings", NULL
36937 };
36938
36939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
36940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36941 if (SWIG_arg_fail(1)) SWIG_fail;
36942 {
36943 if (! PySequence_Check(obj1)) {
36944 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
36945 SWIG_fail;
36946 }
36947 arg2 = new wxArrayString;
36948 temp2 = true;
36949 int i, len=PySequence_Length(obj1);
36950 for (i=0; i<len; i++) {
36951 PyObject* item = PySequence_GetItem(obj1, i);
36952 #if wxUSE_UNICODE
36953 PyObject* str = PyObject_Unicode(item);
36954 #else
36955 PyObject* str = PyObject_Str(item);
36956 #endif
36957 if (PyErr_Occurred()) SWIG_fail;
36958 arg2->Add(Py2wxString(str));
36959 Py_DECREF(item);
36960 Py_DECREF(str);
36961 }
36962 }
36963 {
36964 PyThreadState* __tstate = wxPyBeginAllowThreads();
36965 (arg1)->Append((wxArrayString const &)*arg2);
36966
36967 wxPyEndAllowThreads(__tstate);
36968 if (PyErr_Occurred()) SWIG_fail;
36969 }
36970 Py_INCREF(Py_None); resultobj = Py_None;
36971 {
36972 if (temp2) delete arg2;
36973 }
36974 return resultobj;
36975 fail:
36976 {
36977 if (temp2) delete arg2;
36978 }
36979 return NULL;
36980 }
36981
36982
36983 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
36984 PyObject *resultobj;
36985 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36986 wxString *arg2 = 0 ;
36987 int arg3 ;
36988 PyObject *arg4 = (PyObject *) NULL ;
36989 int result;
36990 bool temp2 = false ;
36991 PyObject * obj0 = 0 ;
36992 PyObject * obj1 = 0 ;
36993 PyObject * obj2 = 0 ;
36994 PyObject * obj3 = 0 ;
36995 char *kwnames[] = {
36996 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
36997 };
36998
36999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37001 if (SWIG_arg_fail(1)) SWIG_fail;
37002 {
37003 arg2 = wxString_in_helper(obj1);
37004 if (arg2 == NULL) SWIG_fail;
37005 temp2 = true;
37006 }
37007 {
37008 arg3 = (int)(SWIG_As_int(obj2));
37009 if (SWIG_arg_fail(3)) SWIG_fail;
37010 }
37011 if (obj3) {
37012 arg4 = obj3;
37013 }
37014 {
37015 PyThreadState* __tstate = wxPyBeginAllowThreads();
37016 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37017
37018 wxPyEndAllowThreads(__tstate);
37019 if (PyErr_Occurred()) SWIG_fail;
37020 }
37021 {
37022 resultobj = SWIG_From_int((int)(result));
37023 }
37024 {
37025 if (temp2)
37026 delete arg2;
37027 }
37028 return resultobj;
37029 fail:
37030 {
37031 if (temp2)
37032 delete arg2;
37033 }
37034 return NULL;
37035 }
37036
37037
37038 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37039 PyObject *resultobj;
37040 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37041 PyObject * obj0 = 0 ;
37042 char *kwnames[] = {
37043 (char *) "self", NULL
37044 };
37045
37046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37048 if (SWIG_arg_fail(1)) SWIG_fail;
37049 {
37050 PyThreadState* __tstate = wxPyBeginAllowThreads();
37051 (arg1)->Clear();
37052
37053 wxPyEndAllowThreads(__tstate);
37054 if (PyErr_Occurred()) SWIG_fail;
37055 }
37056 Py_INCREF(Py_None); resultobj = Py_None;
37057 return resultobj;
37058 fail:
37059 return NULL;
37060 }
37061
37062
37063 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37064 PyObject *resultobj;
37065 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37066 int arg2 ;
37067 PyObject * obj0 = 0 ;
37068 PyObject * obj1 = 0 ;
37069 char *kwnames[] = {
37070 (char *) "self",(char *) "n", NULL
37071 };
37072
37073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37075 if (SWIG_arg_fail(1)) SWIG_fail;
37076 {
37077 arg2 = (int)(SWIG_As_int(obj1));
37078 if (SWIG_arg_fail(2)) SWIG_fail;
37079 }
37080 {
37081 PyThreadState* __tstate = wxPyBeginAllowThreads();
37082 (arg1)->Delete(arg2);
37083
37084 wxPyEndAllowThreads(__tstate);
37085 if (PyErr_Occurred()) SWIG_fail;
37086 }
37087 Py_INCREF(Py_None); resultobj = Py_None;
37088 return resultobj;
37089 fail:
37090 return NULL;
37091 }
37092
37093
37094 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37095 PyObject *resultobj;
37096 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37097 int result;
37098 PyObject * obj0 = 0 ;
37099 char *kwnames[] = {
37100 (char *) "self", NULL
37101 };
37102
37103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37105 if (SWIG_arg_fail(1)) SWIG_fail;
37106 {
37107 PyThreadState* __tstate = wxPyBeginAllowThreads();
37108 result = (int)((wxItemContainer const *)arg1)->GetCount();
37109
37110 wxPyEndAllowThreads(__tstate);
37111 if (PyErr_Occurred()) SWIG_fail;
37112 }
37113 {
37114 resultobj = SWIG_From_int((int)(result));
37115 }
37116 return resultobj;
37117 fail:
37118 return NULL;
37119 }
37120
37121
37122 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37123 PyObject *resultobj;
37124 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37125 bool result;
37126 PyObject * obj0 = 0 ;
37127 char *kwnames[] = {
37128 (char *) "self", NULL
37129 };
37130
37131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37133 if (SWIG_arg_fail(1)) SWIG_fail;
37134 {
37135 PyThreadState* __tstate = wxPyBeginAllowThreads();
37136 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37137
37138 wxPyEndAllowThreads(__tstate);
37139 if (PyErr_Occurred()) SWIG_fail;
37140 }
37141 {
37142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37143 }
37144 return resultobj;
37145 fail:
37146 return NULL;
37147 }
37148
37149
37150 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37151 PyObject *resultobj;
37152 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37153 int arg2 ;
37154 wxString result;
37155 PyObject * obj0 = 0 ;
37156 PyObject * obj1 = 0 ;
37157 char *kwnames[] = {
37158 (char *) "self",(char *) "n", NULL
37159 };
37160
37161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37163 if (SWIG_arg_fail(1)) SWIG_fail;
37164 {
37165 arg2 = (int)(SWIG_As_int(obj1));
37166 if (SWIG_arg_fail(2)) SWIG_fail;
37167 }
37168 {
37169 PyThreadState* __tstate = wxPyBeginAllowThreads();
37170 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37171
37172 wxPyEndAllowThreads(__tstate);
37173 if (PyErr_Occurred()) SWIG_fail;
37174 }
37175 {
37176 #if wxUSE_UNICODE
37177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37178 #else
37179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37180 #endif
37181 }
37182 return resultobj;
37183 fail:
37184 return NULL;
37185 }
37186
37187
37188 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37189 PyObject *resultobj;
37190 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37191 wxArrayString result;
37192 PyObject * obj0 = 0 ;
37193 char *kwnames[] = {
37194 (char *) "self", NULL
37195 };
37196
37197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37199 if (SWIG_arg_fail(1)) SWIG_fail;
37200 {
37201 PyThreadState* __tstate = wxPyBeginAllowThreads();
37202 result = ((wxItemContainer const *)arg1)->GetStrings();
37203
37204 wxPyEndAllowThreads(__tstate);
37205 if (PyErr_Occurred()) SWIG_fail;
37206 }
37207 {
37208 resultobj = wxArrayString2PyList_helper(result);
37209 }
37210 return resultobj;
37211 fail:
37212 return NULL;
37213 }
37214
37215
37216 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37217 PyObject *resultobj;
37218 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37219 int arg2 ;
37220 wxString *arg3 = 0 ;
37221 bool temp3 = false ;
37222 PyObject * obj0 = 0 ;
37223 PyObject * obj1 = 0 ;
37224 PyObject * obj2 = 0 ;
37225 char *kwnames[] = {
37226 (char *) "self",(char *) "n",(char *) "s", NULL
37227 };
37228
37229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37231 if (SWIG_arg_fail(1)) SWIG_fail;
37232 {
37233 arg2 = (int)(SWIG_As_int(obj1));
37234 if (SWIG_arg_fail(2)) SWIG_fail;
37235 }
37236 {
37237 arg3 = wxString_in_helper(obj2);
37238 if (arg3 == NULL) SWIG_fail;
37239 temp3 = true;
37240 }
37241 {
37242 PyThreadState* __tstate = wxPyBeginAllowThreads();
37243 (arg1)->SetString(arg2,(wxString const &)*arg3);
37244
37245 wxPyEndAllowThreads(__tstate);
37246 if (PyErr_Occurred()) SWIG_fail;
37247 }
37248 Py_INCREF(Py_None); resultobj = Py_None;
37249 {
37250 if (temp3)
37251 delete arg3;
37252 }
37253 return resultobj;
37254 fail:
37255 {
37256 if (temp3)
37257 delete arg3;
37258 }
37259 return NULL;
37260 }
37261
37262
37263 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37264 PyObject *resultobj;
37265 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37266 wxString *arg2 = 0 ;
37267 int result;
37268 bool temp2 = false ;
37269 PyObject * obj0 = 0 ;
37270 PyObject * obj1 = 0 ;
37271 char *kwnames[] = {
37272 (char *) "self",(char *) "s", NULL
37273 };
37274
37275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37277 if (SWIG_arg_fail(1)) SWIG_fail;
37278 {
37279 arg2 = wxString_in_helper(obj1);
37280 if (arg2 == NULL) SWIG_fail;
37281 temp2 = true;
37282 }
37283 {
37284 PyThreadState* __tstate = wxPyBeginAllowThreads();
37285 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37286
37287 wxPyEndAllowThreads(__tstate);
37288 if (PyErr_Occurred()) SWIG_fail;
37289 }
37290 {
37291 resultobj = SWIG_From_int((int)(result));
37292 }
37293 {
37294 if (temp2)
37295 delete arg2;
37296 }
37297 return resultobj;
37298 fail:
37299 {
37300 if (temp2)
37301 delete arg2;
37302 }
37303 return NULL;
37304 }
37305
37306
37307 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37308 PyObject *resultobj;
37309 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37310 int arg2 ;
37311 PyObject * obj0 = 0 ;
37312 PyObject * obj1 = 0 ;
37313 char *kwnames[] = {
37314 (char *) "self",(char *) "n", NULL
37315 };
37316
37317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37319 if (SWIG_arg_fail(1)) SWIG_fail;
37320 {
37321 arg2 = (int)(SWIG_As_int(obj1));
37322 if (SWIG_arg_fail(2)) SWIG_fail;
37323 }
37324 {
37325 PyThreadState* __tstate = wxPyBeginAllowThreads();
37326 (arg1)->Select(arg2);
37327
37328 wxPyEndAllowThreads(__tstate);
37329 if (PyErr_Occurred()) SWIG_fail;
37330 }
37331 Py_INCREF(Py_None); resultobj = Py_None;
37332 return resultobj;
37333 fail:
37334 return NULL;
37335 }
37336
37337
37338 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37339 PyObject *resultobj;
37340 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37341 int result;
37342 PyObject * obj0 = 0 ;
37343 char *kwnames[] = {
37344 (char *) "self", NULL
37345 };
37346
37347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37349 if (SWIG_arg_fail(1)) SWIG_fail;
37350 {
37351 PyThreadState* __tstate = wxPyBeginAllowThreads();
37352 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37353
37354 wxPyEndAllowThreads(__tstate);
37355 if (PyErr_Occurred()) SWIG_fail;
37356 }
37357 {
37358 resultobj = SWIG_From_int((int)(result));
37359 }
37360 return resultobj;
37361 fail:
37362 return NULL;
37363 }
37364
37365
37366 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37367 PyObject *resultobj;
37368 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37369 wxString result;
37370 PyObject * obj0 = 0 ;
37371 char *kwnames[] = {
37372 (char *) "self", NULL
37373 };
37374
37375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37377 if (SWIG_arg_fail(1)) SWIG_fail;
37378 {
37379 PyThreadState* __tstate = wxPyBeginAllowThreads();
37380 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37381
37382 wxPyEndAllowThreads(__tstate);
37383 if (PyErr_Occurred()) SWIG_fail;
37384 }
37385 {
37386 #if wxUSE_UNICODE
37387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37388 #else
37389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37390 #endif
37391 }
37392 return resultobj;
37393 fail:
37394 return NULL;
37395 }
37396
37397
37398 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37399 PyObject *resultobj;
37400 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37401 int arg2 ;
37402 PyObject *result;
37403 PyObject * obj0 = 0 ;
37404 PyObject * obj1 = 0 ;
37405 char *kwnames[] = {
37406 (char *) "self",(char *) "n", NULL
37407 };
37408
37409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37411 if (SWIG_arg_fail(1)) SWIG_fail;
37412 {
37413 arg2 = (int)(SWIG_As_int(obj1));
37414 if (SWIG_arg_fail(2)) SWIG_fail;
37415 }
37416 {
37417 PyThreadState* __tstate = wxPyBeginAllowThreads();
37418 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37419
37420 wxPyEndAllowThreads(__tstate);
37421 if (PyErr_Occurred()) SWIG_fail;
37422 }
37423 resultobj = result;
37424 return resultobj;
37425 fail:
37426 return NULL;
37427 }
37428
37429
37430 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37431 PyObject *resultobj;
37432 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37433 int arg2 ;
37434 PyObject *arg3 = (PyObject *) 0 ;
37435 PyObject * obj0 = 0 ;
37436 PyObject * obj1 = 0 ;
37437 PyObject * obj2 = 0 ;
37438 char *kwnames[] = {
37439 (char *) "self",(char *) "n",(char *) "clientData", NULL
37440 };
37441
37442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37444 if (SWIG_arg_fail(1)) SWIG_fail;
37445 {
37446 arg2 = (int)(SWIG_As_int(obj1));
37447 if (SWIG_arg_fail(2)) SWIG_fail;
37448 }
37449 arg3 = obj2;
37450 {
37451 PyThreadState* __tstate = wxPyBeginAllowThreads();
37452 wxItemContainer_SetClientData(arg1,arg2,arg3);
37453
37454 wxPyEndAllowThreads(__tstate);
37455 if (PyErr_Occurred()) SWIG_fail;
37456 }
37457 Py_INCREF(Py_None); resultobj = Py_None;
37458 return resultobj;
37459 fail:
37460 return NULL;
37461 }
37462
37463
37464 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37465 PyObject *obj;
37466 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37467 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37468 Py_INCREF(obj);
37469 return Py_BuildValue((char *)"");
37470 }
37471 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37472 PyObject *obj;
37473 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37474 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37475 Py_INCREF(obj);
37476 return Py_BuildValue((char *)"");
37477 }
37478 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37479 PyObject *resultobj;
37480 wxSizerItem *result;
37481 char *kwnames[] = {
37482 NULL
37483 };
37484
37485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37486 {
37487 PyThreadState* __tstate = wxPyBeginAllowThreads();
37488 result = (wxSizerItem *)new wxSizerItem();
37489
37490 wxPyEndAllowThreads(__tstate);
37491 if (PyErr_Occurred()) SWIG_fail;
37492 }
37493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37494 return resultobj;
37495 fail:
37496 return NULL;
37497 }
37498
37499
37500 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37501 PyObject *resultobj;
37502 wxWindow *arg1 = (wxWindow *) 0 ;
37503 int arg2 ;
37504 int arg3 ;
37505 int arg4 ;
37506 PyObject *arg5 = (PyObject *) NULL ;
37507 wxSizerItem *result;
37508 PyObject * obj0 = 0 ;
37509 PyObject * obj1 = 0 ;
37510 PyObject * obj2 = 0 ;
37511 PyObject * obj3 = 0 ;
37512 PyObject * obj4 = 0 ;
37513 char *kwnames[] = {
37514 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37515 };
37516
37517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37519 if (SWIG_arg_fail(1)) SWIG_fail;
37520 {
37521 arg2 = (int)(SWIG_As_int(obj1));
37522 if (SWIG_arg_fail(2)) SWIG_fail;
37523 }
37524 {
37525 arg3 = (int)(SWIG_As_int(obj2));
37526 if (SWIG_arg_fail(3)) SWIG_fail;
37527 }
37528 {
37529 arg4 = (int)(SWIG_As_int(obj3));
37530 if (SWIG_arg_fail(4)) SWIG_fail;
37531 }
37532 if (obj4) {
37533 arg5 = obj4;
37534 }
37535 {
37536 PyThreadState* __tstate = wxPyBeginAllowThreads();
37537 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37538
37539 wxPyEndAllowThreads(__tstate);
37540 if (PyErr_Occurred()) SWIG_fail;
37541 }
37542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37543 return resultobj;
37544 fail:
37545 return NULL;
37546 }
37547
37548
37549 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37550 PyObject *resultobj;
37551 int arg1 ;
37552 int arg2 ;
37553 int arg3 ;
37554 int arg4 ;
37555 int arg5 ;
37556 PyObject *arg6 = (PyObject *) NULL ;
37557 wxSizerItem *result;
37558 PyObject * obj0 = 0 ;
37559 PyObject * obj1 = 0 ;
37560 PyObject * obj2 = 0 ;
37561 PyObject * obj3 = 0 ;
37562 PyObject * obj4 = 0 ;
37563 PyObject * obj5 = 0 ;
37564 char *kwnames[] = {
37565 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37566 };
37567
37568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37569 {
37570 arg1 = (int)(SWIG_As_int(obj0));
37571 if (SWIG_arg_fail(1)) SWIG_fail;
37572 }
37573 {
37574 arg2 = (int)(SWIG_As_int(obj1));
37575 if (SWIG_arg_fail(2)) SWIG_fail;
37576 }
37577 {
37578 arg3 = (int)(SWIG_As_int(obj2));
37579 if (SWIG_arg_fail(3)) SWIG_fail;
37580 }
37581 {
37582 arg4 = (int)(SWIG_As_int(obj3));
37583 if (SWIG_arg_fail(4)) SWIG_fail;
37584 }
37585 {
37586 arg5 = (int)(SWIG_As_int(obj4));
37587 if (SWIG_arg_fail(5)) SWIG_fail;
37588 }
37589 if (obj5) {
37590 arg6 = obj5;
37591 }
37592 {
37593 PyThreadState* __tstate = wxPyBeginAllowThreads();
37594 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37595
37596 wxPyEndAllowThreads(__tstate);
37597 if (PyErr_Occurred()) SWIG_fail;
37598 }
37599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37600 return resultobj;
37601 fail:
37602 return NULL;
37603 }
37604
37605
37606 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37607 PyObject *resultobj;
37608 wxSizer *arg1 = (wxSizer *) 0 ;
37609 int arg2 ;
37610 int arg3 ;
37611 int arg4 ;
37612 PyObject *arg5 = (PyObject *) NULL ;
37613 wxSizerItem *result;
37614 PyObject * obj0 = 0 ;
37615 PyObject * obj1 = 0 ;
37616 PyObject * obj2 = 0 ;
37617 PyObject * obj3 = 0 ;
37618 PyObject * obj4 = 0 ;
37619 char *kwnames[] = {
37620 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37621 };
37622
37623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37625 if (SWIG_arg_fail(1)) SWIG_fail;
37626 {
37627 arg2 = (int)(SWIG_As_int(obj1));
37628 if (SWIG_arg_fail(2)) SWIG_fail;
37629 }
37630 {
37631 arg3 = (int)(SWIG_As_int(obj2));
37632 if (SWIG_arg_fail(3)) SWIG_fail;
37633 }
37634 {
37635 arg4 = (int)(SWIG_As_int(obj3));
37636 if (SWIG_arg_fail(4)) SWIG_fail;
37637 }
37638 if (obj4) {
37639 arg5 = obj4;
37640 }
37641 {
37642 PyThreadState* __tstate = wxPyBeginAllowThreads();
37643 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37644
37645 wxPyEndAllowThreads(__tstate);
37646 if (PyErr_Occurred()) SWIG_fail;
37647 }
37648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37649 return resultobj;
37650 fail:
37651 return NULL;
37652 }
37653
37654
37655 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37656 PyObject *resultobj;
37657 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37658 PyObject * obj0 = 0 ;
37659 char *kwnames[] = {
37660 (char *) "self", NULL
37661 };
37662
37663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37665 if (SWIG_arg_fail(1)) SWIG_fail;
37666 {
37667 PyThreadState* __tstate = wxPyBeginAllowThreads();
37668 (arg1)->DeleteWindows();
37669
37670 wxPyEndAllowThreads(__tstate);
37671 if (PyErr_Occurred()) SWIG_fail;
37672 }
37673 Py_INCREF(Py_None); resultobj = Py_None;
37674 return resultobj;
37675 fail:
37676 return NULL;
37677 }
37678
37679
37680 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37681 PyObject *resultobj;
37682 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37683 PyObject * obj0 = 0 ;
37684 char *kwnames[] = {
37685 (char *) "self", NULL
37686 };
37687
37688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
37689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37690 if (SWIG_arg_fail(1)) SWIG_fail;
37691 {
37692 PyThreadState* __tstate = wxPyBeginAllowThreads();
37693 (arg1)->DetachSizer();
37694
37695 wxPyEndAllowThreads(__tstate);
37696 if (PyErr_Occurred()) SWIG_fail;
37697 }
37698 Py_INCREF(Py_None); resultobj = Py_None;
37699 return resultobj;
37700 fail:
37701 return NULL;
37702 }
37703
37704
37705 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
37706 PyObject *resultobj;
37707 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37708 wxSize result;
37709 PyObject * obj0 = 0 ;
37710 char *kwnames[] = {
37711 (char *) "self", NULL
37712 };
37713
37714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
37719 result = (arg1)->GetSize();
37720
37721 wxPyEndAllowThreads(__tstate);
37722 if (PyErr_Occurred()) SWIG_fail;
37723 }
37724 {
37725 wxSize * resultptr;
37726 resultptr = new wxSize((wxSize &)(result));
37727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37728 }
37729 return resultobj;
37730 fail:
37731 return NULL;
37732 }
37733
37734
37735 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
37736 PyObject *resultobj;
37737 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37738 wxSize result;
37739 PyObject * obj0 = 0 ;
37740 char *kwnames[] = {
37741 (char *) "self", NULL
37742 };
37743
37744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",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 = (arg1)->CalcMin();
37750
37751 wxPyEndAllowThreads(__tstate);
37752 if (PyErr_Occurred()) SWIG_fail;
37753 }
37754 {
37755 wxSize * resultptr;
37756 resultptr = new wxSize((wxSize &)(result));
37757 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37758 }
37759 return resultobj;
37760 fail:
37761 return NULL;
37762 }
37763
37764
37765 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
37766 PyObject *resultobj;
37767 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37768 wxPoint arg2 ;
37769 wxSize arg3 ;
37770 PyObject * obj0 = 0 ;
37771 PyObject * obj1 = 0 ;
37772 PyObject * obj2 = 0 ;
37773 char *kwnames[] = {
37774 (char *) "self",(char *) "pos",(char *) "size", NULL
37775 };
37776
37777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
37778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37779 if (SWIG_arg_fail(1)) SWIG_fail;
37780 {
37781 wxPoint * argp;
37782 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
37783 if (SWIG_arg_fail(2)) SWIG_fail;
37784 if (argp == NULL) {
37785 SWIG_null_ref("wxPoint");
37786 }
37787 if (SWIG_arg_fail(2)) SWIG_fail;
37788 arg2 = *argp;
37789 }
37790 {
37791 wxSize * argp;
37792 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37793 if (SWIG_arg_fail(3)) SWIG_fail;
37794 if (argp == NULL) {
37795 SWIG_null_ref("wxSize");
37796 }
37797 if (SWIG_arg_fail(3)) SWIG_fail;
37798 arg3 = *argp;
37799 }
37800 {
37801 PyThreadState* __tstate = wxPyBeginAllowThreads();
37802 (arg1)->SetDimension(arg2,arg3);
37803
37804 wxPyEndAllowThreads(__tstate);
37805 if (PyErr_Occurred()) SWIG_fail;
37806 }
37807 Py_INCREF(Py_None); resultobj = Py_None;
37808 return resultobj;
37809 fail:
37810 return NULL;
37811 }
37812
37813
37814 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
37815 PyObject *resultobj;
37816 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37817 wxSize result;
37818 PyObject * obj0 = 0 ;
37819 char *kwnames[] = {
37820 (char *) "self", NULL
37821 };
37822
37823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
37824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37825 if (SWIG_arg_fail(1)) SWIG_fail;
37826 {
37827 PyThreadState* __tstate = wxPyBeginAllowThreads();
37828 result = (arg1)->GetMinSize();
37829
37830 wxPyEndAllowThreads(__tstate);
37831 if (PyErr_Occurred()) SWIG_fail;
37832 }
37833 {
37834 wxSize * resultptr;
37835 resultptr = new wxSize((wxSize &)(result));
37836 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37837 }
37838 return resultobj;
37839 fail:
37840 return NULL;
37841 }
37842
37843
37844 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37845 PyObject *resultobj;
37846 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37847 wxSize result;
37848 PyObject * obj0 = 0 ;
37849 char *kwnames[] = {
37850 (char *) "self", NULL
37851 };
37852
37853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
37854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37855 if (SWIG_arg_fail(1)) SWIG_fail;
37856 {
37857 PyThreadState* __tstate = wxPyBeginAllowThreads();
37858 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
37859
37860 wxPyEndAllowThreads(__tstate);
37861 if (PyErr_Occurred()) SWIG_fail;
37862 }
37863 {
37864 wxSize * resultptr;
37865 resultptr = new wxSize((wxSize &)(result));
37866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37867 }
37868 return resultobj;
37869 fail:
37870 return NULL;
37871 }
37872
37873
37874 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
37875 PyObject *resultobj;
37876 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37877 int arg2 ;
37878 int arg3 ;
37879 PyObject * obj0 = 0 ;
37880 PyObject * obj1 = 0 ;
37881 PyObject * obj2 = 0 ;
37882 char *kwnames[] = {
37883 (char *) "self",(char *) "x",(char *) "y", NULL
37884 };
37885
37886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
37887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37888 if (SWIG_arg_fail(1)) SWIG_fail;
37889 {
37890 arg2 = (int)(SWIG_As_int(obj1));
37891 if (SWIG_arg_fail(2)) SWIG_fail;
37892 }
37893 {
37894 arg3 = (int)(SWIG_As_int(obj2));
37895 if (SWIG_arg_fail(3)) SWIG_fail;
37896 }
37897 {
37898 PyThreadState* __tstate = wxPyBeginAllowThreads();
37899 (arg1)->SetInitSize(arg2,arg3);
37900
37901 wxPyEndAllowThreads(__tstate);
37902 if (PyErr_Occurred()) SWIG_fail;
37903 }
37904 Py_INCREF(Py_None); resultobj = Py_None;
37905 return resultobj;
37906 fail:
37907 return NULL;
37908 }
37909
37910
37911 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
37912 PyObject *resultobj;
37913 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37914 int arg2 ;
37915 int arg3 ;
37916 PyObject * obj0 = 0 ;
37917 PyObject * obj1 = 0 ;
37918 PyObject * obj2 = 0 ;
37919 char *kwnames[] = {
37920 (char *) "self",(char *) "width",(char *) "height", NULL
37921 };
37922
37923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
37924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37925 if (SWIG_arg_fail(1)) SWIG_fail;
37926 {
37927 arg2 = (int)(SWIG_As_int(obj1));
37928 if (SWIG_arg_fail(2)) SWIG_fail;
37929 }
37930 {
37931 arg3 = (int)(SWIG_As_int(obj2));
37932 if (SWIG_arg_fail(3)) SWIG_fail;
37933 }
37934 {
37935 PyThreadState* __tstate = wxPyBeginAllowThreads();
37936 (arg1)->SetRatio(arg2,arg3);
37937
37938 wxPyEndAllowThreads(__tstate);
37939 if (PyErr_Occurred()) SWIG_fail;
37940 }
37941 Py_INCREF(Py_None); resultobj = Py_None;
37942 return resultobj;
37943 fail:
37944 return NULL;
37945 }
37946
37947
37948 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
37949 PyObject *resultobj;
37950 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37951 wxSize arg2 ;
37952 PyObject * obj0 = 0 ;
37953 PyObject * obj1 = 0 ;
37954 char *kwnames[] = {
37955 (char *) "self",(char *) "size", NULL
37956 };
37957
37958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
37959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37960 if (SWIG_arg_fail(1)) SWIG_fail;
37961 {
37962 wxSize * argp;
37963 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37964 if (SWIG_arg_fail(2)) SWIG_fail;
37965 if (argp == NULL) {
37966 SWIG_null_ref("wxSize");
37967 }
37968 if (SWIG_arg_fail(2)) SWIG_fail;
37969 arg2 = *argp;
37970 }
37971 {
37972 PyThreadState* __tstate = wxPyBeginAllowThreads();
37973 (arg1)->SetRatio(arg2);
37974
37975 wxPyEndAllowThreads(__tstate);
37976 if (PyErr_Occurred()) SWIG_fail;
37977 }
37978 Py_INCREF(Py_None); resultobj = Py_None;
37979 return resultobj;
37980 fail:
37981 return NULL;
37982 }
37983
37984
37985 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37986 PyObject *resultobj;
37987 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37988 float arg2 ;
37989 PyObject * obj0 = 0 ;
37990 PyObject * obj1 = 0 ;
37991 char *kwnames[] = {
37992 (char *) "self",(char *) "ratio", NULL
37993 };
37994
37995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
37996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37997 if (SWIG_arg_fail(1)) SWIG_fail;
37998 {
37999 arg2 = (float)(SWIG_As_float(obj1));
38000 if (SWIG_arg_fail(2)) SWIG_fail;
38001 }
38002 {
38003 PyThreadState* __tstate = wxPyBeginAllowThreads();
38004 (arg1)->SetRatio(arg2);
38005
38006 wxPyEndAllowThreads(__tstate);
38007 if (PyErr_Occurred()) SWIG_fail;
38008 }
38009 Py_INCREF(Py_None); resultobj = Py_None;
38010 return resultobj;
38011 fail:
38012 return NULL;
38013 }
38014
38015
38016 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38017 PyObject *resultobj;
38018 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38019 float result;
38020 PyObject * obj0 = 0 ;
38021 char *kwnames[] = {
38022 (char *) "self", NULL
38023 };
38024
38025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38027 if (SWIG_arg_fail(1)) SWIG_fail;
38028 {
38029 PyThreadState* __tstate = wxPyBeginAllowThreads();
38030 result = (float)(arg1)->GetRatio();
38031
38032 wxPyEndAllowThreads(__tstate);
38033 if (PyErr_Occurred()) SWIG_fail;
38034 }
38035 {
38036 resultobj = SWIG_From_float((float)(result));
38037 }
38038 return resultobj;
38039 fail:
38040 return NULL;
38041 }
38042
38043
38044 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38045 PyObject *resultobj;
38046 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38047 wxRect result;
38048 PyObject * obj0 = 0 ;
38049 char *kwnames[] = {
38050 (char *) "self", NULL
38051 };
38052
38053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38055 if (SWIG_arg_fail(1)) SWIG_fail;
38056 {
38057 PyThreadState* __tstate = wxPyBeginAllowThreads();
38058 result = (arg1)->GetRect();
38059
38060 wxPyEndAllowThreads(__tstate);
38061 if (PyErr_Occurred()) SWIG_fail;
38062 }
38063 {
38064 wxRect * resultptr;
38065 resultptr = new wxRect((wxRect &)(result));
38066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38067 }
38068 return resultobj;
38069 fail:
38070 return NULL;
38071 }
38072
38073
38074 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38075 PyObject *resultobj;
38076 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38077 bool result;
38078 PyObject * obj0 = 0 ;
38079 char *kwnames[] = {
38080 (char *) "self", NULL
38081 };
38082
38083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38085 if (SWIG_arg_fail(1)) SWIG_fail;
38086 {
38087 PyThreadState* __tstate = wxPyBeginAllowThreads();
38088 result = (bool)(arg1)->IsWindow();
38089
38090 wxPyEndAllowThreads(__tstate);
38091 if (PyErr_Occurred()) SWIG_fail;
38092 }
38093 {
38094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38095 }
38096 return resultobj;
38097 fail:
38098 return NULL;
38099 }
38100
38101
38102 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38103 PyObject *resultobj;
38104 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38105 bool result;
38106 PyObject * obj0 = 0 ;
38107 char *kwnames[] = {
38108 (char *) "self", NULL
38109 };
38110
38111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38113 if (SWIG_arg_fail(1)) SWIG_fail;
38114 {
38115 PyThreadState* __tstate = wxPyBeginAllowThreads();
38116 result = (bool)(arg1)->IsSizer();
38117
38118 wxPyEndAllowThreads(__tstate);
38119 if (PyErr_Occurred()) SWIG_fail;
38120 }
38121 {
38122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38123 }
38124 return resultobj;
38125 fail:
38126 return NULL;
38127 }
38128
38129
38130 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38131 PyObject *resultobj;
38132 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38133 bool result;
38134 PyObject * obj0 = 0 ;
38135 char *kwnames[] = {
38136 (char *) "self", NULL
38137 };
38138
38139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38141 if (SWIG_arg_fail(1)) SWIG_fail;
38142 {
38143 PyThreadState* __tstate = wxPyBeginAllowThreads();
38144 result = (bool)(arg1)->IsSpacer();
38145
38146 wxPyEndAllowThreads(__tstate);
38147 if (PyErr_Occurred()) SWIG_fail;
38148 }
38149 {
38150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38151 }
38152 return resultobj;
38153 fail:
38154 return NULL;
38155 }
38156
38157
38158 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38159 PyObject *resultobj;
38160 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38161 int arg2 ;
38162 PyObject * obj0 = 0 ;
38163 PyObject * obj1 = 0 ;
38164 char *kwnames[] = {
38165 (char *) "self",(char *) "proportion", NULL
38166 };
38167
38168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38170 if (SWIG_arg_fail(1)) SWIG_fail;
38171 {
38172 arg2 = (int)(SWIG_As_int(obj1));
38173 if (SWIG_arg_fail(2)) SWIG_fail;
38174 }
38175 {
38176 PyThreadState* __tstate = wxPyBeginAllowThreads();
38177 (arg1)->SetProportion(arg2);
38178
38179 wxPyEndAllowThreads(__tstate);
38180 if (PyErr_Occurred()) SWIG_fail;
38181 }
38182 Py_INCREF(Py_None); resultobj = Py_None;
38183 return resultobj;
38184 fail:
38185 return NULL;
38186 }
38187
38188
38189 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38190 PyObject *resultobj;
38191 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38192 int result;
38193 PyObject * obj0 = 0 ;
38194 char *kwnames[] = {
38195 (char *) "self", NULL
38196 };
38197
38198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38200 if (SWIG_arg_fail(1)) SWIG_fail;
38201 {
38202 PyThreadState* __tstate = wxPyBeginAllowThreads();
38203 result = (int)(arg1)->GetProportion();
38204
38205 wxPyEndAllowThreads(__tstate);
38206 if (PyErr_Occurred()) SWIG_fail;
38207 }
38208 {
38209 resultobj = SWIG_From_int((int)(result));
38210 }
38211 return resultobj;
38212 fail:
38213 return NULL;
38214 }
38215
38216
38217 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38218 PyObject *resultobj;
38219 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38220 int arg2 ;
38221 PyObject * obj0 = 0 ;
38222 PyObject * obj1 = 0 ;
38223 char *kwnames[] = {
38224 (char *) "self",(char *) "flag", NULL
38225 };
38226
38227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38229 if (SWIG_arg_fail(1)) SWIG_fail;
38230 {
38231 arg2 = (int)(SWIG_As_int(obj1));
38232 if (SWIG_arg_fail(2)) SWIG_fail;
38233 }
38234 {
38235 PyThreadState* __tstate = wxPyBeginAllowThreads();
38236 (arg1)->SetFlag(arg2);
38237
38238 wxPyEndAllowThreads(__tstate);
38239 if (PyErr_Occurred()) SWIG_fail;
38240 }
38241 Py_INCREF(Py_None); resultobj = Py_None;
38242 return resultobj;
38243 fail:
38244 return NULL;
38245 }
38246
38247
38248 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38249 PyObject *resultobj;
38250 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38251 int result;
38252 PyObject * obj0 = 0 ;
38253 char *kwnames[] = {
38254 (char *) "self", NULL
38255 };
38256
38257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38259 if (SWIG_arg_fail(1)) SWIG_fail;
38260 {
38261 PyThreadState* __tstate = wxPyBeginAllowThreads();
38262 result = (int)(arg1)->GetFlag();
38263
38264 wxPyEndAllowThreads(__tstate);
38265 if (PyErr_Occurred()) SWIG_fail;
38266 }
38267 {
38268 resultobj = SWIG_From_int((int)(result));
38269 }
38270 return resultobj;
38271 fail:
38272 return NULL;
38273 }
38274
38275
38276 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38277 PyObject *resultobj;
38278 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38279 int arg2 ;
38280 PyObject * obj0 = 0 ;
38281 PyObject * obj1 = 0 ;
38282 char *kwnames[] = {
38283 (char *) "self",(char *) "border", NULL
38284 };
38285
38286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38288 if (SWIG_arg_fail(1)) SWIG_fail;
38289 {
38290 arg2 = (int)(SWIG_As_int(obj1));
38291 if (SWIG_arg_fail(2)) SWIG_fail;
38292 }
38293 {
38294 PyThreadState* __tstate = wxPyBeginAllowThreads();
38295 (arg1)->SetBorder(arg2);
38296
38297 wxPyEndAllowThreads(__tstate);
38298 if (PyErr_Occurred()) SWIG_fail;
38299 }
38300 Py_INCREF(Py_None); resultobj = Py_None;
38301 return resultobj;
38302 fail:
38303 return NULL;
38304 }
38305
38306
38307 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38308 PyObject *resultobj;
38309 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38310 int result;
38311 PyObject * obj0 = 0 ;
38312 char *kwnames[] = {
38313 (char *) "self", NULL
38314 };
38315
38316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38318 if (SWIG_arg_fail(1)) SWIG_fail;
38319 {
38320 PyThreadState* __tstate = wxPyBeginAllowThreads();
38321 result = (int)(arg1)->GetBorder();
38322
38323 wxPyEndAllowThreads(__tstate);
38324 if (PyErr_Occurred()) SWIG_fail;
38325 }
38326 {
38327 resultobj = SWIG_From_int((int)(result));
38328 }
38329 return resultobj;
38330 fail:
38331 return NULL;
38332 }
38333
38334
38335 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38336 PyObject *resultobj;
38337 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38338 wxWindow *result;
38339 PyObject * obj0 = 0 ;
38340 char *kwnames[] = {
38341 (char *) "self", NULL
38342 };
38343
38344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38346 if (SWIG_arg_fail(1)) SWIG_fail;
38347 {
38348 PyThreadState* __tstate = wxPyBeginAllowThreads();
38349 result = (wxWindow *)(arg1)->GetWindow();
38350
38351 wxPyEndAllowThreads(__tstate);
38352 if (PyErr_Occurred()) SWIG_fail;
38353 }
38354 {
38355 resultobj = wxPyMake_wxObject(result, 0);
38356 }
38357 return resultobj;
38358 fail:
38359 return NULL;
38360 }
38361
38362
38363 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38364 PyObject *resultobj;
38365 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38366 wxWindow *arg2 = (wxWindow *) 0 ;
38367 PyObject * obj0 = 0 ;
38368 PyObject * obj1 = 0 ;
38369 char *kwnames[] = {
38370 (char *) "self",(char *) "window", NULL
38371 };
38372
38373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38375 if (SWIG_arg_fail(1)) SWIG_fail;
38376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38377 if (SWIG_arg_fail(2)) SWIG_fail;
38378 {
38379 PyThreadState* __tstate = wxPyBeginAllowThreads();
38380 (arg1)->SetWindow(arg2);
38381
38382 wxPyEndAllowThreads(__tstate);
38383 if (PyErr_Occurred()) SWIG_fail;
38384 }
38385 Py_INCREF(Py_None); resultobj = Py_None;
38386 return resultobj;
38387 fail:
38388 return NULL;
38389 }
38390
38391
38392 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38393 PyObject *resultobj;
38394 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38395 wxSizer *result;
38396 PyObject * obj0 = 0 ;
38397 char *kwnames[] = {
38398 (char *) "self", NULL
38399 };
38400
38401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38403 if (SWIG_arg_fail(1)) SWIG_fail;
38404 {
38405 PyThreadState* __tstate = wxPyBeginAllowThreads();
38406 result = (wxSizer *)(arg1)->GetSizer();
38407
38408 wxPyEndAllowThreads(__tstate);
38409 if (PyErr_Occurred()) SWIG_fail;
38410 }
38411 {
38412 resultobj = wxPyMake_wxSizer(result, 0);
38413 }
38414 return resultobj;
38415 fail:
38416 return NULL;
38417 }
38418
38419
38420 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38421 PyObject *resultobj;
38422 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38423 wxSizer *arg2 = (wxSizer *) 0 ;
38424 PyObject * obj0 = 0 ;
38425 PyObject * obj1 = 0 ;
38426 char *kwnames[] = {
38427 (char *) "self",(char *) "sizer", NULL
38428 };
38429
38430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38432 if (SWIG_arg_fail(1)) SWIG_fail;
38433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38434 if (SWIG_arg_fail(2)) SWIG_fail;
38435 {
38436 PyThreadState* __tstate = wxPyBeginAllowThreads();
38437 (arg1)->SetSizer(arg2);
38438
38439 wxPyEndAllowThreads(__tstate);
38440 if (PyErr_Occurred()) SWIG_fail;
38441 }
38442 Py_INCREF(Py_None); resultobj = Py_None;
38443 return resultobj;
38444 fail:
38445 return NULL;
38446 }
38447
38448
38449 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38450 PyObject *resultobj;
38451 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38452 wxSize *result;
38453 PyObject * obj0 = 0 ;
38454 char *kwnames[] = {
38455 (char *) "self", NULL
38456 };
38457
38458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38460 if (SWIG_arg_fail(1)) SWIG_fail;
38461 {
38462 PyThreadState* __tstate = wxPyBeginAllowThreads();
38463 {
38464 wxSize const &_result_ref = (arg1)->GetSpacer();
38465 result = (wxSize *) &_result_ref;
38466 }
38467
38468 wxPyEndAllowThreads(__tstate);
38469 if (PyErr_Occurred()) SWIG_fail;
38470 }
38471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38472 return resultobj;
38473 fail:
38474 return NULL;
38475 }
38476
38477
38478 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38479 PyObject *resultobj;
38480 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38481 wxSize *arg2 = 0 ;
38482 wxSize temp2 ;
38483 PyObject * obj0 = 0 ;
38484 PyObject * obj1 = 0 ;
38485 char *kwnames[] = {
38486 (char *) "self",(char *) "size", NULL
38487 };
38488
38489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38491 if (SWIG_arg_fail(1)) SWIG_fail;
38492 {
38493 arg2 = &temp2;
38494 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38495 }
38496 {
38497 PyThreadState* __tstate = wxPyBeginAllowThreads();
38498 (arg1)->SetSpacer((wxSize const &)*arg2);
38499
38500 wxPyEndAllowThreads(__tstate);
38501 if (PyErr_Occurred()) SWIG_fail;
38502 }
38503 Py_INCREF(Py_None); resultobj = Py_None;
38504 return resultobj;
38505 fail:
38506 return NULL;
38507 }
38508
38509
38510 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38511 PyObject *resultobj;
38512 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38513 bool arg2 ;
38514 PyObject * obj0 = 0 ;
38515 PyObject * obj1 = 0 ;
38516 char *kwnames[] = {
38517 (char *) "self",(char *) "show", NULL
38518 };
38519
38520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38522 if (SWIG_arg_fail(1)) SWIG_fail;
38523 {
38524 arg2 = (bool)(SWIG_As_bool(obj1));
38525 if (SWIG_arg_fail(2)) SWIG_fail;
38526 }
38527 {
38528 PyThreadState* __tstate = wxPyBeginAllowThreads();
38529 (arg1)->Show(arg2);
38530
38531 wxPyEndAllowThreads(__tstate);
38532 if (PyErr_Occurred()) SWIG_fail;
38533 }
38534 Py_INCREF(Py_None); resultobj = Py_None;
38535 return resultobj;
38536 fail:
38537 return NULL;
38538 }
38539
38540
38541 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38542 PyObject *resultobj;
38543 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38544 bool result;
38545 PyObject * obj0 = 0 ;
38546 char *kwnames[] = {
38547 (char *) "self", NULL
38548 };
38549
38550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38552 if (SWIG_arg_fail(1)) SWIG_fail;
38553 {
38554 PyThreadState* __tstate = wxPyBeginAllowThreads();
38555 result = (bool)(arg1)->IsShown();
38556
38557 wxPyEndAllowThreads(__tstate);
38558 if (PyErr_Occurred()) SWIG_fail;
38559 }
38560 {
38561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38562 }
38563 return resultobj;
38564 fail:
38565 return NULL;
38566 }
38567
38568
38569 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38570 PyObject *resultobj;
38571 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38572 wxPoint result;
38573 PyObject * obj0 = 0 ;
38574 char *kwnames[] = {
38575 (char *) "self", NULL
38576 };
38577
38578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38580 if (SWIG_arg_fail(1)) SWIG_fail;
38581 {
38582 PyThreadState* __tstate = wxPyBeginAllowThreads();
38583 result = (arg1)->GetPosition();
38584
38585 wxPyEndAllowThreads(__tstate);
38586 if (PyErr_Occurred()) SWIG_fail;
38587 }
38588 {
38589 wxPoint * resultptr;
38590 resultptr = new wxPoint((wxPoint &)(result));
38591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38592 }
38593 return resultobj;
38594 fail:
38595 return NULL;
38596 }
38597
38598
38599 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38600 PyObject *resultobj;
38601 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38602 PyObject *result;
38603 PyObject * obj0 = 0 ;
38604 char *kwnames[] = {
38605 (char *) "self", NULL
38606 };
38607
38608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38610 if (SWIG_arg_fail(1)) SWIG_fail;
38611 {
38612 PyThreadState* __tstate = wxPyBeginAllowThreads();
38613 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38614
38615 wxPyEndAllowThreads(__tstate);
38616 if (PyErr_Occurred()) SWIG_fail;
38617 }
38618 resultobj = result;
38619 return resultobj;
38620 fail:
38621 return NULL;
38622 }
38623
38624
38625 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38626 PyObject *obj;
38627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38628 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38629 Py_INCREF(obj);
38630 return Py_BuildValue((char *)"");
38631 }
38632 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38633 PyObject *resultobj;
38634 wxSizer *arg1 = (wxSizer *) 0 ;
38635 PyObject *arg2 = (PyObject *) 0 ;
38636 PyObject * obj0 = 0 ;
38637 PyObject * obj1 = 0 ;
38638 char *kwnames[] = {
38639 (char *) "self",(char *) "_self", NULL
38640 };
38641
38642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38644 if (SWIG_arg_fail(1)) SWIG_fail;
38645 arg2 = obj1;
38646 {
38647 PyThreadState* __tstate = wxPyBeginAllowThreads();
38648 wxSizer__setOORInfo(arg1,arg2);
38649
38650 wxPyEndAllowThreads(__tstate);
38651 if (PyErr_Occurred()) SWIG_fail;
38652 }
38653 Py_INCREF(Py_None); resultobj = Py_None;
38654 return resultobj;
38655 fail:
38656 return NULL;
38657 }
38658
38659
38660 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38661 PyObject *resultobj;
38662 wxSizer *arg1 = (wxSizer *) 0 ;
38663 PyObject *arg2 = (PyObject *) 0 ;
38664 int arg3 = (int) 0 ;
38665 int arg4 = (int) 0 ;
38666 int arg5 = (int) 0 ;
38667 PyObject *arg6 = (PyObject *) NULL ;
38668 wxSizerItem *result;
38669 PyObject * obj0 = 0 ;
38670 PyObject * obj1 = 0 ;
38671 PyObject * obj2 = 0 ;
38672 PyObject * obj3 = 0 ;
38673 PyObject * obj4 = 0 ;
38674 PyObject * obj5 = 0 ;
38675 char *kwnames[] = {
38676 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38677 };
38678
38679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38681 if (SWIG_arg_fail(1)) SWIG_fail;
38682 arg2 = obj1;
38683 if (obj2) {
38684 {
38685 arg3 = (int)(SWIG_As_int(obj2));
38686 if (SWIG_arg_fail(3)) SWIG_fail;
38687 }
38688 }
38689 if (obj3) {
38690 {
38691 arg4 = (int)(SWIG_As_int(obj3));
38692 if (SWIG_arg_fail(4)) SWIG_fail;
38693 }
38694 }
38695 if (obj4) {
38696 {
38697 arg5 = (int)(SWIG_As_int(obj4));
38698 if (SWIG_arg_fail(5)) SWIG_fail;
38699 }
38700 }
38701 if (obj5) {
38702 arg6 = obj5;
38703 }
38704 {
38705 PyThreadState* __tstate = wxPyBeginAllowThreads();
38706 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
38707
38708 wxPyEndAllowThreads(__tstate);
38709 if (PyErr_Occurred()) SWIG_fail;
38710 }
38711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38712 return resultobj;
38713 fail:
38714 return NULL;
38715 }
38716
38717
38718 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38719 PyObject *resultobj;
38720 wxSizer *arg1 = (wxSizer *) 0 ;
38721 int arg2 ;
38722 PyObject *arg3 = (PyObject *) 0 ;
38723 int arg4 = (int) 0 ;
38724 int arg5 = (int) 0 ;
38725 int arg6 = (int) 0 ;
38726 PyObject *arg7 = (PyObject *) NULL ;
38727 wxSizerItem *result;
38728 PyObject * obj0 = 0 ;
38729 PyObject * obj1 = 0 ;
38730 PyObject * obj2 = 0 ;
38731 PyObject * obj3 = 0 ;
38732 PyObject * obj4 = 0 ;
38733 PyObject * obj5 = 0 ;
38734 PyObject * obj6 = 0 ;
38735 char *kwnames[] = {
38736 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38737 };
38738
38739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38741 if (SWIG_arg_fail(1)) SWIG_fail;
38742 {
38743 arg2 = (int)(SWIG_As_int(obj1));
38744 if (SWIG_arg_fail(2)) SWIG_fail;
38745 }
38746 arg3 = obj2;
38747 if (obj3) {
38748 {
38749 arg4 = (int)(SWIG_As_int(obj3));
38750 if (SWIG_arg_fail(4)) SWIG_fail;
38751 }
38752 }
38753 if (obj4) {
38754 {
38755 arg5 = (int)(SWIG_As_int(obj4));
38756 if (SWIG_arg_fail(5)) SWIG_fail;
38757 }
38758 }
38759 if (obj5) {
38760 {
38761 arg6 = (int)(SWIG_As_int(obj5));
38762 if (SWIG_arg_fail(6)) SWIG_fail;
38763 }
38764 }
38765 if (obj6) {
38766 arg7 = obj6;
38767 }
38768 {
38769 PyThreadState* __tstate = wxPyBeginAllowThreads();
38770 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
38771
38772 wxPyEndAllowThreads(__tstate);
38773 if (PyErr_Occurred()) SWIG_fail;
38774 }
38775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38776 return resultobj;
38777 fail:
38778 return NULL;
38779 }
38780
38781
38782 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
38783 PyObject *resultobj;
38784 wxSizer *arg1 = (wxSizer *) 0 ;
38785 PyObject *arg2 = (PyObject *) 0 ;
38786 int arg3 = (int) 0 ;
38787 int arg4 = (int) 0 ;
38788 int arg5 = (int) 0 ;
38789 PyObject *arg6 = (PyObject *) NULL ;
38790 wxSizerItem *result;
38791 PyObject * obj0 = 0 ;
38792 PyObject * obj1 = 0 ;
38793 PyObject * obj2 = 0 ;
38794 PyObject * obj3 = 0 ;
38795 PyObject * obj4 = 0 ;
38796 PyObject * obj5 = 0 ;
38797 char *kwnames[] = {
38798 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38799 };
38800
38801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38803 if (SWIG_arg_fail(1)) SWIG_fail;
38804 arg2 = obj1;
38805 if (obj2) {
38806 {
38807 arg3 = (int)(SWIG_As_int(obj2));
38808 if (SWIG_arg_fail(3)) SWIG_fail;
38809 }
38810 }
38811 if (obj3) {
38812 {
38813 arg4 = (int)(SWIG_As_int(obj3));
38814 if (SWIG_arg_fail(4)) SWIG_fail;
38815 }
38816 }
38817 if (obj4) {
38818 {
38819 arg5 = (int)(SWIG_As_int(obj4));
38820 if (SWIG_arg_fail(5)) SWIG_fail;
38821 }
38822 }
38823 if (obj5) {
38824 arg6 = obj5;
38825 }
38826 {
38827 PyThreadState* __tstate = wxPyBeginAllowThreads();
38828 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
38829
38830 wxPyEndAllowThreads(__tstate);
38831 if (PyErr_Occurred()) SWIG_fail;
38832 }
38833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38834 return resultobj;
38835 fail:
38836 return NULL;
38837 }
38838
38839
38840 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
38841 PyObject *resultobj;
38842 wxSizer *arg1 = (wxSizer *) 0 ;
38843 PyObject *arg2 = (PyObject *) 0 ;
38844 bool result;
38845 PyObject * obj0 = 0 ;
38846 PyObject * obj1 = 0 ;
38847 char *kwnames[] = {
38848 (char *) "self",(char *) "item", NULL
38849 };
38850
38851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
38852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38853 if (SWIG_arg_fail(1)) SWIG_fail;
38854 arg2 = obj1;
38855 {
38856 PyThreadState* __tstate = wxPyBeginAllowThreads();
38857 result = (bool)wxSizer_Remove(arg1,arg2);
38858
38859 wxPyEndAllowThreads(__tstate);
38860 if (PyErr_Occurred()) SWIG_fail;
38861 }
38862 {
38863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38864 }
38865 return resultobj;
38866 fail:
38867 return NULL;
38868 }
38869
38870
38871 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
38872 PyObject *resultobj;
38873 wxSizer *arg1 = (wxSizer *) 0 ;
38874 PyObject *arg2 = (PyObject *) 0 ;
38875 bool result;
38876 PyObject * obj0 = 0 ;
38877 PyObject * obj1 = 0 ;
38878 char *kwnames[] = {
38879 (char *) "self",(char *) "item", NULL
38880 };
38881
38882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
38883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38884 if (SWIG_arg_fail(1)) SWIG_fail;
38885 arg2 = obj1;
38886 {
38887 PyThreadState* __tstate = wxPyBeginAllowThreads();
38888 result = (bool)wxSizer_Detach(arg1,arg2);
38889
38890 wxPyEndAllowThreads(__tstate);
38891 if (PyErr_Occurred()) SWIG_fail;
38892 }
38893 {
38894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38895 }
38896 return resultobj;
38897 fail:
38898 return NULL;
38899 }
38900
38901
38902 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
38903 PyObject *resultobj;
38904 wxSizer *arg1 = (wxSizer *) 0 ;
38905 PyObject *arg2 = (PyObject *) 0 ;
38906 wxSizerItem *result;
38907 PyObject * obj0 = 0 ;
38908 PyObject * obj1 = 0 ;
38909 char *kwnames[] = {
38910 (char *) "self",(char *) "item", NULL
38911 };
38912
38913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
38914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38915 if (SWIG_arg_fail(1)) SWIG_fail;
38916 arg2 = obj1;
38917 {
38918 PyThreadState* __tstate = wxPyBeginAllowThreads();
38919 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
38920
38921 wxPyEndAllowThreads(__tstate);
38922 if (PyErr_Occurred()) SWIG_fail;
38923 }
38924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38925 return resultobj;
38926 fail:
38927 return NULL;
38928 }
38929
38930
38931 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38932 PyObject *resultobj;
38933 wxSizer *arg1 = (wxSizer *) 0 ;
38934 PyObject *arg2 = (PyObject *) 0 ;
38935 wxSize *arg3 = 0 ;
38936 wxSize temp3 ;
38937 PyObject * obj0 = 0 ;
38938 PyObject * obj1 = 0 ;
38939 PyObject * obj2 = 0 ;
38940 char *kwnames[] = {
38941 (char *) "self",(char *) "item",(char *) "size", NULL
38942 };
38943
38944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38946 if (SWIG_arg_fail(1)) SWIG_fail;
38947 arg2 = obj1;
38948 {
38949 arg3 = &temp3;
38950 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
38951 }
38952 {
38953 PyThreadState* __tstate = wxPyBeginAllowThreads();
38954 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
38955
38956 wxPyEndAllowThreads(__tstate);
38957 if (PyErr_Occurred()) SWIG_fail;
38958 }
38959 Py_INCREF(Py_None); resultobj = Py_None;
38960 return resultobj;
38961 fail:
38962 return NULL;
38963 }
38964
38965
38966 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
38967 PyObject *resultobj;
38968 wxSizer *arg1 = (wxSizer *) 0 ;
38969 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38970 wxSizerItem *result;
38971 PyObject * obj0 = 0 ;
38972 PyObject * obj1 = 0 ;
38973 char *kwnames[] = {
38974 (char *) "self",(char *) "item", NULL
38975 };
38976
38977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
38978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38979 if (SWIG_arg_fail(1)) SWIG_fail;
38980 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38981 if (SWIG_arg_fail(2)) SWIG_fail;
38982 {
38983 PyThreadState* __tstate = wxPyBeginAllowThreads();
38984 result = (wxSizerItem *)(arg1)->Add(arg2);
38985
38986 wxPyEndAllowThreads(__tstate);
38987 if (PyErr_Occurred()) SWIG_fail;
38988 }
38989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38990 return resultobj;
38991 fail:
38992 return NULL;
38993 }
38994
38995
38996 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
38997 PyObject *resultobj;
38998 wxSizer *arg1 = (wxSizer *) 0 ;
38999 size_t arg2 ;
39000 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39001 wxSizerItem *result;
39002 PyObject * obj0 = 0 ;
39003 PyObject * obj1 = 0 ;
39004 PyObject * obj2 = 0 ;
39005 char *kwnames[] = {
39006 (char *) "self",(char *) "index",(char *) "item", NULL
39007 };
39008
39009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39011 if (SWIG_arg_fail(1)) SWIG_fail;
39012 {
39013 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39014 if (SWIG_arg_fail(2)) SWIG_fail;
39015 }
39016 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39017 if (SWIG_arg_fail(3)) SWIG_fail;
39018 {
39019 PyThreadState* __tstate = wxPyBeginAllowThreads();
39020 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39021
39022 wxPyEndAllowThreads(__tstate);
39023 if (PyErr_Occurred()) SWIG_fail;
39024 }
39025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39026 return resultobj;
39027 fail:
39028 return NULL;
39029 }
39030
39031
39032 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39033 PyObject *resultobj;
39034 wxSizer *arg1 = (wxSizer *) 0 ;
39035 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39036 wxSizerItem *result;
39037 PyObject * obj0 = 0 ;
39038 PyObject * obj1 = 0 ;
39039 char *kwnames[] = {
39040 (char *) "self",(char *) "item", NULL
39041 };
39042
39043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39045 if (SWIG_arg_fail(1)) SWIG_fail;
39046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39047 if (SWIG_arg_fail(2)) SWIG_fail;
39048 {
39049 PyThreadState* __tstate = wxPyBeginAllowThreads();
39050 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39051
39052 wxPyEndAllowThreads(__tstate);
39053 if (PyErr_Occurred()) SWIG_fail;
39054 }
39055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39056 return resultobj;
39057 fail:
39058 return NULL;
39059 }
39060
39061
39062 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39063 PyObject *resultobj;
39064 wxSizer *arg1 = (wxSizer *) 0 ;
39065 int arg2 ;
39066 int arg3 ;
39067 int arg4 ;
39068 int arg5 ;
39069 PyObject * obj0 = 0 ;
39070 PyObject * obj1 = 0 ;
39071 PyObject * obj2 = 0 ;
39072 PyObject * obj3 = 0 ;
39073 PyObject * obj4 = 0 ;
39074 char *kwnames[] = {
39075 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39076 };
39077
39078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39080 if (SWIG_arg_fail(1)) SWIG_fail;
39081 {
39082 arg2 = (int)(SWIG_As_int(obj1));
39083 if (SWIG_arg_fail(2)) SWIG_fail;
39084 }
39085 {
39086 arg3 = (int)(SWIG_As_int(obj2));
39087 if (SWIG_arg_fail(3)) SWIG_fail;
39088 }
39089 {
39090 arg4 = (int)(SWIG_As_int(obj3));
39091 if (SWIG_arg_fail(4)) SWIG_fail;
39092 }
39093 {
39094 arg5 = (int)(SWIG_As_int(obj4));
39095 if (SWIG_arg_fail(5)) SWIG_fail;
39096 }
39097 {
39098 PyThreadState* __tstate = wxPyBeginAllowThreads();
39099 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39100
39101 wxPyEndAllowThreads(__tstate);
39102 if (PyErr_Occurred()) SWIG_fail;
39103 }
39104 Py_INCREF(Py_None); resultobj = Py_None;
39105 return resultobj;
39106 fail:
39107 return NULL;
39108 }
39109
39110
39111 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39112 PyObject *resultobj;
39113 wxSizer *arg1 = (wxSizer *) 0 ;
39114 wxSize *arg2 = 0 ;
39115 wxSize temp2 ;
39116 PyObject * obj0 = 0 ;
39117 PyObject * obj1 = 0 ;
39118 char *kwnames[] = {
39119 (char *) "self",(char *) "size", NULL
39120 };
39121
39122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39124 if (SWIG_arg_fail(1)) SWIG_fail;
39125 {
39126 arg2 = &temp2;
39127 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39128 }
39129 {
39130 PyThreadState* __tstate = wxPyBeginAllowThreads();
39131 (arg1)->SetMinSize((wxSize const &)*arg2);
39132
39133 wxPyEndAllowThreads(__tstate);
39134 if (PyErr_Occurred()) SWIG_fail;
39135 }
39136 Py_INCREF(Py_None); resultobj = Py_None;
39137 return resultobj;
39138 fail:
39139 return NULL;
39140 }
39141
39142
39143 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39144 PyObject *resultobj;
39145 wxSizer *arg1 = (wxSizer *) 0 ;
39146 wxSize result;
39147 PyObject * obj0 = 0 ;
39148 char *kwnames[] = {
39149 (char *) "self", NULL
39150 };
39151
39152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39154 if (SWIG_arg_fail(1)) SWIG_fail;
39155 {
39156 PyThreadState* __tstate = wxPyBeginAllowThreads();
39157 result = (arg1)->GetSize();
39158
39159 wxPyEndAllowThreads(__tstate);
39160 if (PyErr_Occurred()) SWIG_fail;
39161 }
39162 {
39163 wxSize * resultptr;
39164 resultptr = new wxSize((wxSize &)(result));
39165 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39166 }
39167 return resultobj;
39168 fail:
39169 return NULL;
39170 }
39171
39172
39173 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39174 PyObject *resultobj;
39175 wxSizer *arg1 = (wxSizer *) 0 ;
39176 wxPoint result;
39177 PyObject * obj0 = 0 ;
39178 char *kwnames[] = {
39179 (char *) "self", NULL
39180 };
39181
39182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39184 if (SWIG_arg_fail(1)) SWIG_fail;
39185 {
39186 PyThreadState* __tstate = wxPyBeginAllowThreads();
39187 result = (arg1)->GetPosition();
39188
39189 wxPyEndAllowThreads(__tstate);
39190 if (PyErr_Occurred()) SWIG_fail;
39191 }
39192 {
39193 wxPoint * resultptr;
39194 resultptr = new wxPoint((wxPoint &)(result));
39195 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39196 }
39197 return resultobj;
39198 fail:
39199 return NULL;
39200 }
39201
39202
39203 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39204 PyObject *resultobj;
39205 wxSizer *arg1 = (wxSizer *) 0 ;
39206 wxSize result;
39207 PyObject * obj0 = 0 ;
39208 char *kwnames[] = {
39209 (char *) "self", NULL
39210 };
39211
39212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39214 if (SWIG_arg_fail(1)) SWIG_fail;
39215 {
39216 PyThreadState* __tstate = wxPyBeginAllowThreads();
39217 result = (arg1)->GetMinSize();
39218
39219 wxPyEndAllowThreads(__tstate);
39220 if (PyErr_Occurred()) SWIG_fail;
39221 }
39222 {
39223 wxSize * resultptr;
39224 resultptr = new wxSize((wxSize &)(result));
39225 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39226 }
39227 return resultobj;
39228 fail:
39229 return NULL;
39230 }
39231
39232
39233 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39234 PyObject *resultobj;
39235 wxSizer *arg1 = (wxSizer *) 0 ;
39236 PyObject * obj0 = 0 ;
39237 char *kwnames[] = {
39238 (char *) "self", NULL
39239 };
39240
39241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39243 if (SWIG_arg_fail(1)) SWIG_fail;
39244 {
39245 PyThreadState* __tstate = wxPyBeginAllowThreads();
39246 (arg1)->RecalcSizes();
39247
39248 wxPyEndAllowThreads(__tstate);
39249 if (PyErr_Occurred()) SWIG_fail;
39250 }
39251 Py_INCREF(Py_None); resultobj = Py_None;
39252 return resultobj;
39253 fail:
39254 return NULL;
39255 }
39256
39257
39258 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39259 PyObject *resultobj;
39260 wxSizer *arg1 = (wxSizer *) 0 ;
39261 wxSize result;
39262 PyObject * obj0 = 0 ;
39263 char *kwnames[] = {
39264 (char *) "self", NULL
39265 };
39266
39267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39269 if (SWIG_arg_fail(1)) SWIG_fail;
39270 {
39271 PyThreadState* __tstate = wxPyBeginAllowThreads();
39272 result = (arg1)->CalcMin();
39273
39274 wxPyEndAllowThreads(__tstate);
39275 if (PyErr_Occurred()) SWIG_fail;
39276 }
39277 {
39278 wxSize * resultptr;
39279 resultptr = new wxSize((wxSize &)(result));
39280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39281 }
39282 return resultobj;
39283 fail:
39284 return NULL;
39285 }
39286
39287
39288 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39289 PyObject *resultobj;
39290 wxSizer *arg1 = (wxSizer *) 0 ;
39291 PyObject * obj0 = 0 ;
39292 char *kwnames[] = {
39293 (char *) "self", NULL
39294 };
39295
39296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39298 if (SWIG_arg_fail(1)) SWIG_fail;
39299 {
39300 PyThreadState* __tstate = wxPyBeginAllowThreads();
39301 (arg1)->Layout();
39302
39303 wxPyEndAllowThreads(__tstate);
39304 if (PyErr_Occurred()) SWIG_fail;
39305 }
39306 Py_INCREF(Py_None); resultobj = Py_None;
39307 return resultobj;
39308 fail:
39309 return NULL;
39310 }
39311
39312
39313 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39314 PyObject *resultobj;
39315 wxSizer *arg1 = (wxSizer *) 0 ;
39316 wxWindow *arg2 = (wxWindow *) 0 ;
39317 wxSize result;
39318 PyObject * obj0 = 0 ;
39319 PyObject * obj1 = 0 ;
39320 char *kwnames[] = {
39321 (char *) "self",(char *) "window", NULL
39322 };
39323
39324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39326 if (SWIG_arg_fail(1)) SWIG_fail;
39327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39328 if (SWIG_arg_fail(2)) SWIG_fail;
39329 {
39330 PyThreadState* __tstate = wxPyBeginAllowThreads();
39331 result = (arg1)->Fit(arg2);
39332
39333 wxPyEndAllowThreads(__tstate);
39334 if (PyErr_Occurred()) SWIG_fail;
39335 }
39336 {
39337 wxSize * resultptr;
39338 resultptr = new wxSize((wxSize &)(result));
39339 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39340 }
39341 return resultobj;
39342 fail:
39343 return NULL;
39344 }
39345
39346
39347 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39348 PyObject *resultobj;
39349 wxSizer *arg1 = (wxSizer *) 0 ;
39350 wxWindow *arg2 = (wxWindow *) 0 ;
39351 PyObject * obj0 = 0 ;
39352 PyObject * obj1 = 0 ;
39353 char *kwnames[] = {
39354 (char *) "self",(char *) "window", NULL
39355 };
39356
39357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39359 if (SWIG_arg_fail(1)) SWIG_fail;
39360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39361 if (SWIG_arg_fail(2)) SWIG_fail;
39362 {
39363 PyThreadState* __tstate = wxPyBeginAllowThreads();
39364 (arg1)->FitInside(arg2);
39365
39366 wxPyEndAllowThreads(__tstate);
39367 if (PyErr_Occurred()) SWIG_fail;
39368 }
39369 Py_INCREF(Py_None); resultobj = Py_None;
39370 return resultobj;
39371 fail:
39372 return NULL;
39373 }
39374
39375
39376 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39377 PyObject *resultobj;
39378 wxSizer *arg1 = (wxSizer *) 0 ;
39379 wxWindow *arg2 = (wxWindow *) 0 ;
39380 PyObject * obj0 = 0 ;
39381 PyObject * obj1 = 0 ;
39382 char *kwnames[] = {
39383 (char *) "self",(char *) "window", NULL
39384 };
39385
39386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39388 if (SWIG_arg_fail(1)) SWIG_fail;
39389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39390 if (SWIG_arg_fail(2)) SWIG_fail;
39391 {
39392 PyThreadState* __tstate = wxPyBeginAllowThreads();
39393 (arg1)->SetSizeHints(arg2);
39394
39395 wxPyEndAllowThreads(__tstate);
39396 if (PyErr_Occurred()) SWIG_fail;
39397 }
39398 Py_INCREF(Py_None); resultobj = Py_None;
39399 return resultobj;
39400 fail:
39401 return NULL;
39402 }
39403
39404
39405 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39406 PyObject *resultobj;
39407 wxSizer *arg1 = (wxSizer *) 0 ;
39408 wxWindow *arg2 = (wxWindow *) 0 ;
39409 PyObject * obj0 = 0 ;
39410 PyObject * obj1 = 0 ;
39411 char *kwnames[] = {
39412 (char *) "self",(char *) "window", NULL
39413 };
39414
39415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39417 if (SWIG_arg_fail(1)) SWIG_fail;
39418 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39419 if (SWIG_arg_fail(2)) SWIG_fail;
39420 {
39421 PyThreadState* __tstate = wxPyBeginAllowThreads();
39422 (arg1)->SetVirtualSizeHints(arg2);
39423
39424 wxPyEndAllowThreads(__tstate);
39425 if (PyErr_Occurred()) SWIG_fail;
39426 }
39427 Py_INCREF(Py_None); resultobj = Py_None;
39428 return resultobj;
39429 fail:
39430 return NULL;
39431 }
39432
39433
39434 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39435 PyObject *resultobj;
39436 wxSizer *arg1 = (wxSizer *) 0 ;
39437 bool arg2 = (bool) false ;
39438 PyObject * obj0 = 0 ;
39439 PyObject * obj1 = 0 ;
39440 char *kwnames[] = {
39441 (char *) "self",(char *) "deleteWindows", NULL
39442 };
39443
39444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39446 if (SWIG_arg_fail(1)) SWIG_fail;
39447 if (obj1) {
39448 {
39449 arg2 = (bool)(SWIG_As_bool(obj1));
39450 if (SWIG_arg_fail(2)) SWIG_fail;
39451 }
39452 }
39453 {
39454 PyThreadState* __tstate = wxPyBeginAllowThreads();
39455 (arg1)->Clear(arg2);
39456
39457 wxPyEndAllowThreads(__tstate);
39458 if (PyErr_Occurred()) SWIG_fail;
39459 }
39460 Py_INCREF(Py_None); resultobj = Py_None;
39461 return resultobj;
39462 fail:
39463 return NULL;
39464 }
39465
39466
39467 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39468 PyObject *resultobj;
39469 wxSizer *arg1 = (wxSizer *) 0 ;
39470 PyObject * obj0 = 0 ;
39471 char *kwnames[] = {
39472 (char *) "self", NULL
39473 };
39474
39475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39477 if (SWIG_arg_fail(1)) SWIG_fail;
39478 {
39479 PyThreadState* __tstate = wxPyBeginAllowThreads();
39480 (arg1)->DeleteWindows();
39481
39482 wxPyEndAllowThreads(__tstate);
39483 if (PyErr_Occurred()) SWIG_fail;
39484 }
39485 Py_INCREF(Py_None); resultobj = Py_None;
39486 return resultobj;
39487 fail:
39488 return NULL;
39489 }
39490
39491
39492 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39493 PyObject *resultobj;
39494 wxSizer *arg1 = (wxSizer *) 0 ;
39495 PyObject *result;
39496 PyObject * obj0 = 0 ;
39497 char *kwnames[] = {
39498 (char *) "self", NULL
39499 };
39500
39501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39503 if (SWIG_arg_fail(1)) SWIG_fail;
39504 {
39505 PyThreadState* __tstate = wxPyBeginAllowThreads();
39506 result = (PyObject *)wxSizer_GetChildren(arg1);
39507
39508 wxPyEndAllowThreads(__tstate);
39509 if (PyErr_Occurred()) SWIG_fail;
39510 }
39511 resultobj = result;
39512 return resultobj;
39513 fail:
39514 return NULL;
39515 }
39516
39517
39518 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39519 PyObject *resultobj;
39520 wxSizer *arg1 = (wxSizer *) 0 ;
39521 PyObject *arg2 = (PyObject *) 0 ;
39522 bool arg3 = (bool) true ;
39523 bool arg4 = (bool) false ;
39524 bool result;
39525 PyObject * obj0 = 0 ;
39526 PyObject * obj1 = 0 ;
39527 PyObject * obj2 = 0 ;
39528 PyObject * obj3 = 0 ;
39529 char *kwnames[] = {
39530 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39531 };
39532
39533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39535 if (SWIG_arg_fail(1)) SWIG_fail;
39536 arg2 = obj1;
39537 if (obj2) {
39538 {
39539 arg3 = (bool)(SWIG_As_bool(obj2));
39540 if (SWIG_arg_fail(3)) SWIG_fail;
39541 }
39542 }
39543 if (obj3) {
39544 {
39545 arg4 = (bool)(SWIG_As_bool(obj3));
39546 if (SWIG_arg_fail(4)) SWIG_fail;
39547 }
39548 }
39549 {
39550 PyThreadState* __tstate = wxPyBeginAllowThreads();
39551 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39552
39553 wxPyEndAllowThreads(__tstate);
39554 if (PyErr_Occurred()) SWIG_fail;
39555 }
39556 {
39557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39558 }
39559 return resultobj;
39560 fail:
39561 return NULL;
39562 }
39563
39564
39565 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39566 PyObject *resultobj;
39567 wxSizer *arg1 = (wxSizer *) 0 ;
39568 PyObject *arg2 = (PyObject *) 0 ;
39569 bool result;
39570 PyObject * obj0 = 0 ;
39571 PyObject * obj1 = 0 ;
39572 char *kwnames[] = {
39573 (char *) "self",(char *) "item", NULL
39574 };
39575
39576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39578 if (SWIG_arg_fail(1)) SWIG_fail;
39579 arg2 = obj1;
39580 {
39581 PyThreadState* __tstate = wxPyBeginAllowThreads();
39582 result = (bool)wxSizer_IsShown(arg1,arg2);
39583
39584 wxPyEndAllowThreads(__tstate);
39585 if (PyErr_Occurred()) SWIG_fail;
39586 }
39587 {
39588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39589 }
39590 return resultobj;
39591 fail:
39592 return NULL;
39593 }
39594
39595
39596 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39597 PyObject *resultobj;
39598 wxSizer *arg1 = (wxSizer *) 0 ;
39599 bool arg2 ;
39600 PyObject * obj0 = 0 ;
39601 PyObject * obj1 = 0 ;
39602 char *kwnames[] = {
39603 (char *) "self",(char *) "show", NULL
39604 };
39605
39606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39608 if (SWIG_arg_fail(1)) SWIG_fail;
39609 {
39610 arg2 = (bool)(SWIG_As_bool(obj1));
39611 if (SWIG_arg_fail(2)) SWIG_fail;
39612 }
39613 {
39614 PyThreadState* __tstate = wxPyBeginAllowThreads();
39615 (arg1)->ShowItems(arg2);
39616
39617 wxPyEndAllowThreads(__tstate);
39618 if (PyErr_Occurred()) SWIG_fail;
39619 }
39620 Py_INCREF(Py_None); resultobj = Py_None;
39621 return resultobj;
39622 fail:
39623 return NULL;
39624 }
39625
39626
39627 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39628 PyObject *obj;
39629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39630 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39631 Py_INCREF(obj);
39632 return Py_BuildValue((char *)"");
39633 }
39634 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39635 PyObject *resultobj;
39636 wxPySizer *result;
39637 char *kwnames[] = {
39638 NULL
39639 };
39640
39641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39642 {
39643 PyThreadState* __tstate = wxPyBeginAllowThreads();
39644 result = (wxPySizer *)new wxPySizer();
39645
39646 wxPyEndAllowThreads(__tstate);
39647 if (PyErr_Occurred()) SWIG_fail;
39648 }
39649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39650 return resultobj;
39651 fail:
39652 return NULL;
39653 }
39654
39655
39656 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39657 PyObject *resultobj;
39658 wxPySizer *arg1 = (wxPySizer *) 0 ;
39659 PyObject *arg2 = (PyObject *) 0 ;
39660 PyObject *arg3 = (PyObject *) 0 ;
39661 PyObject * obj0 = 0 ;
39662 PyObject * obj1 = 0 ;
39663 PyObject * obj2 = 0 ;
39664 char *kwnames[] = {
39665 (char *) "self",(char *) "self",(char *) "_class", NULL
39666 };
39667
39668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
39669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
39670 if (SWIG_arg_fail(1)) SWIG_fail;
39671 arg2 = obj1;
39672 arg3 = obj2;
39673 {
39674 PyThreadState* __tstate = wxPyBeginAllowThreads();
39675 (arg1)->_setCallbackInfo(arg2,arg3);
39676
39677 wxPyEndAllowThreads(__tstate);
39678 if (PyErr_Occurred()) SWIG_fail;
39679 }
39680 Py_INCREF(Py_None); resultobj = Py_None;
39681 return resultobj;
39682 fail:
39683 return NULL;
39684 }
39685
39686
39687 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
39688 PyObject *obj;
39689 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39690 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
39691 Py_INCREF(obj);
39692 return Py_BuildValue((char *)"");
39693 }
39694 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39695 PyObject *resultobj;
39696 int arg1 = (int) wxHORIZONTAL ;
39697 wxBoxSizer *result;
39698 PyObject * obj0 = 0 ;
39699 char *kwnames[] = {
39700 (char *) "orient", NULL
39701 };
39702
39703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
39704 if (obj0) {
39705 {
39706 arg1 = (int)(SWIG_As_int(obj0));
39707 if (SWIG_arg_fail(1)) SWIG_fail;
39708 }
39709 }
39710 {
39711 PyThreadState* __tstate = wxPyBeginAllowThreads();
39712 result = (wxBoxSizer *)new wxBoxSizer(arg1);
39713
39714 wxPyEndAllowThreads(__tstate);
39715 if (PyErr_Occurred()) SWIG_fail;
39716 }
39717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
39718 return resultobj;
39719 fail:
39720 return NULL;
39721 }
39722
39723
39724 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39725 PyObject *resultobj;
39726 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39727 int result;
39728 PyObject * obj0 = 0 ;
39729 char *kwnames[] = {
39730 (char *) "self", NULL
39731 };
39732
39733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
39734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39735 if (SWIG_arg_fail(1)) SWIG_fail;
39736 {
39737 PyThreadState* __tstate = wxPyBeginAllowThreads();
39738 result = (int)(arg1)->GetOrientation();
39739
39740 wxPyEndAllowThreads(__tstate);
39741 if (PyErr_Occurred()) SWIG_fail;
39742 }
39743 {
39744 resultobj = SWIG_From_int((int)(result));
39745 }
39746 return resultobj;
39747 fail:
39748 return NULL;
39749 }
39750
39751
39752 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39753 PyObject *resultobj;
39754 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39755 int arg2 ;
39756 PyObject * obj0 = 0 ;
39757 PyObject * obj1 = 0 ;
39758 char *kwnames[] = {
39759 (char *) "self",(char *) "orient", NULL
39760 };
39761
39762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
39763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39764 if (SWIG_arg_fail(1)) SWIG_fail;
39765 {
39766 arg2 = (int)(SWIG_As_int(obj1));
39767 if (SWIG_arg_fail(2)) SWIG_fail;
39768 }
39769 {
39770 PyThreadState* __tstate = wxPyBeginAllowThreads();
39771 (arg1)->SetOrientation(arg2);
39772
39773 wxPyEndAllowThreads(__tstate);
39774 if (PyErr_Occurred()) SWIG_fail;
39775 }
39776 Py_INCREF(Py_None); resultobj = Py_None;
39777 return resultobj;
39778 fail:
39779 return NULL;
39780 }
39781
39782
39783 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
39784 PyObject *obj;
39785 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39786 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
39787 Py_INCREF(obj);
39788 return Py_BuildValue((char *)"");
39789 }
39790 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39791 PyObject *resultobj;
39792 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
39793 int arg2 = (int) wxHORIZONTAL ;
39794 wxStaticBoxSizer *result;
39795 PyObject * obj0 = 0 ;
39796 PyObject * obj1 = 0 ;
39797 char *kwnames[] = {
39798 (char *) "box",(char *) "orient", NULL
39799 };
39800
39801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
39802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
39803 if (SWIG_arg_fail(1)) SWIG_fail;
39804 if (obj1) {
39805 {
39806 arg2 = (int)(SWIG_As_int(obj1));
39807 if (SWIG_arg_fail(2)) SWIG_fail;
39808 }
39809 }
39810 {
39811 PyThreadState* __tstate = wxPyBeginAllowThreads();
39812 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
39813
39814 wxPyEndAllowThreads(__tstate);
39815 if (PyErr_Occurred()) SWIG_fail;
39816 }
39817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
39818 return resultobj;
39819 fail:
39820 return NULL;
39821 }
39822
39823
39824 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
39825 PyObject *resultobj;
39826 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
39827 wxStaticBox *result;
39828 PyObject * obj0 = 0 ;
39829 char *kwnames[] = {
39830 (char *) "self", NULL
39831 };
39832
39833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
39834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39835 if (SWIG_arg_fail(1)) SWIG_fail;
39836 {
39837 PyThreadState* __tstate = wxPyBeginAllowThreads();
39838 result = (wxStaticBox *)(arg1)->GetStaticBox();
39839
39840 wxPyEndAllowThreads(__tstate);
39841 if (PyErr_Occurred()) SWIG_fail;
39842 }
39843 {
39844 resultobj = wxPyMake_wxObject(result, 0);
39845 }
39846 return resultobj;
39847 fail:
39848 return NULL;
39849 }
39850
39851
39852 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
39853 PyObject *obj;
39854 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39855 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
39856 Py_INCREF(obj);
39857 return Py_BuildValue((char *)"");
39858 }
39859 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39860 PyObject *resultobj;
39861 int arg1 = (int) 1 ;
39862 int arg2 = (int) 0 ;
39863 int arg3 = (int) 0 ;
39864 int arg4 = (int) 0 ;
39865 wxGridSizer *result;
39866 PyObject * obj0 = 0 ;
39867 PyObject * obj1 = 0 ;
39868 PyObject * obj2 = 0 ;
39869 PyObject * obj3 = 0 ;
39870 char *kwnames[] = {
39871 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39872 };
39873
39874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39875 if (obj0) {
39876 {
39877 arg1 = (int)(SWIG_As_int(obj0));
39878 if (SWIG_arg_fail(1)) SWIG_fail;
39879 }
39880 }
39881 if (obj1) {
39882 {
39883 arg2 = (int)(SWIG_As_int(obj1));
39884 if (SWIG_arg_fail(2)) SWIG_fail;
39885 }
39886 }
39887 if (obj2) {
39888 {
39889 arg3 = (int)(SWIG_As_int(obj2));
39890 if (SWIG_arg_fail(3)) SWIG_fail;
39891 }
39892 }
39893 if (obj3) {
39894 {
39895 arg4 = (int)(SWIG_As_int(obj3));
39896 if (SWIG_arg_fail(4)) SWIG_fail;
39897 }
39898 }
39899 {
39900 PyThreadState* __tstate = wxPyBeginAllowThreads();
39901 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
39902
39903 wxPyEndAllowThreads(__tstate);
39904 if (PyErr_Occurred()) SWIG_fail;
39905 }
39906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
39907 return resultobj;
39908 fail:
39909 return NULL;
39910 }
39911
39912
39913 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39914 PyObject *resultobj;
39915 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39916 int arg2 ;
39917 PyObject * obj0 = 0 ;
39918 PyObject * obj1 = 0 ;
39919 char *kwnames[] = {
39920 (char *) "self",(char *) "cols", NULL
39921 };
39922
39923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
39924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39925 if (SWIG_arg_fail(1)) SWIG_fail;
39926 {
39927 arg2 = (int)(SWIG_As_int(obj1));
39928 if (SWIG_arg_fail(2)) SWIG_fail;
39929 }
39930 {
39931 PyThreadState* __tstate = wxPyBeginAllowThreads();
39932 (arg1)->SetCols(arg2);
39933
39934 wxPyEndAllowThreads(__tstate);
39935 if (PyErr_Occurred()) SWIG_fail;
39936 }
39937 Py_INCREF(Py_None); resultobj = Py_None;
39938 return resultobj;
39939 fail:
39940 return NULL;
39941 }
39942
39943
39944 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39945 PyObject *resultobj;
39946 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39947 int arg2 ;
39948 PyObject * obj0 = 0 ;
39949 PyObject * obj1 = 0 ;
39950 char *kwnames[] = {
39951 (char *) "self",(char *) "rows", NULL
39952 };
39953
39954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
39955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39956 if (SWIG_arg_fail(1)) SWIG_fail;
39957 {
39958 arg2 = (int)(SWIG_As_int(obj1));
39959 if (SWIG_arg_fail(2)) SWIG_fail;
39960 }
39961 {
39962 PyThreadState* __tstate = wxPyBeginAllowThreads();
39963 (arg1)->SetRows(arg2);
39964
39965 wxPyEndAllowThreads(__tstate);
39966 if (PyErr_Occurred()) SWIG_fail;
39967 }
39968 Py_INCREF(Py_None); resultobj = Py_None;
39969 return resultobj;
39970 fail:
39971 return NULL;
39972 }
39973
39974
39975 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39976 PyObject *resultobj;
39977 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39978 int arg2 ;
39979 PyObject * obj0 = 0 ;
39980 PyObject * obj1 = 0 ;
39981 char *kwnames[] = {
39982 (char *) "self",(char *) "gap", NULL
39983 };
39984
39985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
39986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39987 if (SWIG_arg_fail(1)) SWIG_fail;
39988 {
39989 arg2 = (int)(SWIG_As_int(obj1));
39990 if (SWIG_arg_fail(2)) SWIG_fail;
39991 }
39992 {
39993 PyThreadState* __tstate = wxPyBeginAllowThreads();
39994 (arg1)->SetVGap(arg2);
39995
39996 wxPyEndAllowThreads(__tstate);
39997 if (PyErr_Occurred()) SWIG_fail;
39998 }
39999 Py_INCREF(Py_None); resultobj = Py_None;
40000 return resultobj;
40001 fail:
40002 return NULL;
40003 }
40004
40005
40006 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40007 PyObject *resultobj;
40008 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40009 int arg2 ;
40010 PyObject * obj0 = 0 ;
40011 PyObject * obj1 = 0 ;
40012 char *kwnames[] = {
40013 (char *) "self",(char *) "gap", NULL
40014 };
40015
40016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40018 if (SWIG_arg_fail(1)) SWIG_fail;
40019 {
40020 arg2 = (int)(SWIG_As_int(obj1));
40021 if (SWIG_arg_fail(2)) SWIG_fail;
40022 }
40023 {
40024 PyThreadState* __tstate = wxPyBeginAllowThreads();
40025 (arg1)->SetHGap(arg2);
40026
40027 wxPyEndAllowThreads(__tstate);
40028 if (PyErr_Occurred()) SWIG_fail;
40029 }
40030 Py_INCREF(Py_None); resultobj = Py_None;
40031 return resultobj;
40032 fail:
40033 return NULL;
40034 }
40035
40036
40037 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40038 PyObject *resultobj;
40039 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40040 int result;
40041 PyObject * obj0 = 0 ;
40042 char *kwnames[] = {
40043 (char *) "self", NULL
40044 };
40045
40046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40048 if (SWIG_arg_fail(1)) SWIG_fail;
40049 {
40050 PyThreadState* __tstate = wxPyBeginAllowThreads();
40051 result = (int)(arg1)->GetCols();
40052
40053 wxPyEndAllowThreads(__tstate);
40054 if (PyErr_Occurred()) SWIG_fail;
40055 }
40056 {
40057 resultobj = SWIG_From_int((int)(result));
40058 }
40059 return resultobj;
40060 fail:
40061 return NULL;
40062 }
40063
40064
40065 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40066 PyObject *resultobj;
40067 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40068 int result;
40069 PyObject * obj0 = 0 ;
40070 char *kwnames[] = {
40071 (char *) "self", NULL
40072 };
40073
40074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40076 if (SWIG_arg_fail(1)) SWIG_fail;
40077 {
40078 PyThreadState* __tstate = wxPyBeginAllowThreads();
40079 result = (int)(arg1)->GetRows();
40080
40081 wxPyEndAllowThreads(__tstate);
40082 if (PyErr_Occurred()) SWIG_fail;
40083 }
40084 {
40085 resultobj = SWIG_From_int((int)(result));
40086 }
40087 return resultobj;
40088 fail:
40089 return NULL;
40090 }
40091
40092
40093 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40094 PyObject *resultobj;
40095 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40096 int result;
40097 PyObject * obj0 = 0 ;
40098 char *kwnames[] = {
40099 (char *) "self", NULL
40100 };
40101
40102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40104 if (SWIG_arg_fail(1)) SWIG_fail;
40105 {
40106 PyThreadState* __tstate = wxPyBeginAllowThreads();
40107 result = (int)(arg1)->GetVGap();
40108
40109 wxPyEndAllowThreads(__tstate);
40110 if (PyErr_Occurred()) SWIG_fail;
40111 }
40112 {
40113 resultobj = SWIG_From_int((int)(result));
40114 }
40115 return resultobj;
40116 fail:
40117 return NULL;
40118 }
40119
40120
40121 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40122 PyObject *resultobj;
40123 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40124 int result;
40125 PyObject * obj0 = 0 ;
40126 char *kwnames[] = {
40127 (char *) "self", NULL
40128 };
40129
40130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40132 if (SWIG_arg_fail(1)) SWIG_fail;
40133 {
40134 PyThreadState* __tstate = wxPyBeginAllowThreads();
40135 result = (int)(arg1)->GetHGap();
40136
40137 wxPyEndAllowThreads(__tstate);
40138 if (PyErr_Occurred()) SWIG_fail;
40139 }
40140 {
40141 resultobj = SWIG_From_int((int)(result));
40142 }
40143 return resultobj;
40144 fail:
40145 return NULL;
40146 }
40147
40148
40149 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40150 PyObject *obj;
40151 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40152 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40153 Py_INCREF(obj);
40154 return Py_BuildValue((char *)"");
40155 }
40156 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40157 PyObject *resultobj;
40158 int arg1 = (int) 1 ;
40159 int arg2 = (int) 0 ;
40160 int arg3 = (int) 0 ;
40161 int arg4 = (int) 0 ;
40162 wxFlexGridSizer *result;
40163 PyObject * obj0 = 0 ;
40164 PyObject * obj1 = 0 ;
40165 PyObject * obj2 = 0 ;
40166 PyObject * obj3 = 0 ;
40167 char *kwnames[] = {
40168 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40169 };
40170
40171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40172 if (obj0) {
40173 {
40174 arg1 = (int)(SWIG_As_int(obj0));
40175 if (SWIG_arg_fail(1)) SWIG_fail;
40176 }
40177 }
40178 if (obj1) {
40179 {
40180 arg2 = (int)(SWIG_As_int(obj1));
40181 if (SWIG_arg_fail(2)) SWIG_fail;
40182 }
40183 }
40184 if (obj2) {
40185 {
40186 arg3 = (int)(SWIG_As_int(obj2));
40187 if (SWIG_arg_fail(3)) SWIG_fail;
40188 }
40189 }
40190 if (obj3) {
40191 {
40192 arg4 = (int)(SWIG_As_int(obj3));
40193 if (SWIG_arg_fail(4)) SWIG_fail;
40194 }
40195 }
40196 {
40197 PyThreadState* __tstate = wxPyBeginAllowThreads();
40198 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40199
40200 wxPyEndAllowThreads(__tstate);
40201 if (PyErr_Occurred()) SWIG_fail;
40202 }
40203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40204 return resultobj;
40205 fail:
40206 return NULL;
40207 }
40208
40209
40210 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40211 PyObject *resultobj;
40212 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40213 size_t arg2 ;
40214 int arg3 = (int) 0 ;
40215 PyObject * obj0 = 0 ;
40216 PyObject * obj1 = 0 ;
40217 PyObject * obj2 = 0 ;
40218 char *kwnames[] = {
40219 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40220 };
40221
40222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40224 if (SWIG_arg_fail(1)) SWIG_fail;
40225 {
40226 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40227 if (SWIG_arg_fail(2)) SWIG_fail;
40228 }
40229 if (obj2) {
40230 {
40231 arg3 = (int)(SWIG_As_int(obj2));
40232 if (SWIG_arg_fail(3)) SWIG_fail;
40233 }
40234 }
40235 {
40236 PyThreadState* __tstate = wxPyBeginAllowThreads();
40237 (arg1)->AddGrowableRow(arg2,arg3);
40238
40239 wxPyEndAllowThreads(__tstate);
40240 if (PyErr_Occurred()) SWIG_fail;
40241 }
40242 Py_INCREF(Py_None); resultobj = Py_None;
40243 return resultobj;
40244 fail:
40245 return NULL;
40246 }
40247
40248
40249 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40250 PyObject *resultobj;
40251 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40252 size_t arg2 ;
40253 PyObject * obj0 = 0 ;
40254 PyObject * obj1 = 0 ;
40255 char *kwnames[] = {
40256 (char *) "self",(char *) "idx", NULL
40257 };
40258
40259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40261 if (SWIG_arg_fail(1)) SWIG_fail;
40262 {
40263 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40264 if (SWIG_arg_fail(2)) SWIG_fail;
40265 }
40266 {
40267 PyThreadState* __tstate = wxPyBeginAllowThreads();
40268 (arg1)->RemoveGrowableRow(arg2);
40269
40270 wxPyEndAllowThreads(__tstate);
40271 if (PyErr_Occurred()) SWIG_fail;
40272 }
40273 Py_INCREF(Py_None); resultobj = Py_None;
40274 return resultobj;
40275 fail:
40276 return NULL;
40277 }
40278
40279
40280 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40281 PyObject *resultobj;
40282 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40283 size_t arg2 ;
40284 int arg3 = (int) 0 ;
40285 PyObject * obj0 = 0 ;
40286 PyObject * obj1 = 0 ;
40287 PyObject * obj2 = 0 ;
40288 char *kwnames[] = {
40289 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40290 };
40291
40292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40294 if (SWIG_arg_fail(1)) SWIG_fail;
40295 {
40296 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40297 if (SWIG_arg_fail(2)) SWIG_fail;
40298 }
40299 if (obj2) {
40300 {
40301 arg3 = (int)(SWIG_As_int(obj2));
40302 if (SWIG_arg_fail(3)) SWIG_fail;
40303 }
40304 }
40305 {
40306 PyThreadState* __tstate = wxPyBeginAllowThreads();
40307 (arg1)->AddGrowableCol(arg2,arg3);
40308
40309 wxPyEndAllowThreads(__tstate);
40310 if (PyErr_Occurred()) SWIG_fail;
40311 }
40312 Py_INCREF(Py_None); resultobj = Py_None;
40313 return resultobj;
40314 fail:
40315 return NULL;
40316 }
40317
40318
40319 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40320 PyObject *resultobj;
40321 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40322 size_t arg2 ;
40323 PyObject * obj0 = 0 ;
40324 PyObject * obj1 = 0 ;
40325 char *kwnames[] = {
40326 (char *) "self",(char *) "idx", NULL
40327 };
40328
40329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40331 if (SWIG_arg_fail(1)) SWIG_fail;
40332 {
40333 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40334 if (SWIG_arg_fail(2)) SWIG_fail;
40335 }
40336 {
40337 PyThreadState* __tstate = wxPyBeginAllowThreads();
40338 (arg1)->RemoveGrowableCol(arg2);
40339
40340 wxPyEndAllowThreads(__tstate);
40341 if (PyErr_Occurred()) SWIG_fail;
40342 }
40343 Py_INCREF(Py_None); resultobj = Py_None;
40344 return resultobj;
40345 fail:
40346 return NULL;
40347 }
40348
40349
40350 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40351 PyObject *resultobj;
40352 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40353 int arg2 ;
40354 PyObject * obj0 = 0 ;
40355 PyObject * obj1 = 0 ;
40356 char *kwnames[] = {
40357 (char *) "self",(char *) "direction", NULL
40358 };
40359
40360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40362 if (SWIG_arg_fail(1)) SWIG_fail;
40363 {
40364 arg2 = (int)(SWIG_As_int(obj1));
40365 if (SWIG_arg_fail(2)) SWIG_fail;
40366 }
40367 {
40368 PyThreadState* __tstate = wxPyBeginAllowThreads();
40369 (arg1)->SetFlexibleDirection(arg2);
40370
40371 wxPyEndAllowThreads(__tstate);
40372 if (PyErr_Occurred()) SWIG_fail;
40373 }
40374 Py_INCREF(Py_None); resultobj = Py_None;
40375 return resultobj;
40376 fail:
40377 return NULL;
40378 }
40379
40380
40381 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40382 PyObject *resultobj;
40383 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40384 int result;
40385 PyObject * obj0 = 0 ;
40386 char *kwnames[] = {
40387 (char *) "self", NULL
40388 };
40389
40390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40392 if (SWIG_arg_fail(1)) SWIG_fail;
40393 {
40394 PyThreadState* __tstate = wxPyBeginAllowThreads();
40395 result = (int)(arg1)->GetFlexibleDirection();
40396
40397 wxPyEndAllowThreads(__tstate);
40398 if (PyErr_Occurred()) SWIG_fail;
40399 }
40400 {
40401 resultobj = SWIG_From_int((int)(result));
40402 }
40403 return resultobj;
40404 fail:
40405 return NULL;
40406 }
40407
40408
40409 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40410 PyObject *resultobj;
40411 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40412 wxFlexSizerGrowMode arg2 ;
40413 PyObject * obj0 = 0 ;
40414 PyObject * obj1 = 0 ;
40415 char *kwnames[] = {
40416 (char *) "self",(char *) "mode", NULL
40417 };
40418
40419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40421 if (SWIG_arg_fail(1)) SWIG_fail;
40422 {
40423 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40424 if (SWIG_arg_fail(2)) SWIG_fail;
40425 }
40426 {
40427 PyThreadState* __tstate = wxPyBeginAllowThreads();
40428 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40429
40430 wxPyEndAllowThreads(__tstate);
40431 if (PyErr_Occurred()) SWIG_fail;
40432 }
40433 Py_INCREF(Py_None); resultobj = Py_None;
40434 return resultobj;
40435 fail:
40436 return NULL;
40437 }
40438
40439
40440 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40441 PyObject *resultobj;
40442 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40443 wxFlexSizerGrowMode result;
40444 PyObject * obj0 = 0 ;
40445 char *kwnames[] = {
40446 (char *) "self", NULL
40447 };
40448
40449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40451 if (SWIG_arg_fail(1)) SWIG_fail;
40452 {
40453 PyThreadState* __tstate = wxPyBeginAllowThreads();
40454 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40455
40456 wxPyEndAllowThreads(__tstate);
40457 if (PyErr_Occurred()) SWIG_fail;
40458 }
40459 resultobj = SWIG_From_int((result));
40460 return resultobj;
40461 fail:
40462 return NULL;
40463 }
40464
40465
40466 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40467 PyObject *resultobj;
40468 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40469 wxArrayInt *result;
40470 PyObject * obj0 = 0 ;
40471 char *kwnames[] = {
40472 (char *) "self", NULL
40473 };
40474
40475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40477 if (SWIG_arg_fail(1)) SWIG_fail;
40478 {
40479 PyThreadState* __tstate = wxPyBeginAllowThreads();
40480 {
40481 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40482 result = (wxArrayInt *) &_result_ref;
40483 }
40484
40485 wxPyEndAllowThreads(__tstate);
40486 if (PyErr_Occurred()) SWIG_fail;
40487 }
40488 {
40489 resultobj = PyList_New(0);
40490 size_t idx;
40491 for (idx = 0; idx < result->GetCount(); idx += 1) {
40492 PyObject* val = PyInt_FromLong( result->Item(idx) );
40493 PyList_Append(resultobj, val);
40494 Py_DECREF(val);
40495 }
40496 }
40497 return resultobj;
40498 fail:
40499 return NULL;
40500 }
40501
40502
40503 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40504 PyObject *resultobj;
40505 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40506 wxArrayInt *result;
40507 PyObject * obj0 = 0 ;
40508 char *kwnames[] = {
40509 (char *) "self", NULL
40510 };
40511
40512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40514 if (SWIG_arg_fail(1)) SWIG_fail;
40515 {
40516 PyThreadState* __tstate = wxPyBeginAllowThreads();
40517 {
40518 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40519 result = (wxArrayInt *) &_result_ref;
40520 }
40521
40522 wxPyEndAllowThreads(__tstate);
40523 if (PyErr_Occurred()) SWIG_fail;
40524 }
40525 {
40526 resultobj = PyList_New(0);
40527 size_t idx;
40528 for (idx = 0; idx < result->GetCount(); idx += 1) {
40529 PyObject* val = PyInt_FromLong( result->Item(idx) );
40530 PyList_Append(resultobj, val);
40531 Py_DECREF(val);
40532 }
40533 }
40534 return resultobj;
40535 fail:
40536 return NULL;
40537 }
40538
40539
40540 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40541 PyObject *obj;
40542 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40543 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40544 Py_INCREF(obj);
40545 return Py_BuildValue((char *)"");
40546 }
40547 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40548 PyObject *resultobj;
40549 int arg1 = (int) 0 ;
40550 int arg2 = (int) 0 ;
40551 wxGBPosition *result;
40552 PyObject * obj0 = 0 ;
40553 PyObject * obj1 = 0 ;
40554 char *kwnames[] = {
40555 (char *) "row",(char *) "col", NULL
40556 };
40557
40558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
40559 if (obj0) {
40560 {
40561 arg1 = (int)(SWIG_As_int(obj0));
40562 if (SWIG_arg_fail(1)) SWIG_fail;
40563 }
40564 }
40565 if (obj1) {
40566 {
40567 arg2 = (int)(SWIG_As_int(obj1));
40568 if (SWIG_arg_fail(2)) SWIG_fail;
40569 }
40570 }
40571 {
40572 PyThreadState* __tstate = wxPyBeginAllowThreads();
40573 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
40574
40575 wxPyEndAllowThreads(__tstate);
40576 if (PyErr_Occurred()) SWIG_fail;
40577 }
40578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
40579 return resultobj;
40580 fail:
40581 return NULL;
40582 }
40583
40584
40585 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40586 PyObject *resultobj;
40587 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40588 int result;
40589 PyObject * obj0 = 0 ;
40590 char *kwnames[] = {
40591 (char *) "self", NULL
40592 };
40593
40594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
40595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40596 if (SWIG_arg_fail(1)) SWIG_fail;
40597 {
40598 PyThreadState* __tstate = wxPyBeginAllowThreads();
40599 result = (int)((wxGBPosition const *)arg1)->GetRow();
40600
40601 wxPyEndAllowThreads(__tstate);
40602 if (PyErr_Occurred()) SWIG_fail;
40603 }
40604 {
40605 resultobj = SWIG_From_int((int)(result));
40606 }
40607 return resultobj;
40608 fail:
40609 return NULL;
40610 }
40611
40612
40613 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40614 PyObject *resultobj;
40615 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40616 int result;
40617 PyObject * obj0 = 0 ;
40618 char *kwnames[] = {
40619 (char *) "self", NULL
40620 };
40621
40622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
40623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40624 if (SWIG_arg_fail(1)) SWIG_fail;
40625 {
40626 PyThreadState* __tstate = wxPyBeginAllowThreads();
40627 result = (int)((wxGBPosition const *)arg1)->GetCol();
40628
40629 wxPyEndAllowThreads(__tstate);
40630 if (PyErr_Occurred()) SWIG_fail;
40631 }
40632 {
40633 resultobj = SWIG_From_int((int)(result));
40634 }
40635 return resultobj;
40636 fail:
40637 return NULL;
40638 }
40639
40640
40641 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40642 PyObject *resultobj;
40643 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40644 int arg2 ;
40645 PyObject * obj0 = 0 ;
40646 PyObject * obj1 = 0 ;
40647 char *kwnames[] = {
40648 (char *) "self",(char *) "row", NULL
40649 };
40650
40651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
40652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40653 if (SWIG_arg_fail(1)) SWIG_fail;
40654 {
40655 arg2 = (int)(SWIG_As_int(obj1));
40656 if (SWIG_arg_fail(2)) SWIG_fail;
40657 }
40658 {
40659 PyThreadState* __tstate = wxPyBeginAllowThreads();
40660 (arg1)->SetRow(arg2);
40661
40662 wxPyEndAllowThreads(__tstate);
40663 if (PyErr_Occurred()) SWIG_fail;
40664 }
40665 Py_INCREF(Py_None); resultobj = Py_None;
40666 return resultobj;
40667 fail:
40668 return NULL;
40669 }
40670
40671
40672 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40673 PyObject *resultobj;
40674 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40675 int arg2 ;
40676 PyObject * obj0 = 0 ;
40677 PyObject * obj1 = 0 ;
40678 char *kwnames[] = {
40679 (char *) "self",(char *) "col", NULL
40680 };
40681
40682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
40683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40684 if (SWIG_arg_fail(1)) SWIG_fail;
40685 {
40686 arg2 = (int)(SWIG_As_int(obj1));
40687 if (SWIG_arg_fail(2)) SWIG_fail;
40688 }
40689 {
40690 PyThreadState* __tstate = wxPyBeginAllowThreads();
40691 (arg1)->SetCol(arg2);
40692
40693 wxPyEndAllowThreads(__tstate);
40694 if (PyErr_Occurred()) SWIG_fail;
40695 }
40696 Py_INCREF(Py_None); resultobj = Py_None;
40697 return resultobj;
40698 fail:
40699 return NULL;
40700 }
40701
40702
40703 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40704 PyObject *resultobj;
40705 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40706 wxGBPosition *arg2 = 0 ;
40707 bool result;
40708 wxGBPosition temp2 ;
40709 PyObject * obj0 = 0 ;
40710 PyObject * obj1 = 0 ;
40711 char *kwnames[] = {
40712 (char *) "self",(char *) "other", NULL
40713 };
40714
40715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
40716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40717 if (SWIG_arg_fail(1)) SWIG_fail;
40718 {
40719 arg2 = &temp2;
40720 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40721 }
40722 {
40723 PyThreadState* __tstate = wxPyBeginAllowThreads();
40724 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
40725
40726 wxPyEndAllowThreads(__tstate);
40727 if (PyErr_Occurred()) SWIG_fail;
40728 }
40729 {
40730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40731 }
40732 return resultobj;
40733 fail:
40734 return NULL;
40735 }
40736
40737
40738 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40739 PyObject *resultobj;
40740 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40741 wxGBPosition *arg2 = 0 ;
40742 bool result;
40743 wxGBPosition temp2 ;
40744 PyObject * obj0 = 0 ;
40745 PyObject * obj1 = 0 ;
40746 char *kwnames[] = {
40747 (char *) "self",(char *) "other", NULL
40748 };
40749
40750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
40751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40752 if (SWIG_arg_fail(1)) SWIG_fail;
40753 {
40754 arg2 = &temp2;
40755 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40756 }
40757 {
40758 PyThreadState* __tstate = wxPyBeginAllowThreads();
40759 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
40760
40761 wxPyEndAllowThreads(__tstate);
40762 if (PyErr_Occurred()) SWIG_fail;
40763 }
40764 {
40765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40766 }
40767 return resultobj;
40768 fail:
40769 return NULL;
40770 }
40771
40772
40773 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40774 PyObject *resultobj;
40775 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40776 int arg2 = (int) 0 ;
40777 int arg3 = (int) 0 ;
40778 PyObject * obj0 = 0 ;
40779 PyObject * obj1 = 0 ;
40780 PyObject * obj2 = 0 ;
40781 char *kwnames[] = {
40782 (char *) "self",(char *) "row",(char *) "col", NULL
40783 };
40784
40785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40787 if (SWIG_arg_fail(1)) SWIG_fail;
40788 if (obj1) {
40789 {
40790 arg2 = (int)(SWIG_As_int(obj1));
40791 if (SWIG_arg_fail(2)) SWIG_fail;
40792 }
40793 }
40794 if (obj2) {
40795 {
40796 arg3 = (int)(SWIG_As_int(obj2));
40797 if (SWIG_arg_fail(3)) SWIG_fail;
40798 }
40799 }
40800 {
40801 PyThreadState* __tstate = wxPyBeginAllowThreads();
40802 wxGBPosition_Set(arg1,arg2,arg3);
40803
40804 wxPyEndAllowThreads(__tstate);
40805 if (PyErr_Occurred()) SWIG_fail;
40806 }
40807 Py_INCREF(Py_None); resultobj = Py_None;
40808 return resultobj;
40809 fail:
40810 return NULL;
40811 }
40812
40813
40814 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40815 PyObject *resultobj;
40816 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40817 PyObject *result;
40818 PyObject * obj0 = 0 ;
40819 char *kwnames[] = {
40820 (char *) "self", NULL
40821 };
40822
40823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
40824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40825 if (SWIG_arg_fail(1)) SWIG_fail;
40826 {
40827 PyThreadState* __tstate = wxPyBeginAllowThreads();
40828 result = (PyObject *)wxGBPosition_Get(arg1);
40829
40830 wxPyEndAllowThreads(__tstate);
40831 if (PyErr_Occurred()) SWIG_fail;
40832 }
40833 resultobj = result;
40834 return resultobj;
40835 fail:
40836 return NULL;
40837 }
40838
40839
40840 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
40841 PyObject *obj;
40842 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40843 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
40844 Py_INCREF(obj);
40845 return Py_BuildValue((char *)"");
40846 }
40847 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
40848 PyObject *resultobj;
40849 int arg1 = (int) 1 ;
40850 int arg2 = (int) 1 ;
40851 wxGBSpan *result;
40852 PyObject * obj0 = 0 ;
40853 PyObject * obj1 = 0 ;
40854 char *kwnames[] = {
40855 (char *) "rowspan",(char *) "colspan", NULL
40856 };
40857
40858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
40859 if (obj0) {
40860 {
40861 arg1 = (int)(SWIG_As_int(obj0));
40862 if (SWIG_arg_fail(1)) SWIG_fail;
40863 }
40864 }
40865 if (obj1) {
40866 {
40867 arg2 = (int)(SWIG_As_int(obj1));
40868 if (SWIG_arg_fail(2)) SWIG_fail;
40869 }
40870 }
40871 {
40872 PyThreadState* __tstate = wxPyBeginAllowThreads();
40873 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
40874
40875 wxPyEndAllowThreads(__tstate);
40876 if (PyErr_Occurred()) SWIG_fail;
40877 }
40878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
40879 return resultobj;
40880 fail:
40881 return NULL;
40882 }
40883
40884
40885 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40886 PyObject *resultobj;
40887 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40888 int result;
40889 PyObject * obj0 = 0 ;
40890 char *kwnames[] = {
40891 (char *) "self", NULL
40892 };
40893
40894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
40895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40896 if (SWIG_arg_fail(1)) SWIG_fail;
40897 {
40898 PyThreadState* __tstate = wxPyBeginAllowThreads();
40899 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
40900
40901 wxPyEndAllowThreads(__tstate);
40902 if (PyErr_Occurred()) SWIG_fail;
40903 }
40904 {
40905 resultobj = SWIG_From_int((int)(result));
40906 }
40907 return resultobj;
40908 fail:
40909 return NULL;
40910 }
40911
40912
40913 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40914 PyObject *resultobj;
40915 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40916 int result;
40917 PyObject * obj0 = 0 ;
40918 char *kwnames[] = {
40919 (char *) "self", NULL
40920 };
40921
40922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
40923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40924 if (SWIG_arg_fail(1)) SWIG_fail;
40925 {
40926 PyThreadState* __tstate = wxPyBeginAllowThreads();
40927 result = (int)((wxGBSpan const *)arg1)->GetColspan();
40928
40929 wxPyEndAllowThreads(__tstate);
40930 if (PyErr_Occurred()) SWIG_fail;
40931 }
40932 {
40933 resultobj = SWIG_From_int((int)(result));
40934 }
40935 return resultobj;
40936 fail:
40937 return NULL;
40938 }
40939
40940
40941 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40942 PyObject *resultobj;
40943 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40944 int arg2 ;
40945 PyObject * obj0 = 0 ;
40946 PyObject * obj1 = 0 ;
40947 char *kwnames[] = {
40948 (char *) "self",(char *) "rowspan", NULL
40949 };
40950
40951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
40952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40953 if (SWIG_arg_fail(1)) SWIG_fail;
40954 {
40955 arg2 = (int)(SWIG_As_int(obj1));
40956 if (SWIG_arg_fail(2)) SWIG_fail;
40957 }
40958 {
40959 PyThreadState* __tstate = wxPyBeginAllowThreads();
40960 (arg1)->SetRowspan(arg2);
40961
40962 wxPyEndAllowThreads(__tstate);
40963 if (PyErr_Occurred()) SWIG_fail;
40964 }
40965 Py_INCREF(Py_None); resultobj = Py_None;
40966 return resultobj;
40967 fail:
40968 return NULL;
40969 }
40970
40971
40972 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40973 PyObject *resultobj;
40974 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40975 int arg2 ;
40976 PyObject * obj0 = 0 ;
40977 PyObject * obj1 = 0 ;
40978 char *kwnames[] = {
40979 (char *) "self",(char *) "colspan", NULL
40980 };
40981
40982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
40983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40984 if (SWIG_arg_fail(1)) SWIG_fail;
40985 {
40986 arg2 = (int)(SWIG_As_int(obj1));
40987 if (SWIG_arg_fail(2)) SWIG_fail;
40988 }
40989 {
40990 PyThreadState* __tstate = wxPyBeginAllowThreads();
40991 (arg1)->SetColspan(arg2);
40992
40993 wxPyEndAllowThreads(__tstate);
40994 if (PyErr_Occurred()) SWIG_fail;
40995 }
40996 Py_INCREF(Py_None); resultobj = Py_None;
40997 return resultobj;
40998 fail:
40999 return NULL;
41000 }
41001
41002
41003 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41004 PyObject *resultobj;
41005 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41006 wxGBSpan *arg2 = 0 ;
41007 bool result;
41008 wxGBSpan temp2 ;
41009 PyObject * obj0 = 0 ;
41010 PyObject * obj1 = 0 ;
41011 char *kwnames[] = {
41012 (char *) "self",(char *) "other", NULL
41013 };
41014
41015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41017 if (SWIG_arg_fail(1)) SWIG_fail;
41018 {
41019 arg2 = &temp2;
41020 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41021 }
41022 {
41023 PyThreadState* __tstate = wxPyBeginAllowThreads();
41024 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41025
41026 wxPyEndAllowThreads(__tstate);
41027 if (PyErr_Occurred()) SWIG_fail;
41028 }
41029 {
41030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41031 }
41032 return resultobj;
41033 fail:
41034 return NULL;
41035 }
41036
41037
41038 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41039 PyObject *resultobj;
41040 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41041 wxGBSpan *arg2 = 0 ;
41042 bool result;
41043 wxGBSpan temp2 ;
41044 PyObject * obj0 = 0 ;
41045 PyObject * obj1 = 0 ;
41046 char *kwnames[] = {
41047 (char *) "self",(char *) "other", NULL
41048 };
41049
41050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41052 if (SWIG_arg_fail(1)) SWIG_fail;
41053 {
41054 arg2 = &temp2;
41055 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41056 }
41057 {
41058 PyThreadState* __tstate = wxPyBeginAllowThreads();
41059 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41060
41061 wxPyEndAllowThreads(__tstate);
41062 if (PyErr_Occurred()) SWIG_fail;
41063 }
41064 {
41065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41066 }
41067 return resultobj;
41068 fail:
41069 return NULL;
41070 }
41071
41072
41073 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41074 PyObject *resultobj;
41075 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41076 int arg2 = (int) 1 ;
41077 int arg3 = (int) 1 ;
41078 PyObject * obj0 = 0 ;
41079 PyObject * obj1 = 0 ;
41080 PyObject * obj2 = 0 ;
41081 char *kwnames[] = {
41082 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41083 };
41084
41085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41087 if (SWIG_arg_fail(1)) SWIG_fail;
41088 if (obj1) {
41089 {
41090 arg2 = (int)(SWIG_As_int(obj1));
41091 if (SWIG_arg_fail(2)) SWIG_fail;
41092 }
41093 }
41094 if (obj2) {
41095 {
41096 arg3 = (int)(SWIG_As_int(obj2));
41097 if (SWIG_arg_fail(3)) SWIG_fail;
41098 }
41099 }
41100 {
41101 PyThreadState* __tstate = wxPyBeginAllowThreads();
41102 wxGBSpan_Set(arg1,arg2,arg3);
41103
41104 wxPyEndAllowThreads(__tstate);
41105 if (PyErr_Occurred()) SWIG_fail;
41106 }
41107 Py_INCREF(Py_None); resultobj = Py_None;
41108 return resultobj;
41109 fail:
41110 return NULL;
41111 }
41112
41113
41114 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41115 PyObject *resultobj;
41116 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41117 PyObject *result;
41118 PyObject * obj0 = 0 ;
41119 char *kwnames[] = {
41120 (char *) "self", NULL
41121 };
41122
41123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41125 if (SWIG_arg_fail(1)) SWIG_fail;
41126 {
41127 PyThreadState* __tstate = wxPyBeginAllowThreads();
41128 result = (PyObject *)wxGBSpan_Get(arg1);
41129
41130 wxPyEndAllowThreads(__tstate);
41131 if (PyErr_Occurred()) SWIG_fail;
41132 }
41133 resultobj = result;
41134 return resultobj;
41135 fail:
41136 return NULL;
41137 }
41138
41139
41140 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41141 PyObject *obj;
41142 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41143 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41144 Py_INCREF(obj);
41145 return Py_BuildValue((char *)"");
41146 }
41147 static int _wrap_DefaultSpan_set(PyObject *) {
41148 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41149 return 1;
41150 }
41151
41152
41153 static PyObject *_wrap_DefaultSpan_get(void) {
41154 PyObject *pyobj;
41155
41156 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41157 return pyobj;
41158 }
41159
41160
41161 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41162 PyObject *resultobj;
41163 wxGBSizerItem *result;
41164 char *kwnames[] = {
41165 NULL
41166 };
41167
41168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41169 {
41170 PyThreadState* __tstate = wxPyBeginAllowThreads();
41171 result = (wxGBSizerItem *)new wxGBSizerItem();
41172
41173 wxPyEndAllowThreads(__tstate);
41174 if (PyErr_Occurred()) SWIG_fail;
41175 }
41176 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41177 return resultobj;
41178 fail:
41179 return NULL;
41180 }
41181
41182
41183 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41184 PyObject *resultobj;
41185 wxWindow *arg1 = (wxWindow *) 0 ;
41186 wxGBPosition *arg2 = 0 ;
41187 wxGBSpan *arg3 = 0 ;
41188 int arg4 ;
41189 int arg5 ;
41190 PyObject *arg6 = (PyObject *) NULL ;
41191 wxGBSizerItem *result;
41192 wxGBPosition temp2 ;
41193 wxGBSpan temp3 ;
41194 PyObject * obj0 = 0 ;
41195 PyObject * obj1 = 0 ;
41196 PyObject * obj2 = 0 ;
41197 PyObject * obj3 = 0 ;
41198 PyObject * obj4 = 0 ;
41199 PyObject * obj5 = 0 ;
41200 char *kwnames[] = {
41201 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41202 };
41203
41204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41206 if (SWIG_arg_fail(1)) SWIG_fail;
41207 {
41208 arg2 = &temp2;
41209 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41210 }
41211 {
41212 arg3 = &temp3;
41213 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41214 }
41215 {
41216 arg4 = (int)(SWIG_As_int(obj3));
41217 if (SWIG_arg_fail(4)) SWIG_fail;
41218 }
41219 {
41220 arg5 = (int)(SWIG_As_int(obj4));
41221 if (SWIG_arg_fail(5)) SWIG_fail;
41222 }
41223 if (obj5) {
41224 arg6 = obj5;
41225 }
41226 {
41227 PyThreadState* __tstate = wxPyBeginAllowThreads();
41228 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41229
41230 wxPyEndAllowThreads(__tstate);
41231 if (PyErr_Occurred()) SWIG_fail;
41232 }
41233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41234 return resultobj;
41235 fail:
41236 return NULL;
41237 }
41238
41239
41240 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41241 PyObject *resultobj;
41242 wxSizer *arg1 = (wxSizer *) 0 ;
41243 wxGBPosition *arg2 = 0 ;
41244 wxGBSpan *arg3 = 0 ;
41245 int arg4 ;
41246 int arg5 ;
41247 PyObject *arg6 = (PyObject *) NULL ;
41248 wxGBSizerItem *result;
41249 wxGBPosition temp2 ;
41250 wxGBSpan temp3 ;
41251 PyObject * obj0 = 0 ;
41252 PyObject * obj1 = 0 ;
41253 PyObject * obj2 = 0 ;
41254 PyObject * obj3 = 0 ;
41255 PyObject * obj4 = 0 ;
41256 PyObject * obj5 = 0 ;
41257 char *kwnames[] = {
41258 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41259 };
41260
41261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41263 if (SWIG_arg_fail(1)) SWIG_fail;
41264 {
41265 arg2 = &temp2;
41266 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41267 }
41268 {
41269 arg3 = &temp3;
41270 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41271 }
41272 {
41273 arg4 = (int)(SWIG_As_int(obj3));
41274 if (SWIG_arg_fail(4)) SWIG_fail;
41275 }
41276 {
41277 arg5 = (int)(SWIG_As_int(obj4));
41278 if (SWIG_arg_fail(5)) SWIG_fail;
41279 }
41280 if (obj5) {
41281 arg6 = obj5;
41282 }
41283 {
41284 PyThreadState* __tstate = wxPyBeginAllowThreads();
41285 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41286
41287 wxPyEndAllowThreads(__tstate);
41288 if (PyErr_Occurred()) SWIG_fail;
41289 }
41290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41291 return resultobj;
41292 fail:
41293 return NULL;
41294 }
41295
41296
41297 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41298 PyObject *resultobj;
41299 int arg1 ;
41300 int arg2 ;
41301 wxGBPosition *arg3 = 0 ;
41302 wxGBSpan *arg4 = 0 ;
41303 int arg5 ;
41304 int arg6 ;
41305 PyObject *arg7 = (PyObject *) NULL ;
41306 wxGBSizerItem *result;
41307 wxGBPosition temp3 ;
41308 wxGBSpan temp4 ;
41309 PyObject * obj0 = 0 ;
41310 PyObject * obj1 = 0 ;
41311 PyObject * obj2 = 0 ;
41312 PyObject * obj3 = 0 ;
41313 PyObject * obj4 = 0 ;
41314 PyObject * obj5 = 0 ;
41315 PyObject * obj6 = 0 ;
41316 char *kwnames[] = {
41317 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41318 };
41319
41320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41321 {
41322 arg1 = (int)(SWIG_As_int(obj0));
41323 if (SWIG_arg_fail(1)) SWIG_fail;
41324 }
41325 {
41326 arg2 = (int)(SWIG_As_int(obj1));
41327 if (SWIG_arg_fail(2)) SWIG_fail;
41328 }
41329 {
41330 arg3 = &temp3;
41331 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41332 }
41333 {
41334 arg4 = &temp4;
41335 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41336 }
41337 {
41338 arg5 = (int)(SWIG_As_int(obj4));
41339 if (SWIG_arg_fail(5)) SWIG_fail;
41340 }
41341 {
41342 arg6 = (int)(SWIG_As_int(obj5));
41343 if (SWIG_arg_fail(6)) SWIG_fail;
41344 }
41345 if (obj6) {
41346 arg7 = obj6;
41347 }
41348 {
41349 PyThreadState* __tstate = wxPyBeginAllowThreads();
41350 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41351
41352 wxPyEndAllowThreads(__tstate);
41353 if (PyErr_Occurred()) SWIG_fail;
41354 }
41355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41356 return resultobj;
41357 fail:
41358 return NULL;
41359 }
41360
41361
41362 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41363 PyObject *resultobj;
41364 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41365 wxGBPosition result;
41366 PyObject * obj0 = 0 ;
41367 char *kwnames[] = {
41368 (char *) "self", NULL
41369 };
41370
41371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
41372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41373 if (SWIG_arg_fail(1)) SWIG_fail;
41374 {
41375 PyThreadState* __tstate = wxPyBeginAllowThreads();
41376 result = ((wxGBSizerItem const *)arg1)->GetPos();
41377
41378 wxPyEndAllowThreads(__tstate);
41379 if (PyErr_Occurred()) SWIG_fail;
41380 }
41381 {
41382 wxGBPosition * resultptr;
41383 resultptr = new wxGBPosition((wxGBPosition &)(result));
41384 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41385 }
41386 return resultobj;
41387 fail:
41388 return NULL;
41389 }
41390
41391
41392 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41393 PyObject *resultobj;
41394 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41395 wxGBSpan result;
41396 PyObject * obj0 = 0 ;
41397 char *kwnames[] = {
41398 (char *) "self", NULL
41399 };
41400
41401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
41402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41403 if (SWIG_arg_fail(1)) SWIG_fail;
41404 {
41405 PyThreadState* __tstate = wxPyBeginAllowThreads();
41406 result = ((wxGBSizerItem const *)arg1)->GetSpan();
41407
41408 wxPyEndAllowThreads(__tstate);
41409 if (PyErr_Occurred()) SWIG_fail;
41410 }
41411 {
41412 wxGBSpan * resultptr;
41413 resultptr = new wxGBSpan((wxGBSpan &)(result));
41414 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41415 }
41416 return resultobj;
41417 fail:
41418 return NULL;
41419 }
41420
41421
41422 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41423 PyObject *resultobj;
41424 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41425 wxGBPosition *arg2 = 0 ;
41426 bool result;
41427 wxGBPosition temp2 ;
41428 PyObject * obj0 = 0 ;
41429 PyObject * obj1 = 0 ;
41430 char *kwnames[] = {
41431 (char *) "self",(char *) "pos", NULL
41432 };
41433
41434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
41435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41436 if (SWIG_arg_fail(1)) SWIG_fail;
41437 {
41438 arg2 = &temp2;
41439 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41440 }
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
41444
41445 wxPyEndAllowThreads(__tstate);
41446 if (PyErr_Occurred()) SWIG_fail;
41447 }
41448 {
41449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41450 }
41451 return resultobj;
41452 fail:
41453 return NULL;
41454 }
41455
41456
41457 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41458 PyObject *resultobj;
41459 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41460 wxGBSpan *arg2 = 0 ;
41461 bool result;
41462 wxGBSpan temp2 ;
41463 PyObject * obj0 = 0 ;
41464 PyObject * obj1 = 0 ;
41465 char *kwnames[] = {
41466 (char *) "self",(char *) "span", NULL
41467 };
41468
41469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
41470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41471 if (SWIG_arg_fail(1)) SWIG_fail;
41472 {
41473 arg2 = &temp2;
41474 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41475 }
41476 {
41477 PyThreadState* __tstate = wxPyBeginAllowThreads();
41478 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
41479
41480 wxPyEndAllowThreads(__tstate);
41481 if (PyErr_Occurred()) SWIG_fail;
41482 }
41483 {
41484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41485 }
41486 return resultobj;
41487 fail:
41488 return NULL;
41489 }
41490
41491
41492 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
41493 PyObject *resultobj;
41494 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41495 wxGBSizerItem *arg2 = 0 ;
41496 bool result;
41497 PyObject * obj0 = 0 ;
41498 PyObject * obj1 = 0 ;
41499 char *kwnames[] = {
41500 (char *) "self",(char *) "other", NULL
41501 };
41502
41503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
41504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41505 if (SWIG_arg_fail(1)) SWIG_fail;
41506 {
41507 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41508 if (SWIG_arg_fail(2)) SWIG_fail;
41509 if (arg2 == NULL) {
41510 SWIG_null_ref("wxGBSizerItem");
41511 }
41512 if (SWIG_arg_fail(2)) SWIG_fail;
41513 }
41514 {
41515 PyThreadState* __tstate = wxPyBeginAllowThreads();
41516 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
41517
41518 wxPyEndAllowThreads(__tstate);
41519 if (PyErr_Occurred()) SWIG_fail;
41520 }
41521 {
41522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41523 }
41524 return resultobj;
41525 fail:
41526 return NULL;
41527 }
41528
41529
41530 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
41531 PyObject *resultobj;
41532 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41533 wxGBPosition *arg2 = 0 ;
41534 wxGBSpan *arg3 = 0 ;
41535 bool result;
41536 wxGBPosition temp2 ;
41537 wxGBSpan temp3 ;
41538 PyObject * obj0 = 0 ;
41539 PyObject * obj1 = 0 ;
41540 PyObject * obj2 = 0 ;
41541 char *kwnames[] = {
41542 (char *) "self",(char *) "pos",(char *) "span", NULL
41543 };
41544
41545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
41546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41547 if (SWIG_arg_fail(1)) SWIG_fail;
41548 {
41549 arg2 = &temp2;
41550 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41551 }
41552 {
41553 arg3 = &temp3;
41554 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41555 }
41556 {
41557 PyThreadState* __tstate = wxPyBeginAllowThreads();
41558 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
41559
41560 wxPyEndAllowThreads(__tstate);
41561 if (PyErr_Occurred()) SWIG_fail;
41562 }
41563 {
41564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41565 }
41566 return resultobj;
41567 fail:
41568 return NULL;
41569 }
41570
41571
41572 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
41573 PyObject *resultobj;
41574 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41575 wxGBPosition result;
41576 PyObject * obj0 = 0 ;
41577 char *kwnames[] = {
41578 (char *) "self", NULL
41579 };
41580
41581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
41582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41583 if (SWIG_arg_fail(1)) SWIG_fail;
41584 {
41585 PyThreadState* __tstate = wxPyBeginAllowThreads();
41586 result = wxGBSizerItem_GetEndPos(arg1);
41587
41588 wxPyEndAllowThreads(__tstate);
41589 if (PyErr_Occurred()) SWIG_fail;
41590 }
41591 {
41592 wxGBPosition * resultptr;
41593 resultptr = new wxGBPosition((wxGBPosition &)(result));
41594 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41595 }
41596 return resultobj;
41597 fail:
41598 return NULL;
41599 }
41600
41601
41602 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41603 PyObject *resultobj;
41604 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41605 wxGridBagSizer *result;
41606 PyObject * obj0 = 0 ;
41607 char *kwnames[] = {
41608 (char *) "self", NULL
41609 };
41610
41611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
41612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41613 if (SWIG_arg_fail(1)) SWIG_fail;
41614 {
41615 PyThreadState* __tstate = wxPyBeginAllowThreads();
41616 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
41617
41618 wxPyEndAllowThreads(__tstate);
41619 if (PyErr_Occurred()) SWIG_fail;
41620 }
41621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
41622 return resultobj;
41623 fail:
41624 return NULL;
41625 }
41626
41627
41628 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41629 PyObject *resultobj;
41630 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41631 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
41632 PyObject * obj0 = 0 ;
41633 PyObject * obj1 = 0 ;
41634 char *kwnames[] = {
41635 (char *) "self",(char *) "sizer", NULL
41636 };
41637
41638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
41639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41640 if (SWIG_arg_fail(1)) SWIG_fail;
41641 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41642 if (SWIG_arg_fail(2)) SWIG_fail;
41643 {
41644 PyThreadState* __tstate = wxPyBeginAllowThreads();
41645 (arg1)->SetGBSizer(arg2);
41646
41647 wxPyEndAllowThreads(__tstate);
41648 if (PyErr_Occurred()) SWIG_fail;
41649 }
41650 Py_INCREF(Py_None); resultobj = Py_None;
41651 return resultobj;
41652 fail:
41653 return NULL;
41654 }
41655
41656
41657 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
41658 PyObject *obj;
41659 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41660 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
41661 Py_INCREF(obj);
41662 return Py_BuildValue((char *)"");
41663 }
41664 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41665 PyObject *resultobj;
41666 int arg1 = (int) 0 ;
41667 int arg2 = (int) 0 ;
41668 wxGridBagSizer *result;
41669 PyObject * obj0 = 0 ;
41670 PyObject * obj1 = 0 ;
41671 char *kwnames[] = {
41672 (char *) "vgap",(char *) "hgap", NULL
41673 };
41674
41675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
41676 if (obj0) {
41677 {
41678 arg1 = (int)(SWIG_As_int(obj0));
41679 if (SWIG_arg_fail(1)) SWIG_fail;
41680 }
41681 }
41682 if (obj1) {
41683 {
41684 arg2 = (int)(SWIG_As_int(obj1));
41685 if (SWIG_arg_fail(2)) SWIG_fail;
41686 }
41687 }
41688 {
41689 PyThreadState* __tstate = wxPyBeginAllowThreads();
41690 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
41691
41692 wxPyEndAllowThreads(__tstate);
41693 if (PyErr_Occurred()) SWIG_fail;
41694 }
41695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
41696 return resultobj;
41697 fail:
41698 return NULL;
41699 }
41700
41701
41702 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
41703 PyObject *resultobj;
41704 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41705 PyObject *arg2 = (PyObject *) 0 ;
41706 wxGBPosition *arg3 = 0 ;
41707 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
41708 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
41709 int arg5 = (int) 0 ;
41710 int arg6 = (int) 0 ;
41711 PyObject *arg7 = (PyObject *) NULL ;
41712 wxGBSizerItem *result;
41713 wxGBPosition temp3 ;
41714 wxGBSpan temp4 ;
41715 PyObject * obj0 = 0 ;
41716 PyObject * obj1 = 0 ;
41717 PyObject * obj2 = 0 ;
41718 PyObject * obj3 = 0 ;
41719 PyObject * obj4 = 0 ;
41720 PyObject * obj5 = 0 ;
41721 PyObject * obj6 = 0 ;
41722 char *kwnames[] = {
41723 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41724 };
41725
41726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41728 if (SWIG_arg_fail(1)) SWIG_fail;
41729 arg2 = obj1;
41730 {
41731 arg3 = &temp3;
41732 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41733 }
41734 if (obj3) {
41735 {
41736 arg4 = &temp4;
41737 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41738 }
41739 }
41740 if (obj4) {
41741 {
41742 arg5 = (int)(SWIG_As_int(obj4));
41743 if (SWIG_arg_fail(5)) SWIG_fail;
41744 }
41745 }
41746 if (obj5) {
41747 {
41748 arg6 = (int)(SWIG_As_int(obj5));
41749 if (SWIG_arg_fail(6)) SWIG_fail;
41750 }
41751 }
41752 if (obj6) {
41753 arg7 = obj6;
41754 }
41755 {
41756 PyThreadState* __tstate = wxPyBeginAllowThreads();
41757 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41758
41759 wxPyEndAllowThreads(__tstate);
41760 if (PyErr_Occurred()) SWIG_fail;
41761 }
41762 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41763 return resultobj;
41764 fail:
41765 return NULL;
41766 }
41767
41768
41769 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
41770 PyObject *resultobj;
41771 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41772 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
41773 wxGBSizerItem *result;
41774 PyObject * obj0 = 0 ;
41775 PyObject * obj1 = 0 ;
41776 char *kwnames[] = {
41777 (char *) "self",(char *) "item", NULL
41778 };
41779
41780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
41781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41782 if (SWIG_arg_fail(1)) SWIG_fail;
41783 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41784 if (SWIG_arg_fail(2)) SWIG_fail;
41785 {
41786 PyThreadState* __tstate = wxPyBeginAllowThreads();
41787 result = (wxGBSizerItem *)(arg1)->Add(arg2);
41788
41789 wxPyEndAllowThreads(__tstate);
41790 if (PyErr_Occurred()) SWIG_fail;
41791 }
41792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41793 return resultobj;
41794 fail:
41795 return NULL;
41796 }
41797
41798
41799 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41800 PyObject *resultobj;
41801 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41802 int arg2 ;
41803 int arg3 ;
41804 wxSize result;
41805 PyObject * obj0 = 0 ;
41806 PyObject * obj1 = 0 ;
41807 PyObject * obj2 = 0 ;
41808 char *kwnames[] = {
41809 (char *) "self",(char *) "row",(char *) "col", NULL
41810 };
41811
41812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
41813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41814 if (SWIG_arg_fail(1)) SWIG_fail;
41815 {
41816 arg2 = (int)(SWIG_As_int(obj1));
41817 if (SWIG_arg_fail(2)) SWIG_fail;
41818 }
41819 {
41820 arg3 = (int)(SWIG_As_int(obj2));
41821 if (SWIG_arg_fail(3)) SWIG_fail;
41822 }
41823 {
41824 PyThreadState* __tstate = wxPyBeginAllowThreads();
41825 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
41826
41827 wxPyEndAllowThreads(__tstate);
41828 if (PyErr_Occurred()) SWIG_fail;
41829 }
41830 {
41831 wxSize * resultptr;
41832 resultptr = new wxSize((wxSize &)(result));
41833 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41834 }
41835 return resultobj;
41836 fail:
41837 return NULL;
41838 }
41839
41840
41841 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41842 PyObject *resultobj;
41843 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41844 wxSize result;
41845 PyObject * obj0 = 0 ;
41846 char *kwnames[] = {
41847 (char *) "self", NULL
41848 };
41849
41850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
41855 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
41856
41857 wxPyEndAllowThreads(__tstate);
41858 if (PyErr_Occurred()) SWIG_fail;
41859 }
41860 {
41861 wxSize * resultptr;
41862 resultptr = new wxSize((wxSize &)(result));
41863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41864 }
41865 return resultobj;
41866 fail:
41867 return NULL;
41868 }
41869
41870
41871 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41872 PyObject *resultobj;
41873 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41874 wxSize *arg2 = 0 ;
41875 wxSize temp2 ;
41876 PyObject * obj0 = 0 ;
41877 PyObject * obj1 = 0 ;
41878 char *kwnames[] = {
41879 (char *) "self",(char *) "sz", NULL
41880 };
41881
41882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
41883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41884 if (SWIG_arg_fail(1)) SWIG_fail;
41885 {
41886 arg2 = &temp2;
41887 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
41888 }
41889 {
41890 PyThreadState* __tstate = wxPyBeginAllowThreads();
41891 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
41892
41893 wxPyEndAllowThreads(__tstate);
41894 if (PyErr_Occurred()) SWIG_fail;
41895 }
41896 Py_INCREF(Py_None); resultobj = Py_None;
41897 return resultobj;
41898 fail:
41899 return NULL;
41900 }
41901
41902
41903 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41904 PyObject *resultobj;
41905 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41906 wxWindow *arg2 = (wxWindow *) 0 ;
41907 wxGBPosition result;
41908 PyObject * obj0 = 0 ;
41909 PyObject * obj1 = 0 ;
41910
41911 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41913 if (SWIG_arg_fail(1)) SWIG_fail;
41914 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41915 if (SWIG_arg_fail(2)) SWIG_fail;
41916 {
41917 PyThreadState* __tstate = wxPyBeginAllowThreads();
41918 result = (arg1)->GetItemPosition(arg2);
41919
41920 wxPyEndAllowThreads(__tstate);
41921 if (PyErr_Occurred()) SWIG_fail;
41922 }
41923 {
41924 wxGBPosition * resultptr;
41925 resultptr = new wxGBPosition((wxGBPosition &)(result));
41926 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41927 }
41928 return resultobj;
41929 fail:
41930 return NULL;
41931 }
41932
41933
41934 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
41935 PyObject *resultobj;
41936 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41937 wxSizer *arg2 = (wxSizer *) 0 ;
41938 wxGBPosition result;
41939 PyObject * obj0 = 0 ;
41940 PyObject * obj1 = 0 ;
41941
41942 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41944 if (SWIG_arg_fail(1)) SWIG_fail;
41945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41946 if (SWIG_arg_fail(2)) SWIG_fail;
41947 {
41948 PyThreadState* __tstate = wxPyBeginAllowThreads();
41949 result = (arg1)->GetItemPosition(arg2);
41950
41951 wxPyEndAllowThreads(__tstate);
41952 if (PyErr_Occurred()) SWIG_fail;
41953 }
41954 {
41955 wxGBPosition * resultptr;
41956 resultptr = new wxGBPosition((wxGBPosition &)(result));
41957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41958 }
41959 return resultobj;
41960 fail:
41961 return NULL;
41962 }
41963
41964
41965 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
41966 PyObject *resultobj;
41967 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41968 size_t arg2 ;
41969 wxGBPosition result;
41970 PyObject * obj0 = 0 ;
41971 PyObject * obj1 = 0 ;
41972
41973 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41975 if (SWIG_arg_fail(1)) SWIG_fail;
41976 {
41977 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41978 if (SWIG_arg_fail(2)) SWIG_fail;
41979 }
41980 {
41981 PyThreadState* __tstate = wxPyBeginAllowThreads();
41982 result = (arg1)->GetItemPosition(arg2);
41983
41984 wxPyEndAllowThreads(__tstate);
41985 if (PyErr_Occurred()) SWIG_fail;
41986 }
41987 {
41988 wxGBPosition * resultptr;
41989 resultptr = new wxGBPosition((wxGBPosition &)(result));
41990 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41991 }
41992 return resultobj;
41993 fail:
41994 return NULL;
41995 }
41996
41997
41998 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
41999 int argc;
42000 PyObject *argv[3];
42001 int ii;
42002
42003 argc = PyObject_Length(args);
42004 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42005 argv[ii] = PyTuple_GetItem(args,ii);
42006 }
42007 if (argc == 2) {
42008 int _v;
42009 {
42010 void *ptr;
42011 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42012 _v = 0;
42013 PyErr_Clear();
42014 } else {
42015 _v = 1;
42016 }
42017 }
42018 if (_v) {
42019 {
42020 void *ptr;
42021 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42022 _v = 0;
42023 PyErr_Clear();
42024 } else {
42025 _v = 1;
42026 }
42027 }
42028 if (_v) {
42029 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42030 }
42031 }
42032 }
42033 if (argc == 2) {
42034 int _v;
42035 {
42036 void *ptr;
42037 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42038 _v = 0;
42039 PyErr_Clear();
42040 } else {
42041 _v = 1;
42042 }
42043 }
42044 if (_v) {
42045 {
42046 void *ptr;
42047 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42048 _v = 0;
42049 PyErr_Clear();
42050 } else {
42051 _v = 1;
42052 }
42053 }
42054 if (_v) {
42055 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42056 }
42057 }
42058 }
42059 if (argc == 2) {
42060 int _v;
42061 {
42062 void *ptr;
42063 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42064 _v = 0;
42065 PyErr_Clear();
42066 } else {
42067 _v = 1;
42068 }
42069 }
42070 if (_v) {
42071 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42072 if (_v) {
42073 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42074 }
42075 }
42076 }
42077
42078 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42079 return NULL;
42080 }
42081
42082
42083 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42084 PyObject *resultobj;
42085 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42086 wxWindow *arg2 = (wxWindow *) 0 ;
42087 wxGBPosition *arg3 = 0 ;
42088 bool result;
42089 wxGBPosition temp3 ;
42090 PyObject * obj0 = 0 ;
42091 PyObject * obj1 = 0 ;
42092 PyObject * obj2 = 0 ;
42093
42094 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42096 if (SWIG_arg_fail(1)) SWIG_fail;
42097 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42098 if (SWIG_arg_fail(2)) SWIG_fail;
42099 {
42100 arg3 = &temp3;
42101 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42102 }
42103 {
42104 PyThreadState* __tstate = wxPyBeginAllowThreads();
42105 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42106
42107 wxPyEndAllowThreads(__tstate);
42108 if (PyErr_Occurred()) SWIG_fail;
42109 }
42110 {
42111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42112 }
42113 return resultobj;
42114 fail:
42115 return NULL;
42116 }
42117
42118
42119 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42120 PyObject *resultobj;
42121 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42122 wxSizer *arg2 = (wxSizer *) 0 ;
42123 wxGBPosition *arg3 = 0 ;
42124 bool result;
42125 wxGBPosition temp3 ;
42126 PyObject * obj0 = 0 ;
42127 PyObject * obj1 = 0 ;
42128 PyObject * obj2 = 0 ;
42129
42130 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42132 if (SWIG_arg_fail(1)) SWIG_fail;
42133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42134 if (SWIG_arg_fail(2)) SWIG_fail;
42135 {
42136 arg3 = &temp3;
42137 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42138 }
42139 {
42140 PyThreadState* __tstate = wxPyBeginAllowThreads();
42141 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42142
42143 wxPyEndAllowThreads(__tstate);
42144 if (PyErr_Occurred()) SWIG_fail;
42145 }
42146 {
42147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42148 }
42149 return resultobj;
42150 fail:
42151 return NULL;
42152 }
42153
42154
42155 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42156 PyObject *resultobj;
42157 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42158 size_t arg2 ;
42159 wxGBPosition *arg3 = 0 ;
42160 bool result;
42161 wxGBPosition temp3 ;
42162 PyObject * obj0 = 0 ;
42163 PyObject * obj1 = 0 ;
42164 PyObject * obj2 = 0 ;
42165
42166 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42168 if (SWIG_arg_fail(1)) SWIG_fail;
42169 {
42170 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42171 if (SWIG_arg_fail(2)) SWIG_fail;
42172 }
42173 {
42174 arg3 = &temp3;
42175 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42176 }
42177 {
42178 PyThreadState* __tstate = wxPyBeginAllowThreads();
42179 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42180
42181 wxPyEndAllowThreads(__tstate);
42182 if (PyErr_Occurred()) SWIG_fail;
42183 }
42184 {
42185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42186 }
42187 return resultobj;
42188 fail:
42189 return NULL;
42190 }
42191
42192
42193 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42194 int argc;
42195 PyObject *argv[4];
42196 int ii;
42197
42198 argc = PyObject_Length(args);
42199 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42200 argv[ii] = PyTuple_GetItem(args,ii);
42201 }
42202 if (argc == 3) {
42203 int _v;
42204 {
42205 void *ptr;
42206 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42207 _v = 0;
42208 PyErr_Clear();
42209 } else {
42210 _v = 1;
42211 }
42212 }
42213 if (_v) {
42214 {
42215 void *ptr;
42216 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42217 _v = 0;
42218 PyErr_Clear();
42219 } else {
42220 _v = 1;
42221 }
42222 }
42223 if (_v) {
42224 {
42225 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42226 }
42227 if (_v) {
42228 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42229 }
42230 }
42231 }
42232 }
42233 if (argc == 3) {
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_wxSizer, 0) == -1) {
42248 _v = 0;
42249 PyErr_Clear();
42250 } else {
42251 _v = 1;
42252 }
42253 }
42254 if (_v) {
42255 {
42256 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42257 }
42258 if (_v) {
42259 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42260 }
42261 }
42262 }
42263 }
42264 if (argc == 3) {
42265 int _v;
42266 {
42267 void *ptr;
42268 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42269 _v = 0;
42270 PyErr_Clear();
42271 } else {
42272 _v = 1;
42273 }
42274 }
42275 if (_v) {
42276 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42277 if (_v) {
42278 {
42279 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42280 }
42281 if (_v) {
42282 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42283 }
42284 }
42285 }
42286 }
42287
42288 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42289 return NULL;
42290 }
42291
42292
42293 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42294 PyObject *resultobj;
42295 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42296 wxWindow *arg2 = (wxWindow *) 0 ;
42297 wxGBSpan result;
42298 PyObject * obj0 = 0 ;
42299 PyObject * obj1 = 0 ;
42300
42301 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42303 if (SWIG_arg_fail(1)) SWIG_fail;
42304 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42305 if (SWIG_arg_fail(2)) SWIG_fail;
42306 {
42307 PyThreadState* __tstate = wxPyBeginAllowThreads();
42308 result = (arg1)->GetItemSpan(arg2);
42309
42310 wxPyEndAllowThreads(__tstate);
42311 if (PyErr_Occurred()) SWIG_fail;
42312 }
42313 {
42314 wxGBSpan * resultptr;
42315 resultptr = new wxGBSpan((wxGBSpan &)(result));
42316 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42317 }
42318 return resultobj;
42319 fail:
42320 return NULL;
42321 }
42322
42323
42324 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42325 PyObject *resultobj;
42326 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42327 wxSizer *arg2 = (wxSizer *) 0 ;
42328 wxGBSpan result;
42329 PyObject * obj0 = 0 ;
42330 PyObject * obj1 = 0 ;
42331
42332 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42334 if (SWIG_arg_fail(1)) SWIG_fail;
42335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42336 if (SWIG_arg_fail(2)) SWIG_fail;
42337 {
42338 PyThreadState* __tstate = wxPyBeginAllowThreads();
42339 result = (arg1)->GetItemSpan(arg2);
42340
42341 wxPyEndAllowThreads(__tstate);
42342 if (PyErr_Occurred()) SWIG_fail;
42343 }
42344 {
42345 wxGBSpan * resultptr;
42346 resultptr = new wxGBSpan((wxGBSpan &)(result));
42347 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42348 }
42349 return resultobj;
42350 fail:
42351 return NULL;
42352 }
42353
42354
42355 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42356 PyObject *resultobj;
42357 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42358 size_t arg2 ;
42359 wxGBSpan result;
42360 PyObject * obj0 = 0 ;
42361 PyObject * obj1 = 0 ;
42362
42363 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42365 if (SWIG_arg_fail(1)) SWIG_fail;
42366 {
42367 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42368 if (SWIG_arg_fail(2)) SWIG_fail;
42369 }
42370 {
42371 PyThreadState* __tstate = wxPyBeginAllowThreads();
42372 result = (arg1)->GetItemSpan(arg2);
42373
42374 wxPyEndAllowThreads(__tstate);
42375 if (PyErr_Occurred()) SWIG_fail;
42376 }
42377 {
42378 wxGBSpan * resultptr;
42379 resultptr = new wxGBSpan((wxGBSpan &)(result));
42380 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42381 }
42382 return resultobj;
42383 fail:
42384 return NULL;
42385 }
42386
42387
42388 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
42389 int argc;
42390 PyObject *argv[3];
42391 int ii;
42392
42393 argc = PyObject_Length(args);
42394 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42395 argv[ii] = PyTuple_GetItem(args,ii);
42396 }
42397 if (argc == 2) {
42398 int _v;
42399 {
42400 void *ptr;
42401 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42402 _v = 0;
42403 PyErr_Clear();
42404 } else {
42405 _v = 1;
42406 }
42407 }
42408 if (_v) {
42409 {
42410 void *ptr;
42411 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42412 _v = 0;
42413 PyErr_Clear();
42414 } else {
42415 _v = 1;
42416 }
42417 }
42418 if (_v) {
42419 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
42420 }
42421 }
42422 }
42423 if (argc == 2) {
42424 int _v;
42425 {
42426 void *ptr;
42427 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42428 _v = 0;
42429 PyErr_Clear();
42430 } else {
42431 _v = 1;
42432 }
42433 }
42434 if (_v) {
42435 {
42436 void *ptr;
42437 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42438 _v = 0;
42439 PyErr_Clear();
42440 } else {
42441 _v = 1;
42442 }
42443 }
42444 if (_v) {
42445 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
42446 }
42447 }
42448 }
42449 if (argc == 2) {
42450 int _v;
42451 {
42452 void *ptr;
42453 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42454 _v = 0;
42455 PyErr_Clear();
42456 } else {
42457 _v = 1;
42458 }
42459 }
42460 if (_v) {
42461 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42462 if (_v) {
42463 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
42464 }
42465 }
42466 }
42467
42468 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
42469 return NULL;
42470 }
42471
42472
42473 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42474 PyObject *resultobj;
42475 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42476 wxWindow *arg2 = (wxWindow *) 0 ;
42477 wxGBSpan *arg3 = 0 ;
42478 bool result;
42479 wxGBSpan temp3 ;
42480 PyObject * obj0 = 0 ;
42481 PyObject * obj1 = 0 ;
42482 PyObject * obj2 = 0 ;
42483
42484 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42486 if (SWIG_arg_fail(1)) SWIG_fail;
42487 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42488 if (SWIG_arg_fail(2)) SWIG_fail;
42489 {
42490 arg3 = &temp3;
42491 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42492 }
42493 {
42494 PyThreadState* __tstate = wxPyBeginAllowThreads();
42495 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42496
42497 wxPyEndAllowThreads(__tstate);
42498 if (PyErr_Occurred()) SWIG_fail;
42499 }
42500 {
42501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42502 }
42503 return resultobj;
42504 fail:
42505 return NULL;
42506 }
42507
42508
42509 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42510 PyObject *resultobj;
42511 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42512 wxSizer *arg2 = (wxSizer *) 0 ;
42513 wxGBSpan *arg3 = 0 ;
42514 bool result;
42515 wxGBSpan temp3 ;
42516 PyObject * obj0 = 0 ;
42517 PyObject * obj1 = 0 ;
42518 PyObject * obj2 = 0 ;
42519
42520 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42522 if (SWIG_arg_fail(1)) SWIG_fail;
42523 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42524 if (SWIG_arg_fail(2)) SWIG_fail;
42525 {
42526 arg3 = &temp3;
42527 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42528 }
42529 {
42530 PyThreadState* __tstate = wxPyBeginAllowThreads();
42531 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42532
42533 wxPyEndAllowThreads(__tstate);
42534 if (PyErr_Occurred()) SWIG_fail;
42535 }
42536 {
42537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42538 }
42539 return resultobj;
42540 fail:
42541 return NULL;
42542 }
42543
42544
42545 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42546 PyObject *resultobj;
42547 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42548 size_t arg2 ;
42549 wxGBSpan *arg3 = 0 ;
42550 bool result;
42551 wxGBSpan temp3 ;
42552 PyObject * obj0 = 0 ;
42553 PyObject * obj1 = 0 ;
42554 PyObject * obj2 = 0 ;
42555
42556 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42558 if (SWIG_arg_fail(1)) SWIG_fail;
42559 {
42560 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42561 if (SWIG_arg_fail(2)) SWIG_fail;
42562 }
42563 {
42564 arg3 = &temp3;
42565 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42566 }
42567 {
42568 PyThreadState* __tstate = wxPyBeginAllowThreads();
42569 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42570
42571 wxPyEndAllowThreads(__tstate);
42572 if (PyErr_Occurred()) SWIG_fail;
42573 }
42574 {
42575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42576 }
42577 return resultobj;
42578 fail:
42579 return NULL;
42580 }
42581
42582
42583 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
42584 int argc;
42585 PyObject *argv[4];
42586 int ii;
42587
42588 argc = PyObject_Length(args);
42589 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42590 argv[ii] = PyTuple_GetItem(args,ii);
42591 }
42592 if (argc == 3) {
42593 int _v;
42594 {
42595 void *ptr;
42596 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42597 _v = 0;
42598 PyErr_Clear();
42599 } else {
42600 _v = 1;
42601 }
42602 }
42603 if (_v) {
42604 {
42605 void *ptr;
42606 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42607 _v = 0;
42608 PyErr_Clear();
42609 } else {
42610 _v = 1;
42611 }
42612 }
42613 if (_v) {
42614 {
42615 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42616 }
42617 if (_v) {
42618 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
42619 }
42620 }
42621 }
42622 }
42623 if (argc == 3) {
42624 int _v;
42625 {
42626 void *ptr;
42627 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42628 _v = 0;
42629 PyErr_Clear();
42630 } else {
42631 _v = 1;
42632 }
42633 }
42634 if (_v) {
42635 {
42636 void *ptr;
42637 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42638 _v = 0;
42639 PyErr_Clear();
42640 } else {
42641 _v = 1;
42642 }
42643 }
42644 if (_v) {
42645 {
42646 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42647 }
42648 if (_v) {
42649 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
42650 }
42651 }
42652 }
42653 }
42654 if (argc == 3) {
42655 int _v;
42656 {
42657 void *ptr;
42658 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42659 _v = 0;
42660 PyErr_Clear();
42661 } else {
42662 _v = 1;
42663 }
42664 }
42665 if (_v) {
42666 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42667 if (_v) {
42668 {
42669 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42670 }
42671 if (_v) {
42672 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
42673 }
42674 }
42675 }
42676 }
42677
42678 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
42679 return NULL;
42680 }
42681
42682
42683 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
42684 PyObject *resultobj;
42685 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42686 wxWindow *arg2 = (wxWindow *) 0 ;
42687 wxGBSizerItem *result;
42688 PyObject * obj0 = 0 ;
42689 PyObject * obj1 = 0 ;
42690
42691 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42693 if (SWIG_arg_fail(1)) SWIG_fail;
42694 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42695 if (SWIG_arg_fail(2)) SWIG_fail;
42696 {
42697 PyThreadState* __tstate = wxPyBeginAllowThreads();
42698 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42699
42700 wxPyEndAllowThreads(__tstate);
42701 if (PyErr_Occurred()) SWIG_fail;
42702 }
42703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42704 return resultobj;
42705 fail:
42706 return NULL;
42707 }
42708
42709
42710 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
42711 PyObject *resultobj;
42712 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42713 wxSizer *arg2 = (wxSizer *) 0 ;
42714 wxGBSizerItem *result;
42715 PyObject * obj0 = 0 ;
42716 PyObject * obj1 = 0 ;
42717
42718 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42720 if (SWIG_arg_fail(1)) SWIG_fail;
42721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42722 if (SWIG_arg_fail(2)) SWIG_fail;
42723 {
42724 PyThreadState* __tstate = wxPyBeginAllowThreads();
42725 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42726
42727 wxPyEndAllowThreads(__tstate);
42728 if (PyErr_Occurred()) SWIG_fail;
42729 }
42730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42731 return resultobj;
42732 fail:
42733 return NULL;
42734 }
42735
42736
42737 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
42738 int argc;
42739 PyObject *argv[3];
42740 int ii;
42741
42742 argc = PyObject_Length(args);
42743 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42744 argv[ii] = PyTuple_GetItem(args,ii);
42745 }
42746 if (argc == 2) {
42747 int _v;
42748 {
42749 void *ptr;
42750 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42751 _v = 0;
42752 PyErr_Clear();
42753 } else {
42754 _v = 1;
42755 }
42756 }
42757 if (_v) {
42758 {
42759 void *ptr;
42760 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42761 _v = 0;
42762 PyErr_Clear();
42763 } else {
42764 _v = 1;
42765 }
42766 }
42767 if (_v) {
42768 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
42769 }
42770 }
42771 }
42772 if (argc == 2) {
42773 int _v;
42774 {
42775 void *ptr;
42776 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42777 _v = 0;
42778 PyErr_Clear();
42779 } else {
42780 _v = 1;
42781 }
42782 }
42783 if (_v) {
42784 {
42785 void *ptr;
42786 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42787 _v = 0;
42788 PyErr_Clear();
42789 } else {
42790 _v = 1;
42791 }
42792 }
42793 if (_v) {
42794 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
42795 }
42796 }
42797 }
42798
42799 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
42800 return NULL;
42801 }
42802
42803
42804 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42805 PyObject *resultobj;
42806 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42807 wxGBPosition *arg2 = 0 ;
42808 wxGBSizerItem *result;
42809 wxGBPosition temp2 ;
42810 PyObject * obj0 = 0 ;
42811 PyObject * obj1 = 0 ;
42812 char *kwnames[] = {
42813 (char *) "self",(char *) "pos", NULL
42814 };
42815
42816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
42817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42818 if (SWIG_arg_fail(1)) SWIG_fail;
42819 {
42820 arg2 = &temp2;
42821 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42822 }
42823 {
42824 PyThreadState* __tstate = wxPyBeginAllowThreads();
42825 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
42826
42827 wxPyEndAllowThreads(__tstate);
42828 if (PyErr_Occurred()) SWIG_fail;
42829 }
42830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42831 return resultobj;
42832 fail:
42833 return NULL;
42834 }
42835
42836
42837 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
42838 PyObject *resultobj;
42839 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42840 wxPoint *arg2 = 0 ;
42841 wxGBSizerItem *result;
42842 wxPoint temp2 ;
42843 PyObject * obj0 = 0 ;
42844 PyObject * obj1 = 0 ;
42845 char *kwnames[] = {
42846 (char *) "self",(char *) "pt", NULL
42847 };
42848
42849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
42850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42851 if (SWIG_arg_fail(1)) SWIG_fail;
42852 {
42853 arg2 = &temp2;
42854 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
42855 }
42856 {
42857 PyThreadState* __tstate = wxPyBeginAllowThreads();
42858 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
42859
42860 wxPyEndAllowThreads(__tstate);
42861 if (PyErr_Occurred()) SWIG_fail;
42862 }
42863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42864 return resultobj;
42865 fail:
42866 return NULL;
42867 }
42868
42869
42870 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
42871 PyObject *resultobj;
42872 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42873 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42874 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
42875 bool result;
42876 PyObject * obj0 = 0 ;
42877 PyObject * obj1 = 0 ;
42878 PyObject * obj2 = 0 ;
42879 char *kwnames[] = {
42880 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
42881 };
42882
42883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
42884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42885 if (SWIG_arg_fail(1)) SWIG_fail;
42886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42887 if (SWIG_arg_fail(2)) SWIG_fail;
42888 if (obj2) {
42889 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42890 if (SWIG_arg_fail(3)) SWIG_fail;
42891 }
42892 {
42893 PyThreadState* __tstate = wxPyBeginAllowThreads();
42894 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
42895
42896 wxPyEndAllowThreads(__tstate);
42897 if (PyErr_Occurred()) SWIG_fail;
42898 }
42899 {
42900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42901 }
42902 return resultobj;
42903 fail:
42904 return NULL;
42905 }
42906
42907
42908 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
42909 PyObject *resultobj;
42910 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42911 wxGBPosition *arg2 = 0 ;
42912 wxGBSpan *arg3 = 0 ;
42913 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
42914 bool result;
42915 wxGBPosition temp2 ;
42916 wxGBSpan temp3 ;
42917 PyObject * obj0 = 0 ;
42918 PyObject * obj1 = 0 ;
42919 PyObject * obj2 = 0 ;
42920 PyObject * obj3 = 0 ;
42921 char *kwnames[] = {
42922 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
42923 };
42924
42925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42927 if (SWIG_arg_fail(1)) SWIG_fail;
42928 {
42929 arg2 = &temp2;
42930 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42931 }
42932 {
42933 arg3 = &temp3;
42934 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42935 }
42936 if (obj3) {
42937 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42938 if (SWIG_arg_fail(4)) SWIG_fail;
42939 }
42940 {
42941 PyThreadState* __tstate = wxPyBeginAllowThreads();
42942 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
42943
42944 wxPyEndAllowThreads(__tstate);
42945 if (PyErr_Occurred()) SWIG_fail;
42946 }
42947 {
42948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42949 }
42950 return resultobj;
42951 fail:
42952 return NULL;
42953 }
42954
42955
42956 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
42957 PyObject *obj;
42958 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42959 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
42960 Py_INCREF(obj);
42961 return Py_BuildValue((char *)"");
42962 }
42963 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42964 PyObject *resultobj;
42965 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42966 wxRelationship arg2 ;
42967 wxWindow *arg3 = (wxWindow *) 0 ;
42968 wxEdge arg4 ;
42969 int arg5 = (int) 0 ;
42970 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
42971 PyObject * obj0 = 0 ;
42972 PyObject * obj1 = 0 ;
42973 PyObject * obj2 = 0 ;
42974 PyObject * obj3 = 0 ;
42975 PyObject * obj4 = 0 ;
42976 PyObject * obj5 = 0 ;
42977 char *kwnames[] = {
42978 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
42979 };
42980
42981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42983 if (SWIG_arg_fail(1)) SWIG_fail;
42984 {
42985 arg2 = (wxRelationship)(SWIG_As_int(obj1));
42986 if (SWIG_arg_fail(2)) SWIG_fail;
42987 }
42988 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42989 if (SWIG_arg_fail(3)) SWIG_fail;
42990 {
42991 arg4 = (wxEdge)(SWIG_As_int(obj3));
42992 if (SWIG_arg_fail(4)) SWIG_fail;
42993 }
42994 if (obj4) {
42995 {
42996 arg5 = (int)(SWIG_As_int(obj4));
42997 if (SWIG_arg_fail(5)) SWIG_fail;
42998 }
42999 }
43000 if (obj5) {
43001 {
43002 arg6 = (int)(SWIG_As_int(obj5));
43003 if (SWIG_arg_fail(6)) SWIG_fail;
43004 }
43005 }
43006 {
43007 PyThreadState* __tstate = wxPyBeginAllowThreads();
43008 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43009
43010 wxPyEndAllowThreads(__tstate);
43011 if (PyErr_Occurred()) SWIG_fail;
43012 }
43013 Py_INCREF(Py_None); resultobj = Py_None;
43014 return resultobj;
43015 fail:
43016 return NULL;
43017 }
43018
43019
43020 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43021 PyObject *resultobj;
43022 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43023 wxWindow *arg2 = (wxWindow *) 0 ;
43024 int arg3 = (int) 0 ;
43025 PyObject * obj0 = 0 ;
43026 PyObject * obj1 = 0 ;
43027 PyObject * obj2 = 0 ;
43028 char *kwnames[] = {
43029 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43030 };
43031
43032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43036 if (SWIG_arg_fail(2)) SWIG_fail;
43037 if (obj2) {
43038 {
43039 arg3 = (int)(SWIG_As_int(obj2));
43040 if (SWIG_arg_fail(3)) SWIG_fail;
43041 }
43042 }
43043 {
43044 PyThreadState* __tstate = wxPyBeginAllowThreads();
43045 (arg1)->LeftOf(arg2,arg3);
43046
43047 wxPyEndAllowThreads(__tstate);
43048 if (PyErr_Occurred()) SWIG_fail;
43049 }
43050 Py_INCREF(Py_None); resultobj = Py_None;
43051 return resultobj;
43052 fail:
43053 return NULL;
43054 }
43055
43056
43057 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43058 PyObject *resultobj;
43059 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43060 wxWindow *arg2 = (wxWindow *) 0 ;
43061 int arg3 = (int) 0 ;
43062 PyObject * obj0 = 0 ;
43063 PyObject * obj1 = 0 ;
43064 PyObject * obj2 = 0 ;
43065 char *kwnames[] = {
43066 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43067 };
43068
43069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43071 if (SWIG_arg_fail(1)) SWIG_fail;
43072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43073 if (SWIG_arg_fail(2)) SWIG_fail;
43074 if (obj2) {
43075 {
43076 arg3 = (int)(SWIG_As_int(obj2));
43077 if (SWIG_arg_fail(3)) SWIG_fail;
43078 }
43079 }
43080 {
43081 PyThreadState* __tstate = wxPyBeginAllowThreads();
43082 (arg1)->RightOf(arg2,arg3);
43083
43084 wxPyEndAllowThreads(__tstate);
43085 if (PyErr_Occurred()) SWIG_fail;
43086 }
43087 Py_INCREF(Py_None); resultobj = Py_None;
43088 return resultobj;
43089 fail:
43090 return NULL;
43091 }
43092
43093
43094 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43095 PyObject *resultobj;
43096 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43097 wxWindow *arg2 = (wxWindow *) 0 ;
43098 int arg3 = (int) 0 ;
43099 PyObject * obj0 = 0 ;
43100 PyObject * obj1 = 0 ;
43101 PyObject * obj2 = 0 ;
43102 char *kwnames[] = {
43103 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43104 };
43105
43106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43108 if (SWIG_arg_fail(1)) SWIG_fail;
43109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43110 if (SWIG_arg_fail(2)) SWIG_fail;
43111 if (obj2) {
43112 {
43113 arg3 = (int)(SWIG_As_int(obj2));
43114 if (SWIG_arg_fail(3)) SWIG_fail;
43115 }
43116 }
43117 {
43118 PyThreadState* __tstate = wxPyBeginAllowThreads();
43119 (arg1)->Above(arg2,arg3);
43120
43121 wxPyEndAllowThreads(__tstate);
43122 if (PyErr_Occurred()) SWIG_fail;
43123 }
43124 Py_INCREF(Py_None); resultobj = Py_None;
43125 return resultobj;
43126 fail:
43127 return NULL;
43128 }
43129
43130
43131 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43132 PyObject *resultobj;
43133 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43134 wxWindow *arg2 = (wxWindow *) 0 ;
43135 int arg3 = (int) 0 ;
43136 PyObject * obj0 = 0 ;
43137 PyObject * obj1 = 0 ;
43138 PyObject * obj2 = 0 ;
43139 char *kwnames[] = {
43140 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43141 };
43142
43143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43145 if (SWIG_arg_fail(1)) SWIG_fail;
43146 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43147 if (SWIG_arg_fail(2)) SWIG_fail;
43148 if (obj2) {
43149 {
43150 arg3 = (int)(SWIG_As_int(obj2));
43151 if (SWIG_arg_fail(3)) SWIG_fail;
43152 }
43153 }
43154 {
43155 PyThreadState* __tstate = wxPyBeginAllowThreads();
43156 (arg1)->Below(arg2,arg3);
43157
43158 wxPyEndAllowThreads(__tstate);
43159 if (PyErr_Occurred()) SWIG_fail;
43160 }
43161 Py_INCREF(Py_None); resultobj = Py_None;
43162 return resultobj;
43163 fail:
43164 return NULL;
43165 }
43166
43167
43168 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43169 PyObject *resultobj;
43170 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43171 wxWindow *arg2 = (wxWindow *) 0 ;
43172 wxEdge arg3 ;
43173 int arg4 = (int) 0 ;
43174 PyObject * obj0 = 0 ;
43175 PyObject * obj1 = 0 ;
43176 PyObject * obj2 = 0 ;
43177 PyObject * obj3 = 0 ;
43178 char *kwnames[] = {
43179 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43180 };
43181
43182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43184 if (SWIG_arg_fail(1)) SWIG_fail;
43185 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43186 if (SWIG_arg_fail(2)) SWIG_fail;
43187 {
43188 arg3 = (wxEdge)(SWIG_As_int(obj2));
43189 if (SWIG_arg_fail(3)) SWIG_fail;
43190 }
43191 if (obj3) {
43192 {
43193 arg4 = (int)(SWIG_As_int(obj3));
43194 if (SWIG_arg_fail(4)) SWIG_fail;
43195 }
43196 }
43197 {
43198 PyThreadState* __tstate = wxPyBeginAllowThreads();
43199 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43200
43201 wxPyEndAllowThreads(__tstate);
43202 if (PyErr_Occurred()) SWIG_fail;
43203 }
43204 Py_INCREF(Py_None); resultobj = Py_None;
43205 return resultobj;
43206 fail:
43207 return NULL;
43208 }
43209
43210
43211 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43212 PyObject *resultobj;
43213 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43214 wxWindow *arg2 = (wxWindow *) 0 ;
43215 wxEdge arg3 ;
43216 int arg4 ;
43217 PyObject * obj0 = 0 ;
43218 PyObject * obj1 = 0 ;
43219 PyObject * obj2 = 0 ;
43220 PyObject * obj3 = 0 ;
43221 char *kwnames[] = {
43222 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43223 };
43224
43225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43227 if (SWIG_arg_fail(1)) SWIG_fail;
43228 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43229 if (SWIG_arg_fail(2)) SWIG_fail;
43230 {
43231 arg3 = (wxEdge)(SWIG_As_int(obj2));
43232 if (SWIG_arg_fail(3)) SWIG_fail;
43233 }
43234 {
43235 arg4 = (int)(SWIG_As_int(obj3));
43236 if (SWIG_arg_fail(4)) SWIG_fail;
43237 }
43238 {
43239 PyThreadState* __tstate = wxPyBeginAllowThreads();
43240 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43241
43242 wxPyEndAllowThreads(__tstate);
43243 if (PyErr_Occurred()) SWIG_fail;
43244 }
43245 Py_INCREF(Py_None); resultobj = Py_None;
43246 return resultobj;
43247 fail:
43248 return NULL;
43249 }
43250
43251
43252 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43253 PyObject *resultobj;
43254 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43255 int arg2 ;
43256 PyObject * obj0 = 0 ;
43257 PyObject * obj1 = 0 ;
43258 char *kwnames[] = {
43259 (char *) "self",(char *) "val", NULL
43260 };
43261
43262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43264 if (SWIG_arg_fail(1)) SWIG_fail;
43265 {
43266 arg2 = (int)(SWIG_As_int(obj1));
43267 if (SWIG_arg_fail(2)) SWIG_fail;
43268 }
43269 {
43270 PyThreadState* __tstate = wxPyBeginAllowThreads();
43271 (arg1)->Absolute(arg2);
43272
43273 wxPyEndAllowThreads(__tstate);
43274 if (PyErr_Occurred()) SWIG_fail;
43275 }
43276 Py_INCREF(Py_None); resultobj = Py_None;
43277 return resultobj;
43278 fail:
43279 return NULL;
43280 }
43281
43282
43283 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43284 PyObject *resultobj;
43285 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43286 PyObject * obj0 = 0 ;
43287 char *kwnames[] = {
43288 (char *) "self", NULL
43289 };
43290
43291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43293 if (SWIG_arg_fail(1)) SWIG_fail;
43294 {
43295 PyThreadState* __tstate = wxPyBeginAllowThreads();
43296 (arg1)->Unconstrained();
43297
43298 wxPyEndAllowThreads(__tstate);
43299 if (PyErr_Occurred()) SWIG_fail;
43300 }
43301 Py_INCREF(Py_None); resultobj = Py_None;
43302 return resultobj;
43303 fail:
43304 return NULL;
43305 }
43306
43307
43308 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43309 PyObject *resultobj;
43310 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43311 PyObject * obj0 = 0 ;
43312 char *kwnames[] = {
43313 (char *) "self", NULL
43314 };
43315
43316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43318 if (SWIG_arg_fail(1)) SWIG_fail;
43319 {
43320 PyThreadState* __tstate = wxPyBeginAllowThreads();
43321 (arg1)->AsIs();
43322
43323 wxPyEndAllowThreads(__tstate);
43324 if (PyErr_Occurred()) SWIG_fail;
43325 }
43326 Py_INCREF(Py_None); resultobj = Py_None;
43327 return resultobj;
43328 fail:
43329 return NULL;
43330 }
43331
43332
43333 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43334 PyObject *resultobj;
43335 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43336 wxWindow *result;
43337 PyObject * obj0 = 0 ;
43338 char *kwnames[] = {
43339 (char *) "self", NULL
43340 };
43341
43342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
43343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43344 if (SWIG_arg_fail(1)) SWIG_fail;
43345 {
43346 PyThreadState* __tstate = wxPyBeginAllowThreads();
43347 result = (wxWindow *)(arg1)->GetOtherWindow();
43348
43349 wxPyEndAllowThreads(__tstate);
43350 if (PyErr_Occurred()) SWIG_fail;
43351 }
43352 {
43353 resultobj = wxPyMake_wxObject(result, 0);
43354 }
43355 return resultobj;
43356 fail:
43357 return NULL;
43358 }
43359
43360
43361 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43362 PyObject *resultobj;
43363 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43364 wxEdge result;
43365 PyObject * obj0 = 0 ;
43366 char *kwnames[] = {
43367 (char *) "self", NULL
43368 };
43369
43370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
43371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43372 if (SWIG_arg_fail(1)) SWIG_fail;
43373 {
43374 PyThreadState* __tstate = wxPyBeginAllowThreads();
43375 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
43376
43377 wxPyEndAllowThreads(__tstate);
43378 if (PyErr_Occurred()) SWIG_fail;
43379 }
43380 resultobj = SWIG_From_int((result));
43381 return resultobj;
43382 fail:
43383 return NULL;
43384 }
43385
43386
43387 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43388 PyObject *resultobj;
43389 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43390 wxEdge arg2 ;
43391 PyObject * obj0 = 0 ;
43392 PyObject * obj1 = 0 ;
43393 char *kwnames[] = {
43394 (char *) "self",(char *) "which", NULL
43395 };
43396
43397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
43398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43399 if (SWIG_arg_fail(1)) SWIG_fail;
43400 {
43401 arg2 = (wxEdge)(SWIG_As_int(obj1));
43402 if (SWIG_arg_fail(2)) SWIG_fail;
43403 }
43404 {
43405 PyThreadState* __tstate = wxPyBeginAllowThreads();
43406 (arg1)->SetEdge((wxEdge )arg2);
43407
43408 wxPyEndAllowThreads(__tstate);
43409 if (PyErr_Occurred()) SWIG_fail;
43410 }
43411 Py_INCREF(Py_None); resultobj = Py_None;
43412 return resultobj;
43413 fail:
43414 return NULL;
43415 }
43416
43417
43418 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43419 PyObject *resultobj;
43420 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43421 int arg2 ;
43422 PyObject * obj0 = 0 ;
43423 PyObject * obj1 = 0 ;
43424 char *kwnames[] = {
43425 (char *) "self",(char *) "v", NULL
43426 };
43427
43428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
43429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43430 if (SWIG_arg_fail(1)) SWIG_fail;
43431 {
43432 arg2 = (int)(SWIG_As_int(obj1));
43433 if (SWIG_arg_fail(2)) SWIG_fail;
43434 }
43435 {
43436 PyThreadState* __tstate = wxPyBeginAllowThreads();
43437 (arg1)->SetValue(arg2);
43438
43439 wxPyEndAllowThreads(__tstate);
43440 if (PyErr_Occurred()) SWIG_fail;
43441 }
43442 Py_INCREF(Py_None); resultobj = Py_None;
43443 return resultobj;
43444 fail:
43445 return NULL;
43446 }
43447
43448
43449 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43450 PyObject *resultobj;
43451 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43452 int result;
43453 PyObject * obj0 = 0 ;
43454 char *kwnames[] = {
43455 (char *) "self", NULL
43456 };
43457
43458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
43459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43460 if (SWIG_arg_fail(1)) SWIG_fail;
43461 {
43462 PyThreadState* __tstate = wxPyBeginAllowThreads();
43463 result = (int)(arg1)->GetMargin();
43464
43465 wxPyEndAllowThreads(__tstate);
43466 if (PyErr_Occurred()) SWIG_fail;
43467 }
43468 {
43469 resultobj = SWIG_From_int((int)(result));
43470 }
43471 return resultobj;
43472 fail:
43473 return NULL;
43474 }
43475
43476
43477 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43478 PyObject *resultobj;
43479 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43480 int arg2 ;
43481 PyObject * obj0 = 0 ;
43482 PyObject * obj1 = 0 ;
43483 char *kwnames[] = {
43484 (char *) "self",(char *) "m", NULL
43485 };
43486
43487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
43488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43489 if (SWIG_arg_fail(1)) SWIG_fail;
43490 {
43491 arg2 = (int)(SWIG_As_int(obj1));
43492 if (SWIG_arg_fail(2)) SWIG_fail;
43493 }
43494 {
43495 PyThreadState* __tstate = wxPyBeginAllowThreads();
43496 (arg1)->SetMargin(arg2);
43497
43498 wxPyEndAllowThreads(__tstate);
43499 if (PyErr_Occurred()) SWIG_fail;
43500 }
43501 Py_INCREF(Py_None); resultobj = Py_None;
43502 return resultobj;
43503 fail:
43504 return NULL;
43505 }
43506
43507
43508 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43509 PyObject *resultobj;
43510 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43511 int result;
43512 PyObject * obj0 = 0 ;
43513 char *kwnames[] = {
43514 (char *) "self", NULL
43515 };
43516
43517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
43518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43519 if (SWIG_arg_fail(1)) SWIG_fail;
43520 {
43521 PyThreadState* __tstate = wxPyBeginAllowThreads();
43522 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
43523
43524 wxPyEndAllowThreads(__tstate);
43525 if (PyErr_Occurred()) SWIG_fail;
43526 }
43527 {
43528 resultobj = SWIG_From_int((int)(result));
43529 }
43530 return resultobj;
43531 fail:
43532 return NULL;
43533 }
43534
43535
43536 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
43537 PyObject *resultobj;
43538 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43539 int result;
43540 PyObject * obj0 = 0 ;
43541 char *kwnames[] = {
43542 (char *) "self", NULL
43543 };
43544
43545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
43546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43547 if (SWIG_arg_fail(1)) SWIG_fail;
43548 {
43549 PyThreadState* __tstate = wxPyBeginAllowThreads();
43550 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
43551
43552 wxPyEndAllowThreads(__tstate);
43553 if (PyErr_Occurred()) SWIG_fail;
43554 }
43555 {
43556 resultobj = SWIG_From_int((int)(result));
43557 }
43558 return resultobj;
43559 fail:
43560 return NULL;
43561 }
43562
43563
43564 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43565 PyObject *resultobj;
43566 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43567 int result;
43568 PyObject * obj0 = 0 ;
43569 char *kwnames[] = {
43570 (char *) "self", NULL
43571 };
43572
43573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
43574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43575 if (SWIG_arg_fail(1)) SWIG_fail;
43576 {
43577 PyThreadState* __tstate = wxPyBeginAllowThreads();
43578 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
43579
43580 wxPyEndAllowThreads(__tstate);
43581 if (PyErr_Occurred()) SWIG_fail;
43582 }
43583 {
43584 resultobj = SWIG_From_int((int)(result));
43585 }
43586 return resultobj;
43587 fail:
43588 return NULL;
43589 }
43590
43591
43592 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43593 PyObject *resultobj;
43594 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43595 bool result;
43596 PyObject * obj0 = 0 ;
43597 char *kwnames[] = {
43598 (char *) "self", NULL
43599 };
43600
43601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
43602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43603 if (SWIG_arg_fail(1)) SWIG_fail;
43604 {
43605 PyThreadState* __tstate = wxPyBeginAllowThreads();
43606 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
43607
43608 wxPyEndAllowThreads(__tstate);
43609 if (PyErr_Occurred()) SWIG_fail;
43610 }
43611 {
43612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43613 }
43614 return resultobj;
43615 fail:
43616 return NULL;
43617 }
43618
43619
43620 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43621 PyObject *resultobj;
43622 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43623 bool arg2 ;
43624 PyObject * obj0 = 0 ;
43625 PyObject * obj1 = 0 ;
43626 char *kwnames[] = {
43627 (char *) "self",(char *) "d", NULL
43628 };
43629
43630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
43631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43632 if (SWIG_arg_fail(1)) SWIG_fail;
43633 {
43634 arg2 = (bool)(SWIG_As_bool(obj1));
43635 if (SWIG_arg_fail(2)) SWIG_fail;
43636 }
43637 {
43638 PyThreadState* __tstate = wxPyBeginAllowThreads();
43639 (arg1)->SetDone(arg2);
43640
43641 wxPyEndAllowThreads(__tstate);
43642 if (PyErr_Occurred()) SWIG_fail;
43643 }
43644 Py_INCREF(Py_None); resultobj = Py_None;
43645 return resultobj;
43646 fail:
43647 return NULL;
43648 }
43649
43650
43651 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43652 PyObject *resultobj;
43653 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43654 wxRelationship result;
43655 PyObject * obj0 = 0 ;
43656 char *kwnames[] = {
43657 (char *) "self", NULL
43658 };
43659
43660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
43661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43662 if (SWIG_arg_fail(1)) SWIG_fail;
43663 {
43664 PyThreadState* __tstate = wxPyBeginAllowThreads();
43665 result = (wxRelationship)(arg1)->GetRelationship();
43666
43667 wxPyEndAllowThreads(__tstate);
43668 if (PyErr_Occurred()) SWIG_fail;
43669 }
43670 resultobj = SWIG_From_int((result));
43671 return resultobj;
43672 fail:
43673 return NULL;
43674 }
43675
43676
43677 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43678 PyObject *resultobj;
43679 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43680 wxRelationship arg2 ;
43681 PyObject * obj0 = 0 ;
43682 PyObject * obj1 = 0 ;
43683 char *kwnames[] = {
43684 (char *) "self",(char *) "r", NULL
43685 };
43686
43687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
43688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43689 if (SWIG_arg_fail(1)) SWIG_fail;
43690 {
43691 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43692 if (SWIG_arg_fail(2)) SWIG_fail;
43693 }
43694 {
43695 PyThreadState* __tstate = wxPyBeginAllowThreads();
43696 (arg1)->SetRelationship((wxRelationship )arg2);
43697
43698 wxPyEndAllowThreads(__tstate);
43699 if (PyErr_Occurred()) SWIG_fail;
43700 }
43701 Py_INCREF(Py_None); resultobj = Py_None;
43702 return resultobj;
43703 fail:
43704 return NULL;
43705 }
43706
43707
43708 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
43709 PyObject *resultobj;
43710 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43711 wxWindow *arg2 = (wxWindow *) 0 ;
43712 bool result;
43713 PyObject * obj0 = 0 ;
43714 PyObject * obj1 = 0 ;
43715 char *kwnames[] = {
43716 (char *) "self",(char *) "otherW", NULL
43717 };
43718
43719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
43720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43721 if (SWIG_arg_fail(1)) SWIG_fail;
43722 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43723 if (SWIG_arg_fail(2)) SWIG_fail;
43724 {
43725 PyThreadState* __tstate = wxPyBeginAllowThreads();
43726 result = (bool)(arg1)->ResetIfWin(arg2);
43727
43728 wxPyEndAllowThreads(__tstate);
43729 if (PyErr_Occurred()) SWIG_fail;
43730 }
43731 {
43732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43733 }
43734 return resultobj;
43735 fail:
43736 return NULL;
43737 }
43738
43739
43740 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
43741 PyObject *resultobj;
43742 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43743 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
43744 wxWindow *arg3 = (wxWindow *) 0 ;
43745 bool result;
43746 PyObject * obj0 = 0 ;
43747 PyObject * obj1 = 0 ;
43748 PyObject * obj2 = 0 ;
43749 char *kwnames[] = {
43750 (char *) "self",(char *) "constraints",(char *) "win", NULL
43751 };
43752
43753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
43754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43755 if (SWIG_arg_fail(1)) SWIG_fail;
43756 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43757 if (SWIG_arg_fail(2)) SWIG_fail;
43758 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43759 if (SWIG_arg_fail(3)) SWIG_fail;
43760 {
43761 PyThreadState* __tstate = wxPyBeginAllowThreads();
43762 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
43763
43764 wxPyEndAllowThreads(__tstate);
43765 if (PyErr_Occurred()) SWIG_fail;
43766 }
43767 {
43768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43769 }
43770 return resultobj;
43771 fail:
43772 return NULL;
43773 }
43774
43775
43776 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43777 PyObject *resultobj;
43778 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43779 wxEdge arg2 ;
43780 wxWindow *arg3 = (wxWindow *) 0 ;
43781 wxWindow *arg4 = (wxWindow *) 0 ;
43782 int result;
43783 PyObject * obj0 = 0 ;
43784 PyObject * obj1 = 0 ;
43785 PyObject * obj2 = 0 ;
43786 PyObject * obj3 = 0 ;
43787 char *kwnames[] = {
43788 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
43789 };
43790
43791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43793 if (SWIG_arg_fail(1)) SWIG_fail;
43794 {
43795 arg2 = (wxEdge)(SWIG_As_int(obj1));
43796 if (SWIG_arg_fail(2)) SWIG_fail;
43797 }
43798 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43799 if (SWIG_arg_fail(3)) SWIG_fail;
43800 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43801 if (SWIG_arg_fail(4)) SWIG_fail;
43802 {
43803 PyThreadState* __tstate = wxPyBeginAllowThreads();
43804 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
43805
43806 wxPyEndAllowThreads(__tstate);
43807 if (PyErr_Occurred()) SWIG_fail;
43808 }
43809 {
43810 resultobj = SWIG_From_int((int)(result));
43811 }
43812 return resultobj;
43813 fail:
43814 return NULL;
43815 }
43816
43817
43818 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
43819 PyObject *obj;
43820 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43821 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
43822 Py_INCREF(obj);
43823 return Py_BuildValue((char *)"");
43824 }
43825 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
43826 PyObject *resultobj;
43827 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43828 wxIndividualLayoutConstraint *result;
43829 PyObject * obj0 = 0 ;
43830 char *kwnames[] = {
43831 (char *) "self", NULL
43832 };
43833
43834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
43835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43836 if (SWIG_arg_fail(1)) SWIG_fail;
43837 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
43838
43839 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43840 return resultobj;
43841 fail:
43842 return NULL;
43843 }
43844
43845
43846 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
43847 PyObject *resultobj;
43848 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43849 wxIndividualLayoutConstraint *result;
43850 PyObject * obj0 = 0 ;
43851 char *kwnames[] = {
43852 (char *) "self", NULL
43853 };
43854
43855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
43856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43857 if (SWIG_arg_fail(1)) SWIG_fail;
43858 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
43859
43860 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43861 return resultobj;
43862 fail:
43863 return NULL;
43864 }
43865
43866
43867 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
43868 PyObject *resultobj;
43869 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43870 wxIndividualLayoutConstraint *result;
43871 PyObject * obj0 = 0 ;
43872 char *kwnames[] = {
43873 (char *) "self", NULL
43874 };
43875
43876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
43877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43878 if (SWIG_arg_fail(1)) SWIG_fail;
43879 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
43880
43881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43882 return resultobj;
43883 fail:
43884 return NULL;
43885 }
43886
43887
43888 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
43889 PyObject *resultobj;
43890 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43891 wxIndividualLayoutConstraint *result;
43892 PyObject * obj0 = 0 ;
43893 char *kwnames[] = {
43894 (char *) "self", NULL
43895 };
43896
43897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
43898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43899 if (SWIG_arg_fail(1)) SWIG_fail;
43900 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
43901
43902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43903 return resultobj;
43904 fail:
43905 return NULL;
43906 }
43907
43908
43909 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
43910 PyObject *resultobj;
43911 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43912 wxIndividualLayoutConstraint *result;
43913 PyObject * obj0 = 0 ;
43914 char *kwnames[] = {
43915 (char *) "self", NULL
43916 };
43917
43918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
43919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43920 if (SWIG_arg_fail(1)) SWIG_fail;
43921 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
43922
43923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43924 return resultobj;
43925 fail:
43926 return NULL;
43927 }
43928
43929
43930 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
43931 PyObject *resultobj;
43932 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43933 wxIndividualLayoutConstraint *result;
43934 PyObject * obj0 = 0 ;
43935 char *kwnames[] = {
43936 (char *) "self", NULL
43937 };
43938
43939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
43940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43941 if (SWIG_arg_fail(1)) SWIG_fail;
43942 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
43943
43944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43945 return resultobj;
43946 fail:
43947 return NULL;
43948 }
43949
43950
43951 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
43952 PyObject *resultobj;
43953 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43954 wxIndividualLayoutConstraint *result;
43955 PyObject * obj0 = 0 ;
43956 char *kwnames[] = {
43957 (char *) "self", NULL
43958 };
43959
43960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
43961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43962 if (SWIG_arg_fail(1)) SWIG_fail;
43963 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
43964
43965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43966 return resultobj;
43967 fail:
43968 return NULL;
43969 }
43970
43971
43972 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
43973 PyObject *resultobj;
43974 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43975 wxIndividualLayoutConstraint *result;
43976 PyObject * obj0 = 0 ;
43977 char *kwnames[] = {
43978 (char *) "self", NULL
43979 };
43980
43981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
43982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43983 if (SWIG_arg_fail(1)) SWIG_fail;
43984 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
43985
43986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43987 return resultobj;
43988 fail:
43989 return NULL;
43990 }
43991
43992
43993 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43994 PyObject *resultobj;
43995 wxLayoutConstraints *result;
43996 char *kwnames[] = {
43997 NULL
43998 };
43999
44000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44001 {
44002 PyThreadState* __tstate = wxPyBeginAllowThreads();
44003 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44004
44005 wxPyEndAllowThreads(__tstate);
44006 if (PyErr_Occurred()) SWIG_fail;
44007 }
44008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44009 return resultobj;
44010 fail:
44011 return NULL;
44012 }
44013
44014
44015 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44016 PyObject *resultobj;
44017 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44018 wxWindow *arg2 = (wxWindow *) 0 ;
44019 int *arg3 = (int *) 0 ;
44020 bool result;
44021 int temp3 ;
44022 int res3 = 0 ;
44023 PyObject * obj0 = 0 ;
44024 PyObject * obj1 = 0 ;
44025 char *kwnames[] = {
44026 (char *) "self",(char *) "win", NULL
44027 };
44028
44029 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44032 if (SWIG_arg_fail(1)) SWIG_fail;
44033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44034 if (SWIG_arg_fail(2)) SWIG_fail;
44035 {
44036 PyThreadState* __tstate = wxPyBeginAllowThreads();
44037 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44038
44039 wxPyEndAllowThreads(__tstate);
44040 if (PyErr_Occurred()) SWIG_fail;
44041 }
44042 {
44043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44044 }
44045 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44046 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44047 return resultobj;
44048 fail:
44049 return NULL;
44050 }
44051
44052
44053 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44054 PyObject *resultobj;
44055 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44056 bool result;
44057 PyObject * obj0 = 0 ;
44058 char *kwnames[] = {
44059 (char *) "self", NULL
44060 };
44061
44062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44064 if (SWIG_arg_fail(1)) SWIG_fail;
44065 {
44066 PyThreadState* __tstate = wxPyBeginAllowThreads();
44067 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44068
44069 wxPyEndAllowThreads(__tstate);
44070 if (PyErr_Occurred()) SWIG_fail;
44071 }
44072 {
44073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44074 }
44075 return resultobj;
44076 fail:
44077 return NULL;
44078 }
44079
44080
44081 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44082 PyObject *obj;
44083 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44084 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44085 Py_INCREF(obj);
44086 return Py_BuildValue((char *)"");
44087 }
44088 static PyMethodDef SwigMethods[] = {
44089 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44090 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44091 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44092 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44093 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44094 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44095 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44096 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44097 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44098 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44099 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44100 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44101 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44102 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44103 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44104 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44105 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44106 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44107 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44108 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44109 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44110 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44111 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44112 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44113 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44114 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44115 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44116 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44117 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44118 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44119 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44120 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44121 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44122 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44123 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44124 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44125 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44126 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44127 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44128 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44129 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44130 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44131 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44132 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44133 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44134 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44135 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44136 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44137 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44138 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44139 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44140 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44141 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44142 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44143 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44144 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44145 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44146 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44147 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44148 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44149 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44150 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44151 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44152 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44153 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44154 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44155 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44156 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44157 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44158 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44159 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44160 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44161 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44162 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44163 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44164 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44165 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44166 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44167 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44168 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44169 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44170 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44171 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44172 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44173 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44174 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44175 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44176 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44177 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44178 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44179 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44180 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44181 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44182 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44183 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44184 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44185 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44186 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44187 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44188 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44189 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44190 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44191 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44192 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44193 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44194 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44195 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44196 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44197 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44198 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44199 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44200 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44201 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44202 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44203 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44204 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44205 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44206 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44207 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44208 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44209 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44210 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44211 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44212 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44213 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44214 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44215 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44216 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44217 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44218 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44219 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44220 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44221 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44222 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44223 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44224 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44225 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44226 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44227 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44228 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44229 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44230 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44231 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44232 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44233 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44234 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44235 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44236 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44237 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44238 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44239 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44240 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44241 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44242 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44243 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44244 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44245 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44246 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44247 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44248 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44249 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44250 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44251 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44252 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44253 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44254 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44255 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44256 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44257 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44258 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44259 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44260 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44261 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44262 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44263 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44264 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44265 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44266 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44267 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44268 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44269 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44270 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44271 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44272 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44273 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44274 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44275 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44276 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44277 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44278 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44279 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44280 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44281 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44282 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44283 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44284 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44285 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44286 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44287 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44288 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44289 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44290 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44291 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44292 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44293 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44294 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44295 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44296 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44297 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44298 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44299 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44300 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44301 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44302 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44303 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44304 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44305 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44306 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44307 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44308 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44309 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44310 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44311 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44312 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44313 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44314 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44315 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44316 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44317 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44318 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44319 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44320 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44321 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44322 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44323 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44324 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44325 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44326 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44327 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44328 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44329 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44330 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44331 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44332 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44333 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44334 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
44335 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44336 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
44337 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44338 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
44339 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
44340 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44341 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44342 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44343 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44344 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44345 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
44346 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44347 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44348 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44349 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44350 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
44351 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
44352 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
44353 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
44354 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
44355 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44356 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44357 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44358 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44359 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44360 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44361 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
44362 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
44363 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44364 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44365 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
44366 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
44367 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
44368 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
44369 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
44370 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44371 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
44372 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44373 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44374 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44375 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44376 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
44377 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
44378 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44379 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44380 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44381 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44382 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
44383 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44384 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44385 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
44386 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44387 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
44388 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44389 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
44390 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44391 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
44392 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44393 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
44394 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44395 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
44396 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44397 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
44398 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44399 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
44400 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44401 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
44402 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44403 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
44404 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44405 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
44406 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44407 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
44408 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
44409 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
44410 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44411 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44412 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44413 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44414 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44415 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44416 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44417 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44418 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44419 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44420 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
44421 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
44422 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44423 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
44424 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44425 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
44426 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44427 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44428 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44429 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44430 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44431 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44432 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44433 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44434 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44435 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
44436 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
44437 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
44438 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44439 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44440 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44441 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
44442 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44443 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44444 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
44445 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44446 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44447 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
44448 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44449 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44450 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44451 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44452 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44453 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44454 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44455 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44456 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44457 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44458 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44459 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
44460 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44461 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44462 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
44463 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
44464 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
44465 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44466 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44467 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44468 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44469 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44470 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
44471 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44472 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44473 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44474 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44475 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44476 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
44477 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44478 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
44479 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
44480 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44481 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
44482 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
44483 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44484 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
44485 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44486 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44487 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44488 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44489 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44490 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44491 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
44492 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
44493 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
44494 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
44495 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
44496 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44497 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44498 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44499 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44500 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44501 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44502 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
44503 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
44504 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
44505 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
44506 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44507 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44508 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44509 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44510 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44511 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
44512 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
44513 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
44514 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
44515 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44516 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44517 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44518 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44519 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44520 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44521 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44522 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44523 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44524 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44525 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44526 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44527 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44528 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44529 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44530 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44531 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44532 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44533 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
44534 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
44535 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
44536 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
44537 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
44538 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
44539 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
44540 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44541 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44542 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44543 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44544 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44545 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44546 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
44547 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44548 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44549 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44550 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44551 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44552 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44553 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
44554 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44555 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44556 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44557 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44558 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44559 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44560 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44561 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44562 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44563 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44564 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44565 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44566 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44567 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44568 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44569 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44570 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44571 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44572 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44573 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44574 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44575 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44576 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44577 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44578 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44579 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44580 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
44581 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
44582 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
44583 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44584 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44585 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44586 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44587 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44588 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
44589 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
44590 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44591 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44592 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
44593 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44594 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44595 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44596 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44597 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44598 { (char *)"MoveEvent_m_pos_set", (PyCFunction) _wrap_MoveEvent_m_pos_set, METH_VARARGS | METH_KEYWORDS, NULL},
44599 { (char *)"MoveEvent_m_pos_get", (PyCFunction) _wrap_MoveEvent_m_pos_get, METH_VARARGS | METH_KEYWORDS, NULL},
44600 { (char *)"MoveEvent_m_rect_set", (PyCFunction) _wrap_MoveEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44601 { (char *)"MoveEvent_m_rect_get", (PyCFunction) _wrap_MoveEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44602 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
44603 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44604 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
44605 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44606 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
44607 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44608 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
44609 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
44610 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44611 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44612 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44613 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
44614 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44615 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44616 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
44617 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44618 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44619 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
44620 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44621 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
44622 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44623 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
44624 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
44625 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44626 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
44627 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44628 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44629 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44630 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44631 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44632 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44633 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44634 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
44635 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44636 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44637 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44638 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
44639 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44640 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
44641 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
44642 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44643 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
44644 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44645 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44646 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44647 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
44648 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44649 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44650 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44651 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44652 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
44653 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44654 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44655 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44656 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44657 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44658 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44659 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44660 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
44661 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
44662 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44663 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44664 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
44665 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44666 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
44667 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44668 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44669 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
44670 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44671 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
44672 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44673 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44674 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44675 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
44676 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44677 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44678 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44679 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
44680 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44681 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44682 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44683 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44684 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44685 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44686 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44687 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44688 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
44689 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44690 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44691 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
44692 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44693 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44694 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
44695 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44696 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44697 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44698 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
44699 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44700 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
44701 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
44702 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44703 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44704 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
44705 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
44706 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44707 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44708 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44709 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44710 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
44711 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44712 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44713 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44714 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44715 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
44716 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44717 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44718 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44719 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44720 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44721 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44722 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44723 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44724 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44725 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
44726 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44727 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44728 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44729 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44730 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44731 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44732 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44734 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44735 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44736 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44737 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
44738 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44739 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44740 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44741 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44742 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44744 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44745 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44746 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44748 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44749 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44750 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44751 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44752 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44754 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44756 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44757 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44758 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
44759 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
44761 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44762 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
44764 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
44768 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44772 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
44781 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44785 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
44788 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
44792 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
44802 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
44971 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45013 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45027 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45030 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45085 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45112 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45156 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45164 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45181 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45182 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45219 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45249 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45252 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45256 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45259 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45269 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
45281 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45291 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45301 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
45315 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
45322 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
45323 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
45324 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
45325 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
45326 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
45331 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
45358 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
45370 { NULL, NULL, 0, NULL }
45371 };
45372
45373
45374 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
45375
45376 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
45377 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
45378 }
45379 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
45380 return (void *)((wxSizer *) ((wxBoxSizer *) x));
45381 }
45382 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
45383 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
45384 }
45385 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
45386 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45387 }
45388 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
45389 return (void *)((wxSizer *) ((wxGridSizer *) x));
45390 }
45391 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
45392 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
45393 }
45394 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
45395 return (void *)((wxSizer *) ((wxPySizer *) x));
45396 }
45397 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
45398 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
45399 }
45400 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
45401 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
45402 }
45403 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
45404 return (void *)((wxEvent *) ((wxMenuEvent *) x));
45405 }
45406 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
45407 return (void *)((wxEvent *) ((wxCloseEvent *) x));
45408 }
45409 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
45410 return (void *)((wxEvent *) ((wxMouseEvent *) x));
45411 }
45412 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
45413 return (void *)((wxEvent *) ((wxEraseEvent *) x));
45414 }
45415 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
45416 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
45417 }
45418 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
45419 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
45420 }
45421 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
45422 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
45423 }
45424 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
45425 return (void *)((wxEvent *) ((wxPyEvent *) x));
45426 }
45427 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
45428 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
45429 }
45430 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
45431 return (void *)((wxEvent *) ((wxIdleEvent *) x));
45432 }
45433 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
45434 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
45435 }
45436 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
45437 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
45438 }
45439 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
45440 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
45441 }
45442 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
45443 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
45444 }
45445 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
45446 return (void *)((wxEvent *) ((wxActivateEvent *) x));
45447 }
45448 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
45449 return (void *)((wxEvent *) ((wxSizeEvent *) x));
45450 }
45451 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
45452 return (void *)((wxEvent *) ((wxMoveEvent *) x));
45453 }
45454 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
45455 return (void *)((wxEvent *) ((wxPaintEvent *) x));
45456 }
45457 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
45458 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
45459 }
45460 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
45461 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
45462 }
45463 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
45464 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
45465 }
45466 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
45467 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
45468 }
45469 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
45470 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45471 }
45472 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
45473 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
45474 }
45475 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
45476 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
45477 }
45478 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
45479 return (void *)((wxEvent *) ((wxFocusEvent *) x));
45480 }
45481 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
45482 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
45483 }
45484 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
45485 return (void *)((wxEvent *) ((wxShowEvent *) x));
45486 }
45487 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
45488 return (void *)((wxEvent *) ((wxCommandEvent *) x));
45489 }
45490 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
45491 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
45492 }
45493 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
45494 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45495 }
45496 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
45497 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
45498 }
45499 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
45500 return (void *)((wxEvent *) ((wxKeyEvent *) x));
45501 }
45502 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
45503 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
45504 }
45505 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
45506 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
45507 }
45508 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
45509 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
45510 }
45511 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
45512 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
45513 }
45514 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
45515 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
45516 }
45517 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
45518 return (void *)((wxControl *) ((wxControlWithItems *) x));
45519 }
45520 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
45521 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
45522 }
45523 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
45524 return (void *)((wxEvtHandler *) ((wxWindow *) x));
45525 }
45526 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
45527 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45528 }
45529 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
45530 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
45531 }
45532 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
45533 return (void *)((wxEvtHandler *) ((wxValidator *) x));
45534 }
45535 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
45536 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
45537 }
45538 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
45539 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
45540 }
45541 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
45542 return (void *)((wxEvtHandler *) ((wxMenu *) x));
45543 }
45544 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
45545 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
45546 }
45547 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
45548 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
45549 }
45550 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
45551 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
45552 }
45553 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
45554 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
45555 }
45556 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
45557 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
45558 }
45559 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
45560 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45561 }
45562 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
45563 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
45564 }
45565 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
45566 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
45567 }
45568 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
45569 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45570 }
45571 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
45572 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45573 }
45574 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
45575 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
45576 }
45577 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
45578 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
45579 }
45580 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
45581 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
45582 }
45583 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
45584 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
45585 }
45586 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
45587 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
45588 }
45589 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
45590 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
45591 }
45592 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
45593 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
45594 }
45595 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
45596 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
45597 }
45598 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
45599 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
45600 }
45601 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
45602 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
45603 }
45604 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
45605 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
45606 }
45607 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
45608 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
45609 }
45610 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
45611 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
45612 }
45613 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
45614 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
45615 }
45616 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
45617 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
45618 }
45619 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
45620 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
45621 }
45622 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
45623 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
45624 }
45625 static void *_p_wxValidatorTo_p_wxObject(void *x) {
45626 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
45627 }
45628 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
45629 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
45630 }
45631 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
45632 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
45633 }
45634 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
45635 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
45636 }
45637 static void *_p_wxSizerTo_p_wxObject(void *x) {
45638 return (void *)((wxObject *) ((wxSizer *) x));
45639 }
45640 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
45641 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
45642 }
45643 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
45644 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
45645 }
45646 static void *_p_wxMenuTo_p_wxObject(void *x) {
45647 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
45648 }
45649 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
45650 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
45651 }
45652 static void *_p_wxImageTo_p_wxObject(void *x) {
45653 return (void *)((wxObject *) ((wxImage *) x));
45654 }
45655 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
45656 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
45657 }
45658 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
45659 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
45660 }
45661 static void *_p_wxPyEventTo_p_wxObject(void *x) {
45662 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
45663 }
45664 static void *_p_wxWindowTo_p_wxObject(void *x) {
45665 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
45666 }
45667 static void *_p_wxControlTo_p_wxObject(void *x) {
45668 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
45669 }
45670 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
45671 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
45672 }
45673 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
45674 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
45675 }
45676 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
45677 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
45678 }
45679 static void *_p_wxPyAppTo_p_wxObject(void *x) {
45680 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
45681 }
45682 static void *_p_wxEventTo_p_wxObject(void *x) {
45683 return (void *)((wxObject *) ((wxEvent *) x));
45684 }
45685 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
45686 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
45687 }
45688 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
45689 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
45690 }
45691 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
45692 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
45693 }
45694 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
45695 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
45696 }
45697 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
45698 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
45699 }
45700 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
45701 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
45702 }
45703 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
45704 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
45705 }
45706 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
45707 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
45708 }
45709 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
45710 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45711 }
45712 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
45713 return (void *)((wxObject *) ((wxEvtHandler *) x));
45714 }
45715 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
45716 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
45717 }
45718 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
45719 return (void *)((wxObject *) ((wxImageHandler *) x));
45720 }
45721 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
45722 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
45723 }
45724 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
45725 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
45726 }
45727 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
45728 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45729 }
45730 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
45731 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45732 }
45733 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
45734 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
45735 }
45736 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
45737 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
45738 }
45739 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
45740 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
45741 }
45742 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
45743 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
45744 }
45745 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
45746 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
45747 }
45748 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
45749 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
45750 }
45751 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
45752 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
45753 }
45754 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
45755 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
45756 }
45757 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
45758 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
45759 }
45760 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
45761 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
45762 }
45763 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
45764 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45765 }
45766 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
45767 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
45768 }
45769 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
45770 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
45771 }
45772 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
45773 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
45774 }
45775 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
45776 return (void *)((wxObject *) ((wxFileSystem *) x));
45777 }
45778 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
45779 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
45780 }
45781 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
45782 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
45783 }
45784 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
45785 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
45786 }
45787 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
45788 return (void *)((wxObject *) ((wxSizerItem *) x));
45789 }
45790 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
45791 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
45792 }
45793 static void *_p_wxShowEventTo_p_wxObject(void *x) {
45794 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
45795 }
45796 static void *_p_wxFSFileTo_p_wxObject(void *x) {
45797 return (void *)((wxObject *) ((wxFSFile *) x));
45798 }
45799 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
45800 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
45801 }
45802 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
45803 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
45804 }
45805 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
45806 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
45807 }
45808 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
45809 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
45810 }
45811 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
45812 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45813 }
45814 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
45815 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45816 }
45817 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
45818 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
45819 }
45820 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
45821 return (void *)((wxObject *) ((wxMenuItem *) x));
45822 }
45823 static void *_p_wxPySizerTo_p_wxObject(void *x) {
45824 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
45825 }
45826 static void *_p_wxControlTo_p_wxWindow(void *x) {
45827 return (void *)((wxWindow *) ((wxControl *) x));
45828 }
45829 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
45830 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
45831 }
45832 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
45833 return (void *)((wxWindow *) ((wxMenuBar *) x));
45834 }
45835 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
45836 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
45837 }
45838 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
45839 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
45840 }
45841 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
45842 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
45843 }
45844 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
45845 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
45846 }
45847 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
45848 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45849 }
45850 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
45851 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
45852 }
45853 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
45854 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
45855 }
45856 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
45857 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
45858 }
45859 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
45860 return (void *)((wxValidator *) ((wxPyValidator *) x));
45861 }
45862 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}};
45863 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}};
45864 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}};
45865 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}};
45866 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}};
45867 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}};
45868 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}};
45869 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}};
45870 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}};
45871 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}};
45872 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}};
45873 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}};
45874 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}};
45875 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}};
45876 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}};
45877 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}};
45878 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}};
45879 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}};
45880 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}};
45881 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}};
45882 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}};
45883 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}};
45884 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}};
45885 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}};
45886 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}};
45887 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}};
45888 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}};
45889 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}};
45890 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}};
45891 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}};
45892 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}};
45893 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}};
45894 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}};
45895 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}};
45896 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}};
45897 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}};
45898 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}};
45899 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}};
45900 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}};
45901 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}};
45902 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}};
45903 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}};
45904 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}};
45905 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}};
45906 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}};
45907 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}};
45908 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}};
45909 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}};
45910 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}};
45911 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}};
45912 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}};
45913 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}};
45914 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}};
45915 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}};
45916 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}};
45917 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}};
45918 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}};
45919 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}};
45920 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}};
45921 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}};
45922 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}};
45923 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}};
45924 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}};
45925 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}};
45926 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}};
45927 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}};
45928 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}};
45929 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}};
45930 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}};
45931 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}};
45932 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}};
45933 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}};
45934 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}};
45935 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}};
45936 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}};
45937 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}};
45938 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}};
45939 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}};
45940 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}};
45941 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}};
45942 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}};
45943 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}};
45944 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}};
45945 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}};
45946 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}};
45947 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}};
45948 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}};
45949 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}};
45950 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}};
45951 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}};
45952 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}};
45953 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}};
45954 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}};
45955 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}};
45956 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}};
45957 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}};
45958 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}};
45959 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}};
45960 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}};
45961 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}};
45962 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}};
45963 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}};
45964 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}};
45965 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}};
45966 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}};
45967 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}};
45968 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}};
45969 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}};
45970 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}};
45971 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}};
45972 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}};
45973 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}};
45974 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}};
45975 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}};
45976 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}};
45977 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}};
45978 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}};
45979 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}};
45980 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}};
45981 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}};
45982 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}};
45983 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}};
45984 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}};
45985 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}};
45986
45987 static swig_type_info *swig_types_initial[] = {
45988 _swigt__p_wxLayoutConstraints,
45989 _swigt__p_wxRealPoint,
45990 _swigt__p_wxSizerItem,
45991 _swigt__p_wxGBSizerItem,
45992 _swigt__p_wxScrollEvent,
45993 _swigt__p_wxEventLoop,
45994 _swigt__p_wxIndividualLayoutConstraint,
45995 _swigt__p_wxSizer,
45996 _swigt__p_wxBoxSizer,
45997 _swigt__p_wxStaticBoxSizer,
45998 _swigt__p_wxGridBagSizer,
45999 _swigt__p_wxAcceleratorEntry,
46000 _swigt__p_wxUpdateUIEvent,
46001 _swigt__p_wxEvent,
46002 _swigt__p_wxMenu,
46003 _swigt__p_wxGridSizer,
46004 _swigt__p_wxFlexGridSizer,
46005 _swigt__p_wxInitDialogEvent,
46006 _swigt__p_wxItemContainer,
46007 _swigt__p_wxNcPaintEvent,
46008 _swigt__p_wxPaintEvent,
46009 _swigt__p_wxSysColourChangedEvent,
46010 _swigt__p_wxMouseCaptureChangedEvent,
46011 _swigt__p_wxDisplayChangedEvent,
46012 _swigt__p_wxPaletteChangedEvent,
46013 _swigt__p_wxControl,
46014 _swigt__p_wxFont,
46015 _swigt__p_wxMenuBarBase,
46016 _swigt__p_wxSetCursorEvent,
46017 _swigt__p_wxFSFile,
46018 _swigt__p_wxCaret,
46019 _swigt__ptrdiff_t,
46020 _swigt__std__ptrdiff_t,
46021 _swigt__p_wxRegion,
46022 _swigt__p_wxPoint2D,
46023 _swigt__p_int,
46024 _swigt__p_wxSize,
46025 _swigt__p_wxDC,
46026 _swigt__p_wxPySizer,
46027 _swigt__p_wxVisualAttributes,
46028 _swigt__p_wxNotifyEvent,
46029 _swigt__p_wxPyEvent,
46030 _swigt__p_wxPropagationDisabler,
46031 _swigt__p_form_ops_t,
46032 _swigt__p_wxAppTraits,
46033 _swigt__p_wxArrayString,
46034 _swigt__p_wxShowEvent,
46035 _swigt__p_wxToolTip,
46036 _swigt__p_wxMoveEvent,
46037 _swigt__p_wxSizeEvent,
46038 _swigt__p_wxActivateEvent,
46039 _swigt__p_wxIconizeEvent,
46040 _swigt__p_wxMaximizeEvent,
46041 _swigt__p_wxQueryNewPaletteEvent,
46042 _swigt__p_wxWindowCreateEvent,
46043 _swigt__p_wxIdleEvent,
46044 _swigt__p_wxMenuItem,
46045 _swigt__p_wxStaticBox,
46046 _swigt__p_long,
46047 _swigt__p_wxDuplexMode,
46048 _swigt__p_wxTIFFHandler,
46049 _swigt__p_wxXPMHandler,
46050 _swigt__p_wxPNMHandler,
46051 _swigt__p_wxJPEGHandler,
46052 _swigt__p_wxPCXHandler,
46053 _swigt__p_wxGIFHandler,
46054 _swigt__p_wxPNGHandler,
46055 _swigt__p_wxANIHandler,
46056 _swigt__p_wxMemoryFSHandler,
46057 _swigt__p_wxZipFSHandler,
46058 _swigt__p_wxInternetFSHandler,
46059 _swigt__p_wxPyFileSystemHandler,
46060 _swigt__p_wxEvtHandler,
46061 _swigt__p_wxCURHandler,
46062 _swigt__p_wxICOHandler,
46063 _swigt__p_wxBMPHandler,
46064 _swigt__p_wxImageHandler,
46065 _swigt__p_wxFileSystemHandler,
46066 _swigt__p_wxRect,
46067 _swigt__p_wxGBSpan,
46068 _swigt__p_wxPropagateOnce,
46069 _swigt__p_wxAcceleratorTable,
46070 _swigt__p_char,
46071 _swigt__p_wxGBPosition,
46072 _swigt__p_wxImage,
46073 _swigt__p_wxFrame,
46074 _swigt__p_wxScrollWinEvent,
46075 _swigt__p_wxPaperSize,
46076 _swigt__p_wxImageHistogram,
46077 _swigt__p_wxPoint,
46078 _swigt__p_wxCursor,
46079 _swigt__p_wxObject,
46080 _swigt__p_wxInputStream,
46081 _swigt__p_wxOutputStream,
46082 _swigt__p_wxPyInputStream,
46083 _swigt__p_wxDateTime,
46084 _swigt__p_wxKeyEvent,
46085 _swigt__p_wxNavigationKeyEvent,
46086 _swigt__p_wxWindowDestroyEvent,
46087 _swigt__p_unsigned_long,
46088 _swigt__p_wxWindow,
46089 _swigt__p_wxMenuBar,
46090 _swigt__p_wxFileSystem,
46091 _swigt__p_wxBitmap,
46092 _swigt__unsigned_int,
46093 _swigt__p_unsigned_int,
46094 _swigt__p_wxMenuEvent,
46095 _swigt__p_wxContextMenuEvent,
46096 _swigt__p_unsigned_char,
46097 _swigt__p_wxEraseEvent,
46098 _swigt__p_wxMouseEvent,
46099 _swigt__p_wxCloseEvent,
46100 _swigt__p_wxPyApp,
46101 _swigt__p_wxCommandEvent,
46102 _swigt__p_wxPyCommandEvent,
46103 _swigt__p_wxPyDropTarget,
46104 _swigt__p_wxQuantize,
46105 _swigt__p_wxChildFocusEvent,
46106 _swigt__p_wxFocusEvent,
46107 _swigt__p_wxDropFilesEvent,
46108 _swigt__p_wxControlWithItems,
46109 _swigt__p_wxColour,
46110 _swigt__p_wxValidator,
46111 _swigt__p_wxPyValidator,
46112 0
46113 };
46114
46115
46116 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46117
46118 static swig_const_info swig_const_table[] = {
46119 {0, 0, 0, 0.0, 0, 0}};
46120
46121 #ifdef __cplusplus
46122 }
46123 #endif
46124
46125
46126 #ifdef __cplusplus
46127 extern "C" {
46128 #endif
46129
46130 /* Python-specific SWIG API */
46131 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46132 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46133 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46134
46135 /* -----------------------------------------------------------------------------
46136 * global variable support code.
46137 * ----------------------------------------------------------------------------- */
46138
46139 typedef struct swig_globalvar {
46140 char *name; /* Name of global variable */
46141 PyObject *(*get_attr)(); /* Return the current value */
46142 int (*set_attr)(PyObject *); /* Set the value */
46143 struct swig_globalvar *next;
46144 } swig_globalvar;
46145
46146 typedef struct swig_varlinkobject {
46147 PyObject_HEAD
46148 swig_globalvar *vars;
46149 } swig_varlinkobject;
46150
46151 static PyObject *
46152 swig_varlink_repr(swig_varlinkobject *v) {
46153 v = v;
46154 return PyString_FromString("<Swig global variables>");
46155 }
46156
46157 static int
46158 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46159 swig_globalvar *var;
46160 flags = flags;
46161 fprintf(fp,"Swig global variables { ");
46162 for (var = v->vars; var; var=var->next) {
46163 fprintf(fp,"%s", var->name);
46164 if (var->next) fprintf(fp,", ");
46165 }
46166 fprintf(fp," }\n");
46167 return 0;
46168 }
46169
46170 static PyObject *
46171 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46172 swig_globalvar *var = v->vars;
46173 while (var) {
46174 if (strcmp(var->name,n) == 0) {
46175 return (*var->get_attr)();
46176 }
46177 var = var->next;
46178 }
46179 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46180 return NULL;
46181 }
46182
46183 static int
46184 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46185 swig_globalvar *var = v->vars;
46186 while (var) {
46187 if (strcmp(var->name,n) == 0) {
46188 return (*var->set_attr)(p);
46189 }
46190 var = var->next;
46191 }
46192 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46193 return 1;
46194 }
46195
46196 static PyTypeObject varlinktype = {
46197 PyObject_HEAD_INIT(0)
46198 0, /* Number of items in variable part (ob_size) */
46199 (char *)"swigvarlink", /* Type name (tp_name) */
46200 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46201 0, /* Itemsize (tp_itemsize) */
46202 0, /* Deallocator (tp_dealloc) */
46203 (printfunc) swig_varlink_print, /* Print (tp_print) */
46204 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46205 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46206 0, /* tp_compare */
46207 (reprfunc) swig_varlink_repr, /* tp_repr */
46208 0, /* tp_as_number */
46209 0, /* tp_as_sequence */
46210 0, /* tp_as_mapping */
46211 0, /* tp_hash */
46212 0, /* tp_call */
46213 0, /* tp_str */
46214 0, /* tp_getattro */
46215 0, /* tp_setattro */
46216 0, /* tp_as_buffer */
46217 0, /* tp_flags */
46218 0, /* tp_doc */
46219 #if PY_VERSION_HEX >= 0x02000000
46220 0, /* tp_traverse */
46221 0, /* tp_clear */
46222 #endif
46223 #if PY_VERSION_HEX >= 0x02010000
46224 0, /* tp_richcompare */
46225 0, /* tp_weaklistoffset */
46226 #endif
46227 #if PY_VERSION_HEX >= 0x02020000
46228 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46229 #endif
46230 #if PY_VERSION_HEX >= 0x02030000
46231 0, /* tp_del */
46232 #endif
46233 #ifdef COUNT_ALLOCS
46234 0,0,0,0 /* tp_alloc -> tp_next */
46235 #endif
46236 };
46237
46238 /* Create a variable linking object for use later */
46239 static PyObject *
46240 SWIG_Python_newvarlink(void) {
46241 swig_varlinkobject *result = 0;
46242 result = PyMem_NEW(swig_varlinkobject,1);
46243 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
46244 result->ob_type = &varlinktype;
46245 result->vars = 0;
46246 result->ob_refcnt = 0;
46247 Py_XINCREF((PyObject *) result);
46248 return ((PyObject*) result);
46249 }
46250
46251 static void
46252 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
46253 swig_varlinkobject *v;
46254 swig_globalvar *gv;
46255 v= (swig_varlinkobject *) p;
46256 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46257 gv->name = (char *) malloc(strlen(name)+1);
46258 strcpy(gv->name,name);
46259 gv->get_attr = get_attr;
46260 gv->set_attr = set_attr;
46261 gv->next = v->vars;
46262 v->vars = gv;
46263 }
46264
46265 /* -----------------------------------------------------------------------------
46266 * constants/methods manipulation
46267 * ----------------------------------------------------------------------------- */
46268
46269 /* Install Constants */
46270 static void
46271 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46272 PyObject *obj = 0;
46273 size_t i;
46274 for (i = 0; constants[i].type; i++) {
46275 switch(constants[i].type) {
46276 case SWIG_PY_INT:
46277 obj = PyInt_FromLong(constants[i].lvalue);
46278 break;
46279 case SWIG_PY_FLOAT:
46280 obj = PyFloat_FromDouble(constants[i].dvalue);
46281 break;
46282 case SWIG_PY_STRING:
46283 if (constants[i].pvalue) {
46284 obj = PyString_FromString((char *) constants[i].pvalue);
46285 } else {
46286 Py_INCREF(Py_None);
46287 obj = Py_None;
46288 }
46289 break;
46290 case SWIG_PY_POINTER:
46291 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
46292 break;
46293 case SWIG_PY_BINARY:
46294 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
46295 break;
46296 default:
46297 obj = 0;
46298 break;
46299 }
46300 if (obj) {
46301 PyDict_SetItemString(d,constants[i].name,obj);
46302 Py_DECREF(obj);
46303 }
46304 }
46305 }
46306
46307 /* -----------------------------------------------------------------------------*/
46308 /* Fix SwigMethods to carry the callback ptrs when needed */
46309 /* -----------------------------------------------------------------------------*/
46310
46311 static void
46312 SWIG_Python_FixMethods(PyMethodDef *methods,
46313 swig_const_info *const_table,
46314 swig_type_info **types,
46315 swig_type_info **types_initial) {
46316 size_t i;
46317 for (i = 0; methods[i].ml_name; ++i) {
46318 char *c = methods[i].ml_doc;
46319 if (c && (c = strstr(c, "swig_ptr: "))) {
46320 int j;
46321 swig_const_info *ci = 0;
46322 char *name = c + 10;
46323 for (j = 0; const_table[j].type; j++) {
46324 if (strncmp(const_table[j].name, name,
46325 strlen(const_table[j].name)) == 0) {
46326 ci = &(const_table[j]);
46327 break;
46328 }
46329 }
46330 if (ci) {
46331 size_t shift = (ci->ptype) - types;
46332 swig_type_info *ty = types_initial[shift];
46333 size_t ldoc = (c - methods[i].ml_doc);
46334 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
46335 char *ndoc = (char*)malloc(ldoc + lptr + 10);
46336 char *buff = ndoc;
46337 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
46338 strncpy(buff, methods[i].ml_doc, ldoc);
46339 buff += ldoc;
46340 strncpy(buff, "swig_ptr: ", 10);
46341 buff += 10;
46342 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
46343 methods[i].ml_doc = ndoc;
46344 }
46345 }
46346 }
46347 }
46348
46349 /* -----------------------------------------------------------------------------*
46350 * Initialize type list
46351 * -----------------------------------------------------------------------------*/
46352
46353 #if PY_MAJOR_VERSION < 2
46354 /* PyModule_AddObject function was introduced in Python 2.0. The following function
46355 is copied out of Python/modsupport.c in python version 2.3.4 */
46356 static int
46357 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
46358 {
46359 PyObject *dict;
46360 if (!PyModule_Check(m)) {
46361 PyErr_SetString(PyExc_TypeError,
46362 "PyModule_AddObject() needs module as first arg");
46363 return -1;
46364 }
46365 if (!o) {
46366 PyErr_SetString(PyExc_TypeError,
46367 "PyModule_AddObject() needs non-NULL value");
46368 return -1;
46369 }
46370
46371 dict = PyModule_GetDict(m);
46372 if (dict == NULL) {
46373 /* Internal error -- modules must have a dict! */
46374 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
46375 PyModule_GetName(m));
46376 return -1;
46377 }
46378 if (PyDict_SetItemString(dict, name, o))
46379 return -1;
46380 Py_DECREF(o);
46381 return 0;
46382 }
46383 #endif
46384
46385 static swig_type_info **
46386 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
46387 static PyMethodDef swig_empty_runtime_method_table[] = {
46388 {
46389 NULL, NULL, 0, NULL
46390 }
46391 };/* Sentinel */
46392
46393 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
46394 swig_empty_runtime_method_table);
46395 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
46396 if (pointer && module) {
46397 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
46398 }
46399 return type_list_handle;
46400 }
46401
46402 static swig_type_info **
46403 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
46404 swig_type_info **type_pointer;
46405
46406 /* first check if module already created */
46407 type_pointer = SWIG_Python_GetTypeListHandle();
46408 if (type_pointer) {
46409 return type_pointer;
46410 } else {
46411 /* create a new module and variable */
46412 return SWIG_Python_SetTypeListHandle(type_list_handle);
46413 }
46414 }
46415
46416 #ifdef __cplusplus
46417 }
46418 #endif
46419
46420 /* -----------------------------------------------------------------------------*
46421 * Partial Init method
46422 * -----------------------------------------------------------------------------*/
46423
46424 #ifdef SWIG_LINK_RUNTIME
46425 #ifdef __cplusplus
46426 extern "C"
46427 #endif
46428 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
46429 #endif
46430
46431 #ifdef __cplusplus
46432 extern "C"
46433 #endif
46434 SWIGEXPORT(void) SWIG_init(void) {
46435 static PyObject *SWIG_globals = 0;
46436 static int typeinit = 0;
46437 PyObject *m, *d;
46438 int i;
46439 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
46440
46441 /* Fix SwigMethods to carry the callback ptrs when needed */
46442 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
46443
46444 m = Py_InitModule((char *) SWIG_name, SwigMethods);
46445 d = PyModule_GetDict(m);
46446
46447 if (!typeinit) {
46448 #ifdef SWIG_LINK_RUNTIME
46449 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
46450 #else
46451 # ifndef SWIG_STATIC_RUNTIME
46452 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
46453 # endif
46454 #endif
46455 for (i = 0; swig_types_initial[i]; i++) {
46456 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
46457 }
46458 typeinit = 1;
46459 }
46460 SWIG_InstallConstants(d,swig_const_table);
46461
46462
46463 #ifndef wxPyUSE_EXPORT
46464 // Make our API structure a CObject so other modules can import it
46465 // from this module.
46466 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
46467 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
46468 Py_XDECREF(cobj);
46469 #endif
46470
46471 {
46472 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
46473 }
46474 {
46475 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
46476 }
46477 {
46478 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
46479 }
46480 {
46481 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
46482 }
46483 {
46484 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
46485 }
46486 {
46487 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
46488 }
46489 {
46490 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
46491 }
46492 {
46493 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
46494 }
46495 {
46496 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
46497 }
46498 {
46499 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
46500 }
46501 {
46502 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
46503 }
46504 {
46505 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
46506 }
46507 {
46508 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
46509 }
46510 {
46511 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
46512 }
46513 {
46514 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
46515 }
46516 {
46517 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
46518 }
46519 {
46520 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
46521 }
46522 {
46523 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
46524 }
46525 {
46526 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
46527 }
46528 {
46529 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
46530 }
46531 {
46532 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
46533 }
46534 {
46535 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
46536 }
46537 {
46538 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
46539 }
46540 {
46541 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
46542 }
46543 {
46544 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
46545 }
46546 {
46547 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
46548 }
46549 {
46550 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
46551 }
46552 {
46553 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
46554 }
46555 {
46556 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
46557 }
46558 {
46559 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
46560 }
46561 {
46562 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
46563 }
46564 {
46565 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
46566 }
46567 {
46568 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
46569 }
46570 {
46571 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
46572 }
46573 {
46574 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
46575 }
46576 {
46577 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
46578 }
46579 {
46580 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
46581 }
46582 {
46583 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
46584 }
46585 {
46586 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
46587 }
46588 {
46589 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
46590 }
46591 {
46592 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
46593 }
46594 {
46595 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
46596 }
46597 {
46598 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
46599 }
46600 {
46601 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
46602 }
46603 {
46604 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
46605 }
46606 {
46607 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
46608 }
46609 {
46610 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
46611 }
46612 {
46613 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
46614 }
46615 {
46616 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
46617 }
46618 {
46619 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
46620 }
46621 {
46622 PyDict_SetItemString(d,"SL_HORIZONTAL", SWIG_From_int((int)(wxSL_HORIZONTAL)));
46623 }
46624 {
46625 PyDict_SetItemString(d,"SL_VERTICAL", SWIG_From_int((int)(wxSL_VERTICAL)));
46626 }
46627 {
46628 PyDict_SetItemString(d,"SL_AUTOTICKS", SWIG_From_int((int)(wxSL_AUTOTICKS)));
46629 }
46630 {
46631 PyDict_SetItemString(d,"SL_LABELS", SWIG_From_int((int)(wxSL_LABELS)));
46632 }
46633 {
46634 PyDict_SetItemString(d,"SL_LEFT", SWIG_From_int((int)(wxSL_LEFT)));
46635 }
46636 {
46637 PyDict_SetItemString(d,"SL_TOP", SWIG_From_int((int)(wxSL_TOP)));
46638 }
46639 {
46640 PyDict_SetItemString(d,"SL_RIGHT", SWIG_From_int((int)(wxSL_RIGHT)));
46641 }
46642 {
46643 PyDict_SetItemString(d,"SL_BOTTOM", SWIG_From_int((int)(wxSL_BOTTOM)));
46644 }
46645 {
46646 PyDict_SetItemString(d,"SL_BOTH", SWIG_From_int((int)(wxSL_BOTH)));
46647 }
46648 {
46649 PyDict_SetItemString(d,"SL_SELRANGE", SWIG_From_int((int)(wxSL_SELRANGE)));
46650 }
46651 {
46652 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
46653 }
46654 {
46655 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
46656 }
46657 {
46658 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
46659 }
46660 {
46661 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
46662 }
46663 {
46664 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
46665 }
46666 {
46667 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
46668 }
46669 {
46670 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
46671 }
46672 {
46673 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
46674 }
46675 {
46676 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
46677 }
46678 {
46679 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
46680 }
46681 {
46682 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
46683 }
46684 {
46685 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
46686 }
46687 {
46688 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
46689 }
46690 {
46691 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
46692 }
46693 {
46694 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
46695 }
46696 {
46697 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
46698 }
46699 {
46700 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
46701 }
46702 {
46703 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
46704 }
46705 {
46706 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
46707 }
46708 {
46709 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
46710 }
46711 {
46712 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
46713 }
46714 {
46715 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
46716 }
46717 {
46718 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
46719 }
46720 {
46721 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
46722 }
46723 {
46724 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
46725 }
46726 {
46727 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
46728 }
46729 {
46730 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
46731 }
46732 {
46733 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
46734 }
46735 {
46736 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
46737 }
46738 {
46739 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
46740 }
46741 {
46742 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
46743 }
46744 {
46745 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
46746 }
46747 {
46748 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
46749 }
46750 {
46751 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
46752 }
46753 {
46754 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
46755 }
46756 {
46757 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
46758 }
46759 {
46760 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
46761 }
46762 {
46763 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
46764 }
46765 {
46766 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
46767 }
46768 {
46769 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
46770 }
46771 {
46772 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
46773 }
46774 {
46775 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
46776 }
46777 {
46778 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
46779 }
46780 {
46781 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
46782 }
46783 {
46784 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
46785 }
46786 {
46787 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
46788 }
46789 {
46790 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
46791 }
46792 {
46793 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
46794 }
46795 {
46796 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
46797 }
46798 {
46799 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
46800 }
46801 {
46802 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
46803 }
46804 {
46805 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
46806 }
46807 {
46808 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
46809 }
46810 {
46811 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
46812 }
46813 {
46814 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
46815 }
46816 {
46817 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
46818 }
46819 {
46820 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
46821 }
46822 {
46823 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
46824 }
46825 {
46826 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
46827 }
46828 {
46829 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
46830 }
46831 {
46832 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
46833 }
46834 {
46835 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
46836 }
46837 {
46838 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
46839 }
46840 {
46841 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
46842 }
46843 {
46844 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
46845 }
46846 {
46847 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
46848 }
46849 {
46850 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
46851 }
46852 {
46853 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
46854 }
46855 {
46856 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
46857 }
46858 {
46859 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
46860 }
46861 {
46862 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
46863 }
46864 {
46865 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
46866 }
46867 {
46868 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
46869 }
46870 {
46871 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
46872 }
46873 {
46874 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
46875 }
46876 {
46877 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
46878 }
46879 {
46880 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
46881 }
46882 {
46883 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
46884 }
46885 {
46886 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
46887 }
46888 {
46889 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
46890 }
46891 {
46892 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
46893 }
46894 {
46895 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
46896 }
46897 {
46898 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
46899 }
46900 {
46901 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
46902 }
46903 {
46904 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
46905 }
46906 {
46907 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
46908 }
46909 {
46910 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
46911 }
46912 {
46913 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
46914 }
46915 {
46916 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
46917 }
46918 {
46919 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
46920 }
46921 {
46922 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
46923 }
46924 {
46925 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
46926 }
46927 {
46928 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
46929 }
46930 {
46931 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
46932 }
46933 {
46934 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
46935 }
46936 {
46937 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
46938 }
46939 {
46940 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
46941 }
46942 {
46943 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
46944 }
46945 {
46946 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
46947 }
46948 {
46949 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
46950 }
46951 {
46952 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
46953 }
46954 {
46955 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
46956 }
46957 {
46958 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
46959 }
46960 {
46961 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
46962 }
46963 {
46964 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
46965 }
46966 {
46967 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
46968 }
46969 {
46970 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
46971 }
46972 {
46973 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
46974 }
46975 {
46976 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
46977 }
46978 {
46979 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
46980 }
46981 {
46982 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
46983 }
46984 {
46985 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
46986 }
46987 {
46988 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
46989 }
46990 {
46991 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
46992 }
46993 {
46994 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
46995 }
46996 {
46997 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
46998 }
46999 {
47000 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47001 }
47002 {
47003 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47004 }
47005 {
47006 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47007 }
47008 {
47009 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47010 }
47011 {
47012 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47013 }
47014 {
47015 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47016 }
47017 {
47018 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47019 }
47020 {
47021 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47022 }
47023 {
47024 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47025 }
47026 {
47027 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47028 }
47029 {
47030 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47031 }
47032 {
47033 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47034 }
47035 {
47036 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47037 }
47038 {
47039 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47040 }
47041 {
47042 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47043 }
47044 {
47045 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47046 }
47047 {
47048 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47049 }
47050 {
47051 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47052 }
47053 {
47054 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47055 }
47056 {
47057 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47058 }
47059 {
47060 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47061 }
47062 {
47063 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47064 }
47065 {
47066 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47067 }
47068 {
47069 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47070 }
47071 {
47072 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47073 }
47074 {
47075 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47076 }
47077 {
47078 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47079 }
47080 {
47081 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47082 }
47083 {
47084 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47085 }
47086 {
47087 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47088 }
47089 {
47090 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47091 }
47092 {
47093 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47094 }
47095 {
47096 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47097 }
47098 {
47099 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47100 }
47101 {
47102 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47103 }
47104 {
47105 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47106 }
47107 {
47108 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47109 }
47110 {
47111 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47112 }
47113 {
47114 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47115 }
47116 {
47117 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47118 }
47119 {
47120 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47121 }
47122 {
47123 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47124 }
47125 {
47126 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47127 }
47128 {
47129 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47130 }
47131 {
47132 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47133 }
47134 {
47135 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47136 }
47137 {
47138 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47139 }
47140 {
47141 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47142 }
47143 {
47144 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47145 }
47146 {
47147 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47148 }
47149 {
47150 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47151 }
47152 {
47153 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47154 }
47155 {
47156 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47157 }
47158 {
47159 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47160 }
47161 {
47162 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47163 }
47164 {
47165 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47166 }
47167 {
47168 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47169 }
47170 {
47171 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47172 }
47173 {
47174 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47175 }
47176 {
47177 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47178 }
47179 {
47180 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47181 }
47182 {
47183 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47184 }
47185 {
47186 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47187 }
47188 {
47189 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47190 }
47191 {
47192 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47193 }
47194 {
47195 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47196 }
47197 {
47198 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47199 }
47200 {
47201 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47202 }
47203 {
47204 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47205 }
47206 {
47207 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47208 }
47209 {
47210 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47211 }
47212 {
47213 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47214 }
47215 {
47216 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47217 }
47218 {
47219 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47220 }
47221 {
47222 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47223 }
47224 {
47225 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47226 }
47227 {
47228 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47229 }
47230 {
47231 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47232 }
47233 {
47234 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47235 }
47236 {
47237 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47238 }
47239 {
47240 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47241 }
47242 {
47243 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47244 }
47245 {
47246 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47247 }
47248 {
47249 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47250 }
47251 {
47252 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47253 }
47254 {
47255 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47256 }
47257 {
47258 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
47259 }
47260 {
47261 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
47262 }
47263 {
47264 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
47265 }
47266 {
47267 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
47268 }
47269 {
47270 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
47271 }
47272 {
47273 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
47274 }
47275 {
47276 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47277 }
47278 {
47279 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47280 }
47281 {
47282 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47283 }
47284 {
47285 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47286 }
47287 {
47288 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47289 }
47290 {
47291 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47292 }
47293 {
47294 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47295 }
47296 {
47297 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47298 }
47299 {
47300 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47301 }
47302 {
47303 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47304 }
47305 {
47306 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
47307 }
47308 {
47309 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
47310 }
47311 {
47312 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
47313 }
47314 {
47315 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
47316 }
47317 {
47318 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
47319 }
47320 {
47321 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
47322 }
47323 {
47324 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
47325 }
47326 {
47327 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
47328 }
47329 {
47330 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
47331 }
47332 {
47333 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
47334 }
47335 {
47336 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
47337 }
47338 {
47339 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
47340 }
47341 {
47342 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
47343 }
47344 {
47345 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
47346 }
47347 {
47348 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
47349 }
47350 {
47351 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
47352 }
47353 {
47354 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
47355 }
47356 {
47357 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
47358 }
47359 {
47360 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
47361 }
47362 {
47363 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
47364 }
47365 {
47366 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
47367 }
47368 {
47369 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
47370 }
47371 {
47372 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
47373 }
47374 {
47375 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
47376 }
47377 {
47378 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
47379 }
47380 {
47381 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
47382 }
47383 {
47384 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
47385 }
47386 {
47387 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
47388 }
47389 {
47390 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
47391 }
47392 {
47393 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
47394 }
47395 {
47396 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
47397 }
47398 {
47399 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
47400 }
47401 {
47402 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
47403 }
47404 {
47405 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
47406 }
47407 {
47408 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
47409 }
47410 {
47411 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
47412 }
47413 {
47414 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
47415 }
47416 {
47417 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
47418 }
47419 {
47420 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
47421 }
47422 {
47423 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
47424 }
47425 {
47426 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
47427 }
47428 {
47429 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
47430 }
47431 {
47432 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
47433 }
47434 {
47435 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
47436 }
47437 {
47438 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
47439 }
47440 {
47441 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
47442 }
47443 {
47444 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
47445 }
47446 {
47447 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
47448 }
47449 {
47450 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
47451 }
47452 {
47453 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
47454 }
47455 {
47456 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
47457 }
47458 {
47459 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
47460 }
47461 {
47462 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
47463 }
47464 {
47465 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
47466 }
47467 {
47468 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
47469 }
47470 {
47471 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
47472 }
47473 {
47474 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
47475 }
47476 {
47477 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
47478 }
47479 {
47480 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
47481 }
47482 {
47483 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
47484 }
47485 {
47486 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
47487 }
47488 {
47489 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
47490 }
47491 {
47492 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
47493 }
47494 {
47495 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
47496 }
47497 {
47498 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
47499 }
47500 {
47501 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
47502 }
47503 {
47504 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
47505 }
47506 {
47507 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
47508 }
47509 {
47510 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
47511 }
47512 {
47513 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
47514 }
47515 {
47516 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
47517 }
47518 {
47519 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
47520 }
47521 {
47522 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
47523 }
47524 {
47525 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
47526 }
47527 {
47528 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
47529 }
47530 {
47531 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
47532 }
47533 {
47534 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
47535 }
47536 {
47537 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
47538 }
47539 {
47540 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
47541 }
47542 {
47543 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
47544 }
47545 {
47546 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
47547 }
47548 {
47549 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
47550 }
47551 {
47552 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
47553 }
47554 {
47555 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
47556 }
47557 {
47558 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
47559 }
47560 {
47561 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
47562 }
47563 {
47564 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
47565 }
47566 {
47567 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
47568 }
47569 {
47570 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
47571 }
47572 {
47573 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
47574 }
47575 {
47576 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
47577 }
47578 {
47579 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
47580 }
47581 {
47582 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
47583 }
47584 {
47585 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
47586 }
47587 {
47588 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
47589 }
47590 {
47591 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
47592 }
47593 {
47594 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
47595 }
47596 {
47597 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
47598 }
47599 {
47600 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
47601 }
47602 {
47603 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
47604 }
47605 {
47606 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
47607 }
47608 {
47609 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
47610 }
47611 {
47612 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
47613 }
47614 {
47615 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
47616 }
47617 {
47618 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
47619 }
47620 {
47621 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
47622 }
47623 {
47624 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
47625 }
47626 {
47627 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
47628 }
47629 {
47630 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
47631 }
47632 {
47633 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
47634 }
47635 {
47636 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
47637 }
47638 {
47639 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
47640 }
47641 {
47642 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
47643 }
47644 {
47645 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
47646 }
47647 {
47648 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
47649 }
47650 {
47651 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
47652 }
47653 {
47654 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
47655 }
47656 {
47657 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
47658 }
47659 {
47660 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
47661 }
47662 {
47663 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
47664 }
47665 {
47666 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
47667 }
47668 {
47669 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
47670 }
47671 {
47672 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
47673 }
47674 {
47675 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48093 }
48094 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48095 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48096 {
48097 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48098 }
48099 {
48100 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48101 }
48102 {
48103 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48104 }
48105 {
48106 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48107 }
48108 {
48109 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48110 }
48111 {
48112 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48113 }
48114 {
48115 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48116 }
48117 {
48118 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48119 }
48120 {
48121 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48122 }
48123 {
48124 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48125 }
48126 {
48127 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48128 }
48129 {
48130 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48131 }
48132 {
48133 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48134 }
48135 {
48136 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48137 }
48138 {
48139 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48140 }
48141 {
48142 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48143 }
48144 {
48145 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48146 }
48147 {
48148 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48149 }
48150 {
48151 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48152 }
48153 {
48154 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48155 }
48156 {
48157 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48158 }
48159 {
48160 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48161 }
48162 {
48163 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48164 }
48165 {
48166 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48167 }
48168 {
48169 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48170 }
48171 {
48172 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48173 }
48174 {
48175 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48176 }
48177 {
48178 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48179 }
48180 {
48181 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48182 }
48183 {
48184 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48185 }
48186 {
48187 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48188 }
48189 {
48190 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48191 }
48192 {
48193 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48194 }
48195 {
48196 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48197 }
48198 {
48199 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48200 }
48201 {
48202 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48203 }
48204 {
48205 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48206 }
48207 {
48208 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48209 }
48210 {
48211 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48212 }
48213 {
48214 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48215 }
48216 {
48217 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48218 }
48219 {
48220 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48221 }
48222 {
48223 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48224 }
48225 {
48226 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48227 }
48228 {
48229 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48230 }
48231 {
48232 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48233 }
48234 {
48235 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48236 }
48237 {
48238 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48239 }
48240 {
48241 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48242 }
48243 {
48244 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48245 }
48246 {
48247 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48248 }
48249 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48250 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48251 {
48252 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
48259 }
48260
48261 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
48262
48263
48264 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
48265
48266 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
48267 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
48268 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
48269 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
48270 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
48271 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
48272 {
48273 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48295 }
48296 {
48297 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48298 }
48299 {
48300 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
48301 }
48302 {
48303 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
48304 }
48305 {
48306 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
48307 }
48308 {
48309 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
48310 }
48311 {
48312 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
48313 }
48314 {
48315 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
48316 }
48317 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
48318 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
48319 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
48320 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
48321 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
48322 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
48323 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
48324 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
48325 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
48326 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
48327 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
48328 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
48329 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
48330 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
48331 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
48332 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
48333 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
48334 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
48335 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
48336 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
48337 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
48338 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
48339 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
48340 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
48341 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
48342 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
48343 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
48344 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
48345 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
48346 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
48347 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
48348 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
48349 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
48350 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
48351 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
48352 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
48353 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
48354 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
48355 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
48356 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
48357 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
48358 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
48359 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
48360 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
48361 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
48362 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
48363 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
48364 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
48365 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
48366 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
48367 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
48368 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
48369 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
48370 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
48371 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
48372 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
48373 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
48374 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
48375 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
48376 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
48377 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
48378 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
48379 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
48380 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
48381 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
48382 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
48383 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
48384 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
48385 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
48386 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
48387 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
48388 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
48389 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
48390 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
48391 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
48392 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
48393 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
48394 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
48395 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
48396 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
48397 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
48398 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
48399 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
48400 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
48401 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
48402 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
48403 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
48404 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
48405 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
48406 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
48407 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
48408 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
48409 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
48410 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
48411 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
48412 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
48413 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
48414 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
48415 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
48416 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
48417 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
48418 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
48419 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
48420 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
48421 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
48422 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
48423 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
48424 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
48425 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
48426 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
48427 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
48428 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
48429 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
48430 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
48431 {
48432 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
48433 }
48434 {
48435 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
48436 }
48437 {
48438 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
48439 }
48440 {
48441 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
48445 }
48446 {
48447 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
48484 }
48485 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
48486 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
48487 {
48488 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
48501 }
48502 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
48503 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
48504 {
48505 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
48506 }
48507 {
48508 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
48512 }
48513 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
48514 {
48515 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
48570 }
48571
48572 // Initialize threading, some globals and such
48573 __wxPyPreStart(d);
48574
48575
48576 // Although these are defined in __version__ they need to be here too so
48577 // that an assert can be done to ensure that the wxPython and the wxWindows
48578 // versions match.
48579 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
48580 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
48581 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
48582
48583 }
48584
wxWidgets (Impactor)