]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Source cleaning.
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652
1653 wxPyInstance_Check,
1654 wxPySwigInstance_Check,
1655
1656 wxPyCheckForApp
1657
1658 };
1659
1660 #endif
1661
1662
1663 #if !WXWIN_COMPATIBILITY_2_4
1664 #define wxHIDE_READONLY 0
1665 #endif
1666
1667
1668 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1669 #define SWIG_From_int PyInt_FromLong
1670 /*@@*/
1671
1672
1673 #if ! wxUSE_HOTKEY
1674 enum wxHotkeyModifier
1675 {
1676 wxMOD_NONE = 0,
1677 wxMOD_ALT = 1,
1678 wxMOD_CONTROL = 2,
1679 wxMOD_SHIFT = 4,
1680 wxMOD_WIN = 8
1681 };
1682 #define wxEVT_HOTKEY 9999
1683 #endif
1684
1685 static const wxString wxPyEmptyString(wxEmptyString);
1686 static wxString wxObject_GetClassName(wxObject *self){
1687 return self->GetClassInfo()->GetClassName();
1688 }
1689 static void wxObject_Destroy(wxObject *self){
1690 delete self;
1691 }
1692
1693 #ifndef __WXMAC__
1694 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1695 #endif
1696
1697
1698 #include <limits.h>
1699
1700
1701 SWIGINTERN int
1702 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1703 const char *errmsg)
1704 {
1705 if (value < min_value) {
1706 if (errmsg) {
1707 PyErr_Format(PyExc_OverflowError,
1708 "value %ld is less than '%s' minimum %ld",
1709 value, errmsg, min_value);
1710 }
1711 return 0;
1712 } else if (value > max_value) {
1713 if (errmsg) {
1714 PyErr_Format(PyExc_OverflowError,
1715 "value %ld is greater than '%s' maximum %ld",
1716 value, errmsg, max_value);
1717 }
1718 return 0;
1719 }
1720 return 1;
1721 }
1722
1723
1724 SWIGINTERN int
1725 SWIG_AsVal_long(PyObject* obj, long* val)
1726 {
1727 if (PyNumber_Check(obj)) {
1728 if (val) *val = PyInt_AsLong(obj);
1729 return 1;
1730 }
1731 else {
1732 SWIG_type_error("number", obj);
1733 }
1734 return 0;
1735 }
1736
1737
1738 #if INT_MAX != LONG_MAX
1739 SWIGINTERN int
1740 SWIG_AsVal_int(PyObject *obj, int *val)
1741 {
1742 const char* errmsg = val ? "int" : (char*)0;
1743 long v;
1744 if (SWIG_AsVal_long(obj, &v)) {
1745 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1746 if (val) *val = (int)(v);
1747 return 1;
1748 } else {
1749 return 0;
1750 }
1751 } else {
1752 PyErr_Clear();
1753 }
1754 if (val) {
1755 SWIG_type_error(errmsg, obj);
1756 }
1757 return 0;
1758 }
1759 #else
1760 SWIGINTERNSHORT int
1761 SWIG_AsVal_int(PyObject *obj, int *val)
1762 {
1763 return SWIG_AsVal_long(obj,(long*)val);
1764 }
1765 #endif
1766
1767
1768 SWIGINTERNSHORT int
1769 SWIG_As_int(PyObject* obj)
1770 {
1771 int v;
1772 if (!SWIG_AsVal_int(obj, &v)) {
1773 /*
1774 this is needed to make valgrind/purify happier.
1775 */
1776 memset((void*)&v, 0, sizeof(int));
1777 }
1778 return v;
1779 }
1780
1781
1782 SWIGINTERNSHORT int
1783 SWIG_Check_int(PyObject* obj)
1784 {
1785 return SWIG_AsVal_int(obj, (int*)0);
1786 }
1787
1788 static PyObject *wxSize_Get(wxSize *self){
1789 bool blocked = wxPyBeginBlockThreads();
1790 PyObject* tup = PyTuple_New(2);
1791 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1792 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1793 wxPyEndBlockThreads(blocked);
1794 return tup;
1795 }
1796
1797 SWIGINTERN int
1798 SWIG_AsVal_double(PyObject *obj, double* val)
1799 {
1800 if (PyNumber_Check(obj)) {
1801 if (val) *val = PyFloat_AsDouble(obj);
1802 return 1;
1803 }
1804 else {
1805 SWIG_type_error("number", obj);
1806 }
1807 return 0;
1808 }
1809
1810
1811 SWIGINTERNSHORT double
1812 SWIG_As_double(PyObject* obj)
1813 {
1814 double v;
1815 if (!SWIG_AsVal_double(obj, &v)) {
1816 /*
1817 this is needed to make valgrind/purify happier.
1818 */
1819 memset((void*)&v, 0, sizeof(double));
1820 }
1821 return v;
1822 }
1823
1824
1825 SWIGINTERNSHORT int
1826 SWIG_Check_double(PyObject* obj)
1827 {
1828 return SWIG_AsVal_double(obj, (double*)0);
1829 }
1830
1831
1832 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1833 #define SWIG_From_double PyFloat_FromDouble
1834 /*@@*/
1835
1836 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1837 self->x = x;
1838 self->y = y;
1839 }
1840 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1841 bool blocked = wxPyBeginBlockThreads();
1842 PyObject* tup = PyTuple_New(2);
1843 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1844 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1845 wxPyEndBlockThreads(blocked);
1846 return tup;
1847 }
1848
1849 SWIGINTERNSHORT long
1850 SWIG_As_long(PyObject* obj)
1851 {
1852 long v;
1853 if (!SWIG_AsVal_long(obj, &v)) {
1854 /*
1855 this is needed to make valgrind/purify happier.
1856 */
1857 memset((void*)&v, 0, sizeof(long));
1858 }
1859 return v;
1860 }
1861
1862
1863 SWIGINTERNSHORT int
1864 SWIG_Check_long(PyObject* obj)
1865 {
1866 return SWIG_AsVal_long(obj, (long*)0);
1867 }
1868
1869 static void wxPoint_Set(wxPoint *self,long x,long y){
1870 self->x = x;
1871 self->y = y;
1872 }
1873 static PyObject *wxPoint_Get(wxPoint *self){
1874 bool blocked = wxPyBeginBlockThreads();
1875 PyObject* tup = PyTuple_New(2);
1876 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1877 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1878 wxPyEndBlockThreads(blocked);
1879 return tup;
1880 }
1881 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1882 self->x = x;
1883 self->y = y;
1884 self->width = width;
1885 self->height = height;
1886 }
1887 static PyObject *wxRect_Get(wxRect *self){
1888 bool blocked = wxPyBeginBlockThreads();
1889 PyObject* tup = PyTuple_New(4);
1890 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1891 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1892 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1893 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1894 wxPyEndBlockThreads(blocked);
1895 return tup;
1896 }
1897
1898 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1899 wxRegion reg1(*r1);
1900 wxRegion reg2(*r2);
1901 wxRect dest(0,0,0,0);
1902 PyObject* obj;
1903
1904 reg1.Intersect(reg2);
1905 dest = reg1.GetBox();
1906
1907 if (dest != wxRect(0,0,0,0)) {
1908 bool blocked = wxPyBeginBlockThreads();
1909 wxRect* newRect = new wxRect(dest);
1910 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1911 wxPyEndBlockThreads(blocked);
1912 return obj;
1913 }
1914 Py_INCREF(Py_None);
1915 return Py_None;
1916 }
1917
1918
1919 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1920 PyObject* o2;
1921 PyObject* o3;
1922
1923 if (!target) {
1924 target = o;
1925 } else if (target == Py_None) {
1926 Py_DECREF(Py_None);
1927 target = o;
1928 } else {
1929 if (!PyTuple_Check(target)) {
1930 o2 = target;
1931 target = PyTuple_New(1);
1932 PyTuple_SetItem(target, 0, o2);
1933 }
1934 o3 = PyTuple_New(1);
1935 PyTuple_SetItem(o3, 0, o);
1936
1937 o2 = target;
1938 target = PySequence_Concat(o2, o3);
1939 Py_DECREF(o2);
1940 Py_DECREF(o3);
1941 }
1942 return target;
1943 }
1944
1945
1946 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1947 self->m_x = x;
1948 self->m_y = y;
1949 }
1950 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1951 bool blocked = wxPyBeginBlockThreads();
1952 PyObject* tup = PyTuple_New(2);
1953 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1954 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1955 wxPyEndBlockThreads(blocked);
1956 return tup;
1957 }
1958
1959 #include "wx/wxPython/pyistream.h"
1960
1961 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1962 wxInputStream* wxis = wxPyCBInputStream::create(p);
1963 if (wxis)
1964 return new wxPyInputStream(wxis);
1965 else
1966 return NULL;
1967 }
1968
1969 SWIGINTERNSHORT PyObject*
1970 SWIG_From_char(char c)
1971 {
1972 return PyString_FromStringAndSize(&c,1);
1973 }
1974
1975
1976 SWIGINTERNSHORT PyObject*
1977 SWIG_From_unsigned_SS_long(unsigned long value)
1978 {
1979 return (value > LONG_MAX) ?
1980 PyLong_FromUnsignedLong(value)
1981 : PyInt_FromLong((long)(value));
1982 }
1983
1984
1985 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1986 SWIGINTERN int
1987 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1988 {
1989 static swig_type_info* pchar_info = 0;
1990 char* vptr = 0;
1991 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1992 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1993 if (cptr) *cptr = vptr;
1994 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1995 return SWIG_OLDOBJ;
1996 } else {
1997 PyErr_Clear();
1998 if (PyString_Check(obj)) {
1999 if (cptr) {
2000 *cptr = PyString_AS_STRING(obj);
2001 if (psize) {
2002 *psize = PyString_GET_SIZE(obj) + 1;
2003 }
2004 }
2005 return SWIG_PYSTR;
2006 }
2007 }
2008 if (cptr) {
2009 SWIG_type_error("char *", obj);
2010 }
2011 return 0;
2012 }
2013
2014
2015 SWIGINTERN int
2016 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2017 {
2018 char* cptr; size_t csize;
2019 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2020 /* in C you can do:
2021
2022 char x[5] = "hello";
2023
2024 ie, assing the array using an extra '0' char.
2025 */
2026 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2027 if (csize <= size) {
2028 if (val) {
2029 if (csize) memcpy(val, cptr, csize);
2030 if (csize < size) memset(val + csize, 0, size - csize);
2031 }
2032 return 1;
2033 }
2034 }
2035 if (val) {
2036 PyErr_Format(PyExc_TypeError,
2037 "a char array of maximum size %lu is expected",
2038 (unsigned long) size);
2039 }
2040 return 0;
2041 }
2042
2043
2044 SWIGINTERN int
2045 SWIG_AsVal_char(PyObject *obj, char *val)
2046 {
2047 const char* errmsg = val ? "char" : (char*)0;
2048 long v;
2049 if (SWIG_AsVal_long(obj, &v)) {
2050 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2051 if (val) *val = (char)(v);
2052 return 1;
2053 } else {
2054 return 0;
2055 }
2056 } else {
2057 PyErr_Clear();
2058 return SWIG_AsCharArray(obj, val, 1);
2059 }
2060 }
2061
2062
2063 SWIGINTERNSHORT char
2064 SWIG_As_char(PyObject* obj)
2065 {
2066 char v;
2067 if (!SWIG_AsVal_char(obj, &v)) {
2068 /*
2069 this is needed to make valgrind/purify happier.
2070 */
2071 memset((void*)&v, 0, sizeof(char));
2072 }
2073 return v;
2074 }
2075
2076
2077 SWIGINTERNSHORT int
2078 SWIG_Check_char(PyObject* obj)
2079 {
2080 return SWIG_AsVal_char(obj, (char*)0);
2081 }
2082
2083
2084 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2085 #define SWIG_From_long PyInt_FromLong
2086 /*@@*/
2087
2088 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2089 // We use only strings for the streams, not unicode
2090 PyObject* str = PyObject_Str(obj);
2091 if (! str) {
2092 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2093 return;
2094 }
2095 self->Write(PyString_AS_STRING(str),
2096 PyString_GET_SIZE(str));
2097 Py_DECREF(str);
2098 }
2099
2100 #include "wx/wxPython/pyistream.h"
2101
2102
2103 class wxPyFileSystemHandler : public wxFileSystemHandler
2104 {
2105 public:
2106 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2107
2108 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2109 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2110 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2111 DEC_PYCALLBACK_STRING__pure(FindNext);
2112
2113 wxString GetProtocol(const wxString& location) {
2114 return wxFileSystemHandler::GetProtocol(location);
2115 }
2116
2117 wxString GetLeftLocation(const wxString& location) {
2118 return wxFileSystemHandler::GetLeftLocation(location);
2119 }
2120
2121 wxString GetAnchor(const wxString& location) {
2122 return wxFileSystemHandler::GetAnchor(location);
2123 }
2124
2125 wxString GetRightLocation(const wxString& location) {
2126 return wxFileSystemHandler::GetRightLocation(location);
2127 }
2128
2129 wxString GetMimeTypeFromExt(const wxString& location) {
2130 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2131 }
2132
2133 PYPRIVATE;
2134 };
2135
2136
2137 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2138 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2139 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2140 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2141
2142
2143 SWIGINTERN int
2144 SWIG_AsVal_bool(PyObject *obj, bool *val)
2145 {
2146 if (obj == Py_True) {
2147 if (val) *val = true;
2148 return 1;
2149 }
2150 if (obj == Py_False) {
2151 if (val) *val = false;
2152 return 1;
2153 }
2154 int res = 0;
2155 if (SWIG_AsVal_int(obj, &res)) {
2156 if (val) *val = res ? true : false;
2157 return 1;
2158 } else {
2159 PyErr_Clear();
2160 }
2161 if (val) {
2162 SWIG_type_error("bool", obj);
2163 }
2164 return 0;
2165 }
2166
2167
2168 SWIGINTERNSHORT bool
2169 SWIG_As_bool(PyObject* obj)
2170 {
2171 bool v;
2172 if (!SWIG_AsVal_bool(obj, &v)) {
2173 /*
2174 this is needed to make valgrind/purify happier.
2175 */
2176 memset((void*)&v, 0, sizeof(bool));
2177 }
2178 return v;
2179 }
2180
2181
2182 SWIGINTERNSHORT int
2183 SWIG_Check_bool(PyObject* obj)
2184 {
2185 return SWIG_AsVal_bool(obj, (bool*)0);
2186 }
2187
2188 static wxString FileSystem_URLToFileName(wxString const &url){
2189 wxFileName fname = wxFileSystem::URLToFileName(url);
2190 return fname.GetFullPath();
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2194 wxImage& image,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, image, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2200 const wxBitmap& bitmap,
2201 long type) {
2202 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2203 }
2204
2205 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2206 PyObject* data) {
2207 if (! PyString_Check(data)) {
2208 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2209 "Expected string object"));
2210 return;
2211 }
2212
2213 bool blocked = wxPyBeginBlockThreads();
2214 void* ptr = (void*)PyString_AsString(data);
2215 size_t size = PyString_Size(data);
2216 wxPyEndBlockThreads(blocked);
2217
2218 wxMemoryFSHandler::AddFile(filename, ptr, size);
2219 }
2220
2221
2222 #include "wx/wxPython/pyistream.h"
2223
2224
2225 SWIGINTERN int
2226 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2227 {
2228 long v = 0;
2229 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2230 SWIG_type_error("unsigned number", obj);
2231 }
2232 else if (val)
2233 *val = (unsigned long)v;
2234 return 1;
2235 }
2236
2237
2238 SWIGINTERNSHORT int
2239 SWIG_CheckUnsignedLongInRange(unsigned long value,
2240 unsigned long max_value,
2241 const char *errmsg)
2242 {
2243 if (value > max_value) {
2244 if (errmsg) {
2245 PyErr_Format(PyExc_OverflowError,
2246 "value %lu is greater than '%s' minimum %lu",
2247 value, errmsg, max_value);
2248 }
2249 return 0;
2250 }
2251 return 1;
2252 }
2253
2254
2255 SWIGINTERN int
2256 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2257 {
2258 const char* errmsg = val ? "unsigned char" : (char*)0;
2259 unsigned long v;
2260 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2261 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2262 if (val) *val = (unsigned char)(v);
2263 return 1;
2264 } else {
2265 return 0;
2266 }
2267 } else {
2268 PyErr_Clear();
2269 }
2270 if (val) {
2271 SWIG_type_error(errmsg, obj);
2272 }
2273 return 0;
2274 }
2275
2276
2277 SWIGINTERNSHORT unsigned char
2278 SWIG_As_unsigned_SS_char(PyObject* obj)
2279 {
2280 unsigned char v;
2281 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2282 /*
2283 this is needed to make valgrind/purify happier.
2284 */
2285 memset((void*)&v, 0, sizeof(unsigned char));
2286 }
2287 return v;
2288 }
2289
2290
2291 SWIGINTERNSHORT int
2292 SWIG_Check_unsigned_SS_char(PyObject* obj)
2293 {
2294 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2295 }
2296
2297
2298 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2299 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2300 /*@@*/
2301
2302
2303 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2304 if (width > 0 && height > 0)
2305 return new wxImage(width, height, clear);
2306 else
2307 return new wxImage;
2308 }
2309 static wxImage *new_wxImage(wxBitmap const &bitmap){
2310 return new wxImage(bitmap.ConvertToImage());
2311 }
2312 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2313 // Copy the source data so the wxImage can clean it up later
2314 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2315 if (copy == NULL) {
2316 PyErr_NoMemory();
2317 return NULL;
2318 }
2319 memcpy(copy, data, width*height*3);
2320 return new wxImage(width, height, copy, false);
2321 }
2322 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2323 // Copy the source data so the wxImage can clean it up later
2324 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2325 if (dcopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(dcopy, data, width*height*3);
2330 unsigned char* acopy = (unsigned char*)malloc(width*height);
2331 if (acopy == NULL) {
2332 PyErr_NoMemory();
2333 return NULL;
2334 }
2335 memcpy(acopy, alpha, width*height);
2336
2337 return new wxImage(width, height, dcopy, acopy, false);
2338 }
2339 static wxSize wxImage_GetSize(wxImage *self){
2340 wxSize size(self->GetWidth(), self->GetHeight());
2341 return size;
2342 }
2343 static PyObject *wxImage_GetData(wxImage *self){
2344 unsigned char* data = self->GetData();
2345 int len = self->GetWidth() * self->GetHeight() * 3;
2346 PyObject* rv;
2347 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2348 return rv;
2349 }
2350 static void wxImage_SetData(wxImage *self,PyObject *data){
2351 unsigned char* dataPtr;
2352
2353 if (! PyString_Check(data)) {
2354 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2355 "Expected string object"));
2356 return /* NULL */ ;
2357 }
2358
2359 size_t len = self->GetWidth() * self->GetHeight() * 3;
2360 dataPtr = (unsigned char*) malloc(len);
2361 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2362 self->SetData(dataPtr);
2363 // wxImage takes ownership of dataPtr...
2364 }
2365 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2366 unsigned char* data = self->GetData();
2367 int len = self->GetWidth() * self->GetHeight() * 3;
2368 PyObject* rv;
2369 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2370 return rv;
2371 }
2372 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2373 unsigned char* buffer;
2374 int size;
2375
2376 bool blocked = wxPyBeginBlockThreads();
2377 if (!PyArg_Parse(data, "t#", &buffer, &size))
2378 goto done;
2379
2380 if (size != self->GetWidth() * self->GetHeight() * 3) {
2381 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2382 goto done;
2383 }
2384 self->SetData(buffer);
2385 done:
2386 wxPyEndBlockThreads(blocked);
2387 }
2388 static PyObject *wxImage_GetAlphaData(wxImage *self){
2389 unsigned char* data = self->GetAlpha();
2390 if (! data) {
2391 RETURN_NONE();
2392 } else {
2393 int len = self->GetWidth() * self->GetHeight();
2394 PyObject* rv;
2395 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2396 return rv;
2397 }
2398 }
2399 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2400 unsigned char* dataPtr;
2401
2402 if (! PyString_Check(data)) {
2403 PyErr_SetString(PyExc_TypeError, "Expected string object");
2404 return /* NULL */ ;
2405 }
2406
2407 size_t len = self->GetWidth() * self->GetHeight();
2408 dataPtr = (unsigned char*) malloc(len);
2409 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2410 self->SetAlpha(dataPtr);
2411 // wxImage takes ownership of dataPtr...
2412 }
2413 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2414 unsigned char* data = self->GetAlpha();
2415 int len = self->GetWidth() * self->GetHeight();
2416 PyObject* rv;
2417 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2418 return rv;
2419 }
2420 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2421 unsigned char* buffer;
2422 int size;
2423
2424 bool blocked = wxPyBeginBlockThreads();
2425 if (!PyArg_Parse(data, "t#", &buffer, &size))
2426 goto done;
2427
2428 if (size != self->GetWidth() * self->GetHeight()) {
2429 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2430 goto done;
2431 }
2432 self->SetAlpha(buffer);
2433 done:
2434 wxPyEndBlockThreads(blocked);
2435 }
2436
2437 SWIGINTERNSHORT unsigned long
2438 SWIG_As_unsigned_SS_long(PyObject* obj)
2439 {
2440 unsigned long v;
2441 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2442 /*
2443 this is needed to make valgrind/purify happier.
2444 */
2445 memset((void*)&v, 0, sizeof(unsigned long));
2446 }
2447 return v;
2448 }
2449
2450
2451 SWIGINTERNSHORT int
2452 SWIG_Check_unsigned_SS_long(PyObject* obj)
2453 {
2454 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2455 }
2456
2457 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2458 wxBitmap bitmap(*self, depth);
2459 return bitmap;
2460 }
2461 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2462 wxImage mono = self->ConvertToMono( red, green, blue );
2463 wxBitmap bitmap( mono, 1 );
2464 return bitmap;
2465 }
2466 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2467 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2468 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2470 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2474 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2475 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2476 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2477 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2478 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2479 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2480 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2481
2482 #include <wx/quantize.h>
2483
2484 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2485 return wxQuantize::Quantize(src, dest,
2486 //NULL, // palette
2487 desiredNoColours,
2488 NULL, // eightBitData
2489 flags);
2490 }
2491 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2492 if (PyCallable_Check(func)) {
2493 self->Connect(id, lastId, eventType,
2494 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2495 new wxPyCallback(func));
2496 }
2497 else if (func == Py_None) {
2498 self->Disconnect(id, lastId, eventType,
2499 (wxObjectEventFunction)
2500 &wxPyCallback::EventThunker);
2501 }
2502 else {
2503 wxPyBLOCK_THREADS(
2504 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2505 }
2506 }
2507 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2508 return self->Disconnect(id, lastId, eventType,
2509 (wxObjectEventFunction)
2510 &wxPyCallback::EventThunker);
2511 }
2512 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2513 if (_self && _self != Py_None) {
2514 self->SetClientObject(new wxPyOORClientData(_self, incref));
2515 }
2516 else {
2517 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2518 if (data) {
2519 self->SetClientObject(NULL); // This will delete it too
2520 }
2521 }
2522 }
2523
2524 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2525 #if wxUSE_UNICODE
2526 return self->GetUnicodeKey();
2527 #else
2528 return 0;
2529 #endif
2530 }
2531
2532 #if UINT_MAX < LONG_MAX
2533 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2534 #define SWIG_From_unsigned_SS_int SWIG_From_long
2535 /*@@*/
2536 #else
2537 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2538 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2539 /*@@*/
2540 #endif
2541
2542
2543 #if UINT_MAX != ULONG_MAX
2544 SWIGINTERN int
2545 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2546 {
2547 const char* errmsg = val ? "unsigned int" : (char*)0;
2548 unsigned long v;
2549 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2550 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2551 if (val) *val = (unsigned int)(v);
2552 return 1;
2553 }
2554 } else {
2555 PyErr_Clear();
2556 }
2557 if (val) {
2558 SWIG_type_error(errmsg, obj);
2559 }
2560 return 0;
2561 }
2562 #else
2563 SWIGINTERNSHORT unsigned int
2564 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2565 {
2566 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2567 }
2568 #endif
2569
2570
2571 SWIGINTERNSHORT unsigned int
2572 SWIG_As_unsigned_SS_int(PyObject* obj)
2573 {
2574 unsigned int v;
2575 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2576 /*
2577 this is needed to make valgrind/purify happier.
2578 */
2579 memset((void*)&v, 0, sizeof(unsigned int));
2580 }
2581 return v;
2582 }
2583
2584
2585 SWIGINTERNSHORT int
2586 SWIG_Check_unsigned_SS_int(PyObject* obj)
2587 {
2588 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2589 }
2590
2591 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2592 self->m_size = size;
2593 }
2594 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2595 int count = self->GetNumberOfFiles();
2596 wxString* files = self->GetFiles();
2597 PyObject* list = PyList_New(count);
2598
2599 if (!list) {
2600 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2601 return NULL;
2602 }
2603
2604 for (int i=0; i<count; i++) {
2605 PyList_SetItem(list, i, wx2PyString(files[i]));
2606 }
2607 return list;
2608 }
2609
2610
2611 static wxPyApp *new_wxPyApp(){
2612 wxPythonApp = new wxPyApp();
2613 return wxPythonApp;
2614 }
2615 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2616
2617 void wxApp_CleanUp() {
2618 __wxPyCleanup();
2619 }
2620
2621
2622 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2623
2624
2625 SWIGINTERNSHORT int
2626 SWIG_AsCharPtr(PyObject *obj, char **val)
2627 {
2628 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2629 return 1;
2630 }
2631 if (val) {
2632 PyErr_Clear();
2633 SWIG_type_error("char *", obj);
2634 }
2635 return 0;
2636 }
2637
2638
2639 SWIGINTERN PyObject *
2640 SWIG_FromCharPtr(const char* cptr)
2641 {
2642 if (cptr) {
2643 size_t size = strlen(cptr);
2644 if (size > INT_MAX) {
2645 return SWIG_NewPointerObj((char*)(cptr),
2646 SWIG_TypeQuery("char *"), 0);
2647 } else {
2648 if (size != 0) {
2649 return PyString_FromStringAndSize(cptr, size);
2650 } else {
2651 return PyString_FromString(cptr);
2652 }
2653 }
2654 }
2655 Py_INCREF(Py_None);
2656 return Py_None;
2657 }
2658
2659
2660 #ifdef __WXMAC__
2661
2662 // A dummy class that raises an exception if used...
2663 class wxEventLoop
2664 {
2665 public:
2666 wxEventLoop() { wxPyRaiseNotImplemented(); }
2667 int Run() { return 0; }
2668 void Exit(int rc = 0) {}
2669 bool Pending() const { return false; }
2670 bool Dispatch() { return false; }
2671 bool IsRunning() const { return false; }
2672 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2673 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2674 };
2675
2676 #else
2677
2678 #include <wx/evtloop.h>
2679
2680 #endif
2681
2682
2683
2684 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2685 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2686 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2687 static PyObject *wxWindow_GetChildren(wxWindow *self){
2688 wxWindowList& list = self->GetChildren();
2689 return wxPy_ConvertList(&list);
2690 }
2691 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2692 #if wxUSE_HOTKEY
2693 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2694 #else
2695 return false;
2696 #endif
2697 }
2698 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2699
2700
2701
2702 return false;
2703
2704 }
2705 static long wxWindow_GetHandle(wxWindow *self){
2706 return wxPyGetWinHandle(self);
2707 }
2708 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2709 self->AssociateHandle((WXWidget)handle);
2710 }
2711
2712 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2713 return wxWindow::FindWindowById(id, parent);
2714 }
2715
2716 wxWindow* wxFindWindowByName( const wxString& name,
2717 const wxWindow *parent = NULL ) {
2718 return wxWindow::FindWindowByName(name, parent);
2719 }
2720
2721 wxWindow* wxFindWindowByLabel( const wxString& label,
2722 const wxWindow *parent = NULL ) {
2723 return wxWindow::FindWindowByLabel(label, parent);
2724 }
2725
2726
2727 #ifdef __WXMSW__
2728 #include <wx/msw/private.h> // to get wxGetWindowId
2729 #endif
2730
2731
2732 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2733 #ifdef __WXMSW__
2734 WXHWND hWnd = (WXHWND)_hWnd;
2735 long id = wxGetWindowId(hWnd);
2736 wxWindow* win = new wxWindow;
2737 parent->AddChild(win);
2738 win->SetEventHandler(win);
2739 win->SetHWND(hWnd);
2740 win->SetId(id);
2741 win->SubclassWin(hWnd);
2742 win->AdoptAttributesFromHWND();
2743 win->SetupColours();
2744 return win;
2745 #else
2746 wxPyRaiseNotImplemented();
2747 return NULL;
2748 #endif
2749 }
2750
2751
2752 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2753 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2754 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2755
2756 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2757
2758 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2759 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2760 wxMenuItemList& list = self->GetMenuItems();
2761 return wxPy_ConvertList(&list);
2762 }
2763 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2764 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2765 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2766 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2767 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2768 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2769 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2770 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2771 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2772 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2773 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2774 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2775 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2776 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2777 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2778 static const wxString wxPyControlNameStr(wxControlNameStr);
2779 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2780 if (clientData) {
2781 wxPyClientData* data = new wxPyClientData(clientData);
2782 return self->Append(item, data);
2783 } else
2784 return self->Append(item);
2785 }
2786 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2787 if (clientData) {
2788 wxPyClientData* data = new wxPyClientData(clientData);
2789 return self->Insert(item, pos, data);
2790 } else
2791 return self->Insert(item, pos);
2792 }
2793 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2794 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2795 if (data) {
2796 Py_INCREF(data->m_obj);
2797 return data->m_obj;
2798 } else {
2799 Py_INCREF(Py_None);
2800 return Py_None;
2801 }
2802 }
2803 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2804 wxPyClientData* data = new wxPyClientData(clientData);
2805 self->SetClientObject(n, data);
2806 }
2807
2808
2809 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2810 wxPyUserData* data = NULL;
2811 if ( userData ) {
2812 bool blocked = wxPyBeginBlockThreads();
2813 data = new wxPyUserData(userData);
2814 wxPyEndBlockThreads(blocked);
2815 }
2816 return new wxSizerItem(window, proportion, flag, border, data);
2817 }
2818 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2819 wxPyUserData* data = NULL;
2820 if ( userData ) {
2821 bool blocked = wxPyBeginBlockThreads();
2822 data = new wxPyUserData(userData);
2823 wxPyEndBlockThreads(blocked);
2824 }
2825 return new wxSizerItem(width, height, proportion, flag, border, data);
2826 }
2827 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2828 wxPyUserData* data = NULL;
2829 if ( userData ) {
2830 bool blocked = wxPyBeginBlockThreads();
2831 data = new wxPyUserData(userData);
2832 wxPyEndBlockThreads(blocked);
2833 }
2834 return new wxSizerItem(sizer, proportion, flag, border, data);
2835 }
2836
2837 #include <float.h>
2838 SWIGINTERN int
2839 SWIG_CheckDoubleInRange(double value, double min_value,
2840 double max_value, const char* errmsg)
2841 {
2842 if (value < min_value) {
2843 if (errmsg) {
2844 PyErr_Format(PyExc_OverflowError,
2845 "value %g is less than %s minimum %g",
2846 value, errmsg, min_value);
2847 }
2848 return 0;
2849 } else if (value > max_value) {
2850 if (errmsg) {
2851 PyErr_Format(PyExc_OverflowError,
2852 "value %g is greater than %s maximum %g",
2853 value, errmsg, max_value);
2854 }
2855 return 0;
2856 }
2857 return 1;
2858 }
2859
2860
2861 SWIGINTERN int
2862 SWIG_AsVal_float(PyObject *obj, float *val)
2863 {
2864 const char* errmsg = val ? "float" : (char*)0;
2865 double v;
2866 if (SWIG_AsVal_double(obj, &v)) {
2867 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2868 if (val) *val = (float)(v);
2869 return 1;
2870 } else {
2871 return 0;
2872 }
2873 } else {
2874 PyErr_Clear();
2875 }
2876 if (val) {
2877 SWIG_type_error(errmsg, obj);
2878 }
2879 return 0;
2880 }
2881
2882
2883 SWIGINTERNSHORT float
2884 SWIG_As_float(PyObject* obj)
2885 {
2886 float v;
2887 if (!SWIG_AsVal_float(obj, &v)) {
2888 /*
2889 this is needed to make valgrind/purify happier.
2890 */
2891 memset((void*)&v, 0, sizeof(float));
2892 }
2893 return v;
2894 }
2895
2896
2897 SWIGINTERNSHORT int
2898 SWIG_Check_float(PyObject* obj)
2899 {
2900 return SWIG_AsVal_float(obj, (float*)0);
2901 }
2902
2903
2904 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2905 #define SWIG_From_float PyFloat_FromDouble
2906 /*@@*/
2907
2908 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2909 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2910 if (data) {
2911 Py_INCREF(data->m_obj);
2912 return data->m_obj;
2913 } else {
2914 Py_INCREF(Py_None);
2915 return Py_None;
2916 }
2917 }
2918
2919 // Figure out the type of the sizer item
2920
2921 struct wxPySizerItemInfo {
2922 wxPySizerItemInfo()
2923 : window(NULL), sizer(NULL), gotSize(false),
2924 size(wxDefaultSize), gotPos(false), pos(-1)
2925 {}
2926
2927 wxWindow* window;
2928 wxSizer* sizer;
2929 bool gotSize;
2930 wxSize size;
2931 bool gotPos;
2932 int pos;
2933 };
2934
2935 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2936
2937 wxPySizerItemInfo info;
2938 wxSize size;
2939 wxSize* sizePtr = &size;
2940
2941 // Find out what the type of the item is
2942 // try wxWindow
2943 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2944 PyErr_Clear();
2945 info.window = NULL;
2946
2947 // try wxSizer
2948 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2949 PyErr_Clear();
2950 info.sizer = NULL;
2951
2952 // try wxSize or (w,h)
2953 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2954 info.size = *sizePtr;
2955 info.gotSize = true;
2956 }
2957
2958 // or a single int
2959 if (checkIdx && PyInt_Check(item)) {
2960 info.pos = PyInt_AsLong(item);
2961 info.gotPos = true;
2962 }
2963 }
2964 }
2965
2966 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2967 // no expected type, figure out what kind of error message to generate
2968 if ( !checkSize && !checkIdx )
2969 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2970 else if ( checkSize && !checkIdx )
2971 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2972 else if ( !checkSize && checkIdx)
2973 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2974 else
2975 // can this one happen?
2976 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2977 }
2978
2979 return info;
2980 }
2981
2982 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2983 if (!self->GetClientObject())
2984 self->SetClientObject(new wxPyOORClientData(_self));
2985 }
2986 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2987
2988 wxPyUserData* data = NULL;
2989 bool blocked = wxPyBeginBlockThreads();
2990 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2991 if ( userData && (info.window || info.sizer || info.gotSize) )
2992 data = new wxPyUserData(userData);
2993 wxPyEndBlockThreads(blocked);
2994
2995 // Now call the real Add method if a valid item type was found
2996 if ( info.window )
2997 return self->Add(info.window, proportion, flag, border, data);
2998 else if ( info.sizer )
2999 return self->Add(info.sizer, proportion, flag, border, data);
3000 else if (info.gotSize)
3001 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3002 proportion, flag, border, data);
3003 else
3004 return NULL;
3005 }
3006 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3007
3008 wxPyUserData* data = NULL;
3009 bool blocked = wxPyBeginBlockThreads();
3010 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3011 if ( userData && (info.window || info.sizer || info.gotSize) )
3012 data = new wxPyUserData(userData);
3013 wxPyEndBlockThreads(blocked);
3014
3015 // Now call the real Insert method if a valid item type was found
3016 if ( info.window )
3017 return self->Insert(before, info.window, proportion, flag, border, data);
3018 else if ( info.sizer )
3019 return self->Insert(before, info.sizer, proportion, flag, border, data);
3020 else if (info.gotSize)
3021 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3022 proportion, flag, border, data);
3023 else
3024 return NULL;
3025 }
3026 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3027
3028 wxPyUserData* data = NULL;
3029 bool blocked = wxPyBeginBlockThreads();
3030 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3031 if ( userData && (info.window || info.sizer || info.gotSize) )
3032 data = new wxPyUserData(userData);
3033 wxPyEndBlockThreads(blocked);
3034
3035 // Now call the real Prepend method if a valid item type was found
3036 if ( info.window )
3037 return self->Prepend(info.window, proportion, flag, border, data);
3038 else if ( info.sizer )
3039 return self->Prepend(info.sizer, proportion, flag, border, data);
3040 else if (info.gotSize)
3041 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3042 proportion, flag, border, data);
3043 else
3044 return NULL;
3045 }
3046 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3047 bool blocked = wxPyBeginBlockThreads();
3048 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3049 wxPyEndBlockThreads(blocked);
3050 if ( info.window )
3051 return self->Remove(info.window);
3052 else if ( info.sizer )
3053 return self->Remove(info.sizer);
3054 else if ( info.gotPos )
3055 return self->Remove(info.pos);
3056 else
3057 return false;
3058 }
3059 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3060 bool blocked = wxPyBeginBlockThreads();
3061 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3062 wxPyEndBlockThreads(blocked);
3063 if ( info.window )
3064 return self->Detach(info.window);
3065 else if ( info.sizer )
3066 return self->Detach(info.sizer);
3067 else if ( info.gotPos )
3068 return self->Detach(info.pos);
3069 else
3070 return false;
3071 }
3072 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3073 bool blocked = wxPyBeginBlockThreads();
3074 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3075 wxPyEndBlockThreads(blocked);
3076 if ( info.window )
3077 return self->GetItem(info.window);
3078 else if ( info.sizer )
3079 return self->GetItem(info.sizer);
3080 else if ( info.gotPos )
3081 return self->GetItem(info.pos);
3082 else
3083 return NULL;
3084 }
3085 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3086 bool blocked = wxPyBeginBlockThreads();
3087 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3088 wxPyEndBlockThreads(blocked);
3089 if ( info.window )
3090 self->SetItemMinSize(info.window, size);
3091 else if ( info.sizer )
3092 self->SetItemMinSize(info.sizer, size);
3093 else if ( info.gotPos )
3094 self->SetItemMinSize(info.pos, size);
3095 }
3096 static PyObject *wxSizer_GetChildren(wxSizer *self){
3097 wxSizerItemList& list = self->GetChildren();
3098 return wxPy_ConvertList(&list);
3099 }
3100 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3101 bool blocked = wxPyBeginBlockThreads();
3102 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3103 wxPyEndBlockThreads(blocked);
3104 if ( info.window )
3105 return self->Show(info.window, show, recursive);
3106 else if ( info.sizer )
3107 return self->Show(info.sizer, show, recursive);
3108 else if ( info.gotPos )
3109 return self->Show(info.pos, show);
3110 else
3111 return false;
3112 }
3113 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3114 bool blocked = wxPyBeginBlockThreads();
3115 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3116 wxPyEndBlockThreads(blocked);
3117 if ( info.window )
3118 return self->IsShown(info.window);
3119 else if ( info.sizer )
3120 return self->IsShown(info.sizer);
3121 else if ( info.gotPos )
3122 return self->IsShown(info.pos);
3123 else
3124 return false;
3125 }
3126
3127 // See pyclasses.h
3128 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3129 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3130 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3131
3132
3133
3134
3135 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3136 {
3137 if (source == Py_None) {
3138 **obj = wxGBPosition(-1,-1);
3139 return true;
3140 }
3141 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3142 }
3143
3144 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3145 {
3146 if (source == Py_None) {
3147 **obj = wxGBSpan(-1,-1);
3148 return true;
3149 }
3150 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3151 }
3152
3153
3154 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3155 self->SetRow(row);
3156 self->SetCol(col);
3157 }
3158 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3159 bool blocked = wxPyBeginBlockThreads();
3160 PyObject* tup = PyTuple_New(2);
3161 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3162 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3163 wxPyEndBlockThreads(blocked);
3164 return tup;
3165 }
3166 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3167 self->SetRowspan(rowspan);
3168 self->SetColspan(colspan);
3169 }
3170 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3171 bool blocked = wxPyBeginBlockThreads();
3172 PyObject* tup = PyTuple_New(2);
3173 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3174 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3175 wxPyEndBlockThreads(blocked);
3176 return tup;
3177 }
3178 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3179 wxPyUserData* data = NULL;
3180 if ( userData ) {
3181 bool blocked = wxPyBeginBlockThreads();
3182 data = new wxPyUserData(userData);
3183 wxPyEndBlockThreads(blocked);
3184 }
3185 return new wxGBSizerItem(window, pos, span, flag, border, data);
3186 }
3187 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3188 wxPyUserData* data = NULL;
3189 if ( userData ) {
3190 bool blocked = wxPyBeginBlockThreads();
3191 data = new wxPyUserData(userData);
3192 wxPyEndBlockThreads(blocked);
3193 }
3194 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3195 }
3196 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3197 wxPyUserData* data = NULL;
3198 if ( userData ) {
3199 bool blocked = wxPyBeginBlockThreads();
3200 data = new wxPyUserData(userData);
3201 wxPyEndBlockThreads(blocked);
3202 }
3203 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3204 }
3205 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3206 int row, col;
3207 self->GetEndPos(row, col);
3208 return wxGBPosition(row, col);
3209 }
3210 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3211
3212 wxPyUserData* data = NULL;
3213 bool blocked = wxPyBeginBlockThreads();
3214 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3215 if ( userData && (info.window || info.sizer || info.gotSize) )
3216 data = new wxPyUserData(userData);
3217 wxPyEndBlockThreads(blocked);
3218
3219 // Now call the real Add method if a valid item type was found
3220 if ( info.window )
3221 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3222 else if ( info.sizer )
3223 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3224 else if (info.gotSize)
3225 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3226 pos, span, flag, border, data);
3227 return NULL;
3228 }
3229
3230
3231 #ifdef __cplusplus
3232 extern "C" {
3233 #endif
3234 static int _wrap_EmptyString_set(PyObject *) {
3235 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3236 return 1;
3237 }
3238
3239
3240 static PyObject *_wrap_EmptyString_get(void) {
3241 PyObject *pyobj;
3242
3243 {
3244 #if wxUSE_UNICODE
3245 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3246 #else
3247 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3248 #endif
3249 }
3250 return pyobj;
3251 }
3252
3253
3254 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3255 PyObject *resultobj;
3256 wxObject *arg1 = (wxObject *) 0 ;
3257 wxString result;
3258 PyObject * obj0 = 0 ;
3259 char *kwnames[] = {
3260 (char *) "self", NULL
3261 };
3262
3263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",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 result = wxObject_GetClassName(arg1);
3269
3270 wxPyEndAllowThreads(__tstate);
3271 if (PyErr_Occurred()) SWIG_fail;
3272 }
3273 {
3274 #if wxUSE_UNICODE
3275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3276 #else
3277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3278 #endif
3279 }
3280 return resultobj;
3281 fail:
3282 return NULL;
3283 }
3284
3285
3286 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3287 PyObject *resultobj;
3288 wxObject *arg1 = (wxObject *) 0 ;
3289 PyObject * obj0 = 0 ;
3290 char *kwnames[] = {
3291 (char *) "self", NULL
3292 };
3293
3294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3296 if (SWIG_arg_fail(1)) SWIG_fail;
3297 {
3298 PyThreadState* __tstate = wxPyBeginAllowThreads();
3299 wxObject_Destroy(arg1);
3300
3301 wxPyEndAllowThreads(__tstate);
3302 if (PyErr_Occurred()) SWIG_fail;
3303 }
3304 Py_INCREF(Py_None); resultobj = Py_None;
3305 return resultobj;
3306 fail:
3307 return NULL;
3308 }
3309
3310
3311 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3312 PyObject *obj;
3313 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3314 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3315 Py_INCREF(obj);
3316 return Py_BuildValue((char *)"");
3317 }
3318 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3319 PyObject *resultobj;
3320 wxSize *arg1 = (wxSize *) 0 ;
3321 int arg2 ;
3322 PyObject * obj0 = 0 ;
3323 PyObject * obj1 = 0 ;
3324 char *kwnames[] = {
3325 (char *) "self",(char *) "x", NULL
3326 };
3327
3328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3330 if (SWIG_arg_fail(1)) SWIG_fail;
3331 {
3332 arg2 = (int)(SWIG_As_int(obj1));
3333 if (SWIG_arg_fail(2)) SWIG_fail;
3334 }
3335 if (arg1) (arg1)->x = arg2;
3336
3337 Py_INCREF(Py_None); resultobj = Py_None;
3338 return resultobj;
3339 fail:
3340 return NULL;
3341 }
3342
3343
3344 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3345 PyObject *resultobj;
3346 wxSize *arg1 = (wxSize *) 0 ;
3347 int result;
3348 PyObject * obj0 = 0 ;
3349 char *kwnames[] = {
3350 (char *) "self", NULL
3351 };
3352
3353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3355 if (SWIG_arg_fail(1)) SWIG_fail;
3356 result = (int) ((arg1)->x);
3357
3358 {
3359 resultobj = SWIG_From_int((int)(result));
3360 }
3361 return resultobj;
3362 fail:
3363 return NULL;
3364 }
3365
3366
3367 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3368 PyObject *resultobj;
3369 wxSize *arg1 = (wxSize *) 0 ;
3370 int arg2 ;
3371 PyObject * obj0 = 0 ;
3372 PyObject * obj1 = 0 ;
3373 char *kwnames[] = {
3374 (char *) "self",(char *) "y", NULL
3375 };
3376
3377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3379 if (SWIG_arg_fail(1)) SWIG_fail;
3380 {
3381 arg2 = (int)(SWIG_As_int(obj1));
3382 if (SWIG_arg_fail(2)) SWIG_fail;
3383 }
3384 if (arg1) (arg1)->y = arg2;
3385
3386 Py_INCREF(Py_None); resultobj = Py_None;
3387 return resultobj;
3388 fail:
3389 return NULL;
3390 }
3391
3392
3393 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3394 PyObject *resultobj;
3395 wxSize *arg1 = (wxSize *) 0 ;
3396 int result;
3397 PyObject * obj0 = 0 ;
3398 char *kwnames[] = {
3399 (char *) "self", NULL
3400 };
3401
3402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3404 if (SWIG_arg_fail(1)) SWIG_fail;
3405 result = (int) ((arg1)->y);
3406
3407 {
3408 resultobj = SWIG_From_int((int)(result));
3409 }
3410 return resultobj;
3411 fail:
3412 return NULL;
3413 }
3414
3415
3416 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3417 PyObject *resultobj;
3418 int arg1 = (int) 0 ;
3419 int arg2 = (int) 0 ;
3420 wxSize *result;
3421 PyObject * obj0 = 0 ;
3422 PyObject * obj1 = 0 ;
3423 char *kwnames[] = {
3424 (char *) "w",(char *) "h", NULL
3425 };
3426
3427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3428 if (obj0) {
3429 {
3430 arg1 = (int)(SWIG_As_int(obj0));
3431 if (SWIG_arg_fail(1)) SWIG_fail;
3432 }
3433 }
3434 if (obj1) {
3435 {
3436 arg2 = (int)(SWIG_As_int(obj1));
3437 if (SWIG_arg_fail(2)) SWIG_fail;
3438 }
3439 }
3440 {
3441 PyThreadState* __tstate = wxPyBeginAllowThreads();
3442 result = (wxSize *)new wxSize(arg1,arg2);
3443
3444 wxPyEndAllowThreads(__tstate);
3445 if (PyErr_Occurred()) SWIG_fail;
3446 }
3447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3448 return resultobj;
3449 fail:
3450 return NULL;
3451 }
3452
3453
3454 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3455 PyObject *resultobj;
3456 wxSize *arg1 = (wxSize *) 0 ;
3457 PyObject * obj0 = 0 ;
3458 char *kwnames[] = {
3459 (char *) "self", NULL
3460 };
3461
3462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3464 if (SWIG_arg_fail(1)) SWIG_fail;
3465 {
3466 PyThreadState* __tstate = wxPyBeginAllowThreads();
3467 delete arg1;
3468
3469 wxPyEndAllowThreads(__tstate);
3470 if (PyErr_Occurred()) SWIG_fail;
3471 }
3472 Py_INCREF(Py_None); resultobj = Py_None;
3473 return resultobj;
3474 fail:
3475 return NULL;
3476 }
3477
3478
3479 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3480 PyObject *resultobj;
3481 wxSize *arg1 = (wxSize *) 0 ;
3482 wxSize *arg2 = 0 ;
3483 bool result;
3484 wxSize temp2 ;
3485 PyObject * obj0 = 0 ;
3486 PyObject * obj1 = 0 ;
3487 char *kwnames[] = {
3488 (char *) "self",(char *) "sz", NULL
3489 };
3490
3491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3493 if (SWIG_arg_fail(1)) SWIG_fail;
3494 {
3495 arg2 = &temp2;
3496 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3497 }
3498 {
3499 PyThreadState* __tstate = wxPyBeginAllowThreads();
3500 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3501
3502 wxPyEndAllowThreads(__tstate);
3503 if (PyErr_Occurred()) SWIG_fail;
3504 }
3505 {
3506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3507 }
3508 return resultobj;
3509 fail:
3510 return NULL;
3511 }
3512
3513
3514 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3515 PyObject *resultobj;
3516 wxSize *arg1 = (wxSize *) 0 ;
3517 wxSize *arg2 = 0 ;
3518 bool result;
3519 wxSize temp2 ;
3520 PyObject * obj0 = 0 ;
3521 PyObject * obj1 = 0 ;
3522 char *kwnames[] = {
3523 (char *) "self",(char *) "sz", NULL
3524 };
3525
3526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3528 if (SWIG_arg_fail(1)) SWIG_fail;
3529 {
3530 arg2 = &temp2;
3531 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3532 }
3533 {
3534 PyThreadState* __tstate = wxPyBeginAllowThreads();
3535 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3536
3537 wxPyEndAllowThreads(__tstate);
3538 if (PyErr_Occurred()) SWIG_fail;
3539 }
3540 {
3541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3542 }
3543 return resultobj;
3544 fail:
3545 return NULL;
3546 }
3547
3548
3549 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3550 PyObject *resultobj;
3551 wxSize *arg1 = (wxSize *) 0 ;
3552 wxSize *arg2 = 0 ;
3553 wxSize result;
3554 wxSize temp2 ;
3555 PyObject * obj0 = 0 ;
3556 PyObject * obj1 = 0 ;
3557 char *kwnames[] = {
3558 (char *) "self",(char *) "sz", NULL
3559 };
3560
3561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3563 if (SWIG_arg_fail(1)) SWIG_fail;
3564 {
3565 arg2 = &temp2;
3566 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3567 }
3568 {
3569 PyThreadState* __tstate = wxPyBeginAllowThreads();
3570 result = (arg1)->operator +((wxSize const &)*arg2);
3571
3572 wxPyEndAllowThreads(__tstate);
3573 if (PyErr_Occurred()) SWIG_fail;
3574 }
3575 {
3576 wxSize * resultptr;
3577 resultptr = new wxSize((wxSize &)(result));
3578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3579 }
3580 return resultobj;
3581 fail:
3582 return NULL;
3583 }
3584
3585
3586 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3587 PyObject *resultobj;
3588 wxSize *arg1 = (wxSize *) 0 ;
3589 wxSize *arg2 = 0 ;
3590 wxSize result;
3591 wxSize temp2 ;
3592 PyObject * obj0 = 0 ;
3593 PyObject * obj1 = 0 ;
3594 char *kwnames[] = {
3595 (char *) "self",(char *) "sz", NULL
3596 };
3597
3598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3600 if (SWIG_arg_fail(1)) SWIG_fail;
3601 {
3602 arg2 = &temp2;
3603 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3604 }
3605 {
3606 PyThreadState* __tstate = wxPyBeginAllowThreads();
3607 result = (arg1)->operator -((wxSize const &)*arg2);
3608
3609 wxPyEndAllowThreads(__tstate);
3610 if (PyErr_Occurred()) SWIG_fail;
3611 }
3612 {
3613 wxSize * resultptr;
3614 resultptr = new wxSize((wxSize &)(result));
3615 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3616 }
3617 return resultobj;
3618 fail:
3619 return NULL;
3620 }
3621
3622
3623 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3624 PyObject *resultobj;
3625 wxSize *arg1 = (wxSize *) 0 ;
3626 wxSize *arg2 = 0 ;
3627 wxSize temp2 ;
3628 PyObject * obj0 = 0 ;
3629 PyObject * obj1 = 0 ;
3630 char *kwnames[] = {
3631 (char *) "self",(char *) "sz", NULL
3632 };
3633
3634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3636 if (SWIG_arg_fail(1)) SWIG_fail;
3637 {
3638 arg2 = &temp2;
3639 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3640 }
3641 {
3642 PyThreadState* __tstate = wxPyBeginAllowThreads();
3643 (arg1)->IncTo((wxSize const &)*arg2);
3644
3645 wxPyEndAllowThreads(__tstate);
3646 if (PyErr_Occurred()) SWIG_fail;
3647 }
3648 Py_INCREF(Py_None); resultobj = Py_None;
3649 return resultobj;
3650 fail:
3651 return NULL;
3652 }
3653
3654
3655 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3656 PyObject *resultobj;
3657 wxSize *arg1 = (wxSize *) 0 ;
3658 wxSize *arg2 = 0 ;
3659 wxSize temp2 ;
3660 PyObject * obj0 = 0 ;
3661 PyObject * obj1 = 0 ;
3662 char *kwnames[] = {
3663 (char *) "self",(char *) "sz", NULL
3664 };
3665
3666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3668 if (SWIG_arg_fail(1)) SWIG_fail;
3669 {
3670 arg2 = &temp2;
3671 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3672 }
3673 {
3674 PyThreadState* __tstate = wxPyBeginAllowThreads();
3675 (arg1)->DecTo((wxSize const &)*arg2);
3676
3677 wxPyEndAllowThreads(__tstate);
3678 if (PyErr_Occurred()) SWIG_fail;
3679 }
3680 Py_INCREF(Py_None); resultobj = Py_None;
3681 return resultobj;
3682 fail:
3683 return NULL;
3684 }
3685
3686
3687 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3688 PyObject *resultobj;
3689 wxSize *arg1 = (wxSize *) 0 ;
3690 int arg2 ;
3691 int arg3 ;
3692 PyObject * obj0 = 0 ;
3693 PyObject * obj1 = 0 ;
3694 PyObject * obj2 = 0 ;
3695 char *kwnames[] = {
3696 (char *) "self",(char *) "w",(char *) "h", NULL
3697 };
3698
3699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3701 if (SWIG_arg_fail(1)) SWIG_fail;
3702 {
3703 arg2 = (int)(SWIG_As_int(obj1));
3704 if (SWIG_arg_fail(2)) SWIG_fail;
3705 }
3706 {
3707 arg3 = (int)(SWIG_As_int(obj2));
3708 if (SWIG_arg_fail(3)) SWIG_fail;
3709 }
3710 {
3711 PyThreadState* __tstate = wxPyBeginAllowThreads();
3712 (arg1)->Set(arg2,arg3);
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_SetWidth(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 *) "w", NULL
3732 };
3733
3734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",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)->SetWidth(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_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3756 PyObject *resultobj;
3757 wxSize *arg1 = (wxSize *) 0 ;
3758 int arg2 ;
3759 PyObject * obj0 = 0 ;
3760 PyObject * obj1 = 0 ;
3761 char *kwnames[] = {
3762 (char *) "self",(char *) "h", NULL
3763 };
3764
3765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3767 if (SWIG_arg_fail(1)) SWIG_fail;
3768 {
3769 arg2 = (int)(SWIG_As_int(obj1));
3770 if (SWIG_arg_fail(2)) SWIG_fail;
3771 }
3772 {
3773 PyThreadState* __tstate = wxPyBeginAllowThreads();
3774 (arg1)->SetHeight(arg2);
3775
3776 wxPyEndAllowThreads(__tstate);
3777 if (PyErr_Occurred()) SWIG_fail;
3778 }
3779 Py_INCREF(Py_None); resultobj = Py_None;
3780 return resultobj;
3781 fail:
3782 return NULL;
3783 }
3784
3785
3786 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3787 PyObject *resultobj;
3788 wxSize *arg1 = (wxSize *) 0 ;
3789 int result;
3790 PyObject * obj0 = 0 ;
3791 char *kwnames[] = {
3792 (char *) "self", NULL
3793 };
3794
3795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3797 if (SWIG_arg_fail(1)) SWIG_fail;
3798 {
3799 PyThreadState* __tstate = wxPyBeginAllowThreads();
3800 result = (int)((wxSize const *)arg1)->GetWidth();
3801
3802 wxPyEndAllowThreads(__tstate);
3803 if (PyErr_Occurred()) SWIG_fail;
3804 }
3805 {
3806 resultobj = SWIG_From_int((int)(result));
3807 }
3808 return resultobj;
3809 fail:
3810 return NULL;
3811 }
3812
3813
3814 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3815 PyObject *resultobj;
3816 wxSize *arg1 = (wxSize *) 0 ;
3817 int result;
3818 PyObject * obj0 = 0 ;
3819 char *kwnames[] = {
3820 (char *) "self", NULL
3821 };
3822
3823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3825 if (SWIG_arg_fail(1)) SWIG_fail;
3826 {
3827 PyThreadState* __tstate = wxPyBeginAllowThreads();
3828 result = (int)((wxSize const *)arg1)->GetHeight();
3829
3830 wxPyEndAllowThreads(__tstate);
3831 if (PyErr_Occurred()) SWIG_fail;
3832 }
3833 {
3834 resultobj = SWIG_From_int((int)(result));
3835 }
3836 return resultobj;
3837 fail:
3838 return NULL;
3839 }
3840
3841
3842 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3843 PyObject *resultobj;
3844 wxSize *arg1 = (wxSize *) 0 ;
3845 bool result;
3846 PyObject * obj0 = 0 ;
3847 char *kwnames[] = {
3848 (char *) "self", NULL
3849 };
3850
3851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3853 if (SWIG_arg_fail(1)) SWIG_fail;
3854 {
3855 PyThreadState* __tstate = wxPyBeginAllowThreads();
3856 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3857
3858 wxPyEndAllowThreads(__tstate);
3859 if (PyErr_Occurred()) SWIG_fail;
3860 }
3861 {
3862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3863 }
3864 return resultobj;
3865 fail:
3866 return NULL;
3867 }
3868
3869
3870 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3871 PyObject *resultobj;
3872 wxSize *arg1 = (wxSize *) 0 ;
3873 wxSize *arg2 = 0 ;
3874 wxSize temp2 ;
3875 PyObject * obj0 = 0 ;
3876 PyObject * obj1 = 0 ;
3877 char *kwnames[] = {
3878 (char *) "self",(char *) "size", NULL
3879 };
3880
3881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3883 if (SWIG_arg_fail(1)) SWIG_fail;
3884 {
3885 arg2 = &temp2;
3886 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3887 }
3888 {
3889 PyThreadState* __tstate = wxPyBeginAllowThreads();
3890 (arg1)->SetDefaults((wxSize const &)*arg2);
3891
3892 wxPyEndAllowThreads(__tstate);
3893 if (PyErr_Occurred()) SWIG_fail;
3894 }
3895 Py_INCREF(Py_None); resultobj = Py_None;
3896 return resultobj;
3897 fail:
3898 return NULL;
3899 }
3900
3901
3902 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3903 PyObject *resultobj;
3904 wxSize *arg1 = (wxSize *) 0 ;
3905 PyObject *result;
3906 PyObject * obj0 = 0 ;
3907 char *kwnames[] = {
3908 (char *) "self", NULL
3909 };
3910
3911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3913 if (SWIG_arg_fail(1)) SWIG_fail;
3914 {
3915 PyThreadState* __tstate = wxPyBeginAllowThreads();
3916 result = (PyObject *)wxSize_Get(arg1);
3917
3918 wxPyEndAllowThreads(__tstate);
3919 if (PyErr_Occurred()) SWIG_fail;
3920 }
3921 resultobj = result;
3922 return resultobj;
3923 fail:
3924 return NULL;
3925 }
3926
3927
3928 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3929 PyObject *obj;
3930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3931 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3932 Py_INCREF(obj);
3933 return Py_BuildValue((char *)"");
3934 }
3935 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3936 PyObject *resultobj;
3937 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3938 double arg2 ;
3939 PyObject * obj0 = 0 ;
3940 PyObject * obj1 = 0 ;
3941 char *kwnames[] = {
3942 (char *) "self",(char *) "x", NULL
3943 };
3944
3945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3947 if (SWIG_arg_fail(1)) SWIG_fail;
3948 {
3949 arg2 = (double)(SWIG_As_double(obj1));
3950 if (SWIG_arg_fail(2)) SWIG_fail;
3951 }
3952 if (arg1) (arg1)->x = arg2;
3953
3954 Py_INCREF(Py_None); resultobj = Py_None;
3955 return resultobj;
3956 fail:
3957 return NULL;
3958 }
3959
3960
3961 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3962 PyObject *resultobj;
3963 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3964 double result;
3965 PyObject * obj0 = 0 ;
3966 char *kwnames[] = {
3967 (char *) "self", NULL
3968 };
3969
3970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3972 if (SWIG_arg_fail(1)) SWIG_fail;
3973 result = (double) ((arg1)->x);
3974
3975 {
3976 resultobj = SWIG_From_double((double)(result));
3977 }
3978 return resultobj;
3979 fail:
3980 return NULL;
3981 }
3982
3983
3984 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3985 PyObject *resultobj;
3986 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3987 double arg2 ;
3988 PyObject * obj0 = 0 ;
3989 PyObject * obj1 = 0 ;
3990 char *kwnames[] = {
3991 (char *) "self",(char *) "y", NULL
3992 };
3993
3994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3996 if (SWIG_arg_fail(1)) SWIG_fail;
3997 {
3998 arg2 = (double)(SWIG_As_double(obj1));
3999 if (SWIG_arg_fail(2)) SWIG_fail;
4000 }
4001 if (arg1) (arg1)->y = arg2;
4002
4003 Py_INCREF(Py_None); resultobj = Py_None;
4004 return resultobj;
4005 fail:
4006 return NULL;
4007 }
4008
4009
4010 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4011 PyObject *resultobj;
4012 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4013 double result;
4014 PyObject * obj0 = 0 ;
4015 char *kwnames[] = {
4016 (char *) "self", NULL
4017 };
4018
4019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4021 if (SWIG_arg_fail(1)) SWIG_fail;
4022 result = (double) ((arg1)->y);
4023
4024 {
4025 resultobj = SWIG_From_double((double)(result));
4026 }
4027 return resultobj;
4028 fail:
4029 return NULL;
4030 }
4031
4032
4033 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4034 PyObject *resultobj;
4035 double arg1 = (double) 0.0 ;
4036 double arg2 = (double) 0.0 ;
4037 wxRealPoint *result;
4038 PyObject * obj0 = 0 ;
4039 PyObject * obj1 = 0 ;
4040 char *kwnames[] = {
4041 (char *) "x",(char *) "y", NULL
4042 };
4043
4044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4045 if (obj0) {
4046 {
4047 arg1 = (double)(SWIG_As_double(obj0));
4048 if (SWIG_arg_fail(1)) SWIG_fail;
4049 }
4050 }
4051 if (obj1) {
4052 {
4053 arg2 = (double)(SWIG_As_double(obj1));
4054 if (SWIG_arg_fail(2)) SWIG_fail;
4055 }
4056 }
4057 {
4058 PyThreadState* __tstate = wxPyBeginAllowThreads();
4059 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4060
4061 wxPyEndAllowThreads(__tstate);
4062 if (PyErr_Occurred()) SWIG_fail;
4063 }
4064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4065 return resultobj;
4066 fail:
4067 return NULL;
4068 }
4069
4070
4071 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4072 PyObject *resultobj;
4073 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4074 PyObject * obj0 = 0 ;
4075 char *kwnames[] = {
4076 (char *) "self", NULL
4077 };
4078
4079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4081 if (SWIG_arg_fail(1)) SWIG_fail;
4082 {
4083 PyThreadState* __tstate = wxPyBeginAllowThreads();
4084 delete arg1;
4085
4086 wxPyEndAllowThreads(__tstate);
4087 if (PyErr_Occurred()) SWIG_fail;
4088 }
4089 Py_INCREF(Py_None); resultobj = Py_None;
4090 return resultobj;
4091 fail:
4092 return NULL;
4093 }
4094
4095
4096 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4097 PyObject *resultobj;
4098 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4099 wxRealPoint *arg2 = 0 ;
4100 bool result;
4101 wxRealPoint temp2 ;
4102 PyObject * obj0 = 0 ;
4103 PyObject * obj1 = 0 ;
4104 char *kwnames[] = {
4105 (char *) "self",(char *) "pt", NULL
4106 };
4107
4108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4110 if (SWIG_arg_fail(1)) SWIG_fail;
4111 {
4112 arg2 = &temp2;
4113 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4114 }
4115 {
4116 PyThreadState* __tstate = wxPyBeginAllowThreads();
4117 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4118
4119 wxPyEndAllowThreads(__tstate);
4120 if (PyErr_Occurred()) SWIG_fail;
4121 }
4122 {
4123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4124 }
4125 return resultobj;
4126 fail:
4127 return NULL;
4128 }
4129
4130
4131 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4132 PyObject *resultobj;
4133 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4134 wxRealPoint *arg2 = 0 ;
4135 bool result;
4136 wxRealPoint temp2 ;
4137 PyObject * obj0 = 0 ;
4138 PyObject * obj1 = 0 ;
4139 char *kwnames[] = {
4140 (char *) "self",(char *) "pt", NULL
4141 };
4142
4143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4145 if (SWIG_arg_fail(1)) SWIG_fail;
4146 {
4147 arg2 = &temp2;
4148 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4149 }
4150 {
4151 PyThreadState* __tstate = wxPyBeginAllowThreads();
4152 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4153
4154 wxPyEndAllowThreads(__tstate);
4155 if (PyErr_Occurred()) SWIG_fail;
4156 }
4157 {
4158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4159 }
4160 return resultobj;
4161 fail:
4162 return NULL;
4163 }
4164
4165
4166 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4167 PyObject *resultobj;
4168 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4169 wxRealPoint *arg2 = 0 ;
4170 wxRealPoint result;
4171 wxRealPoint temp2 ;
4172 PyObject * obj0 = 0 ;
4173 PyObject * obj1 = 0 ;
4174 char *kwnames[] = {
4175 (char *) "self",(char *) "pt", NULL
4176 };
4177
4178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4180 if (SWIG_arg_fail(1)) SWIG_fail;
4181 {
4182 arg2 = &temp2;
4183 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4184 }
4185 {
4186 PyThreadState* __tstate = wxPyBeginAllowThreads();
4187 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4188
4189 wxPyEndAllowThreads(__tstate);
4190 if (PyErr_Occurred()) SWIG_fail;
4191 }
4192 {
4193 wxRealPoint * resultptr;
4194 resultptr = new wxRealPoint((wxRealPoint &)(result));
4195 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4196 }
4197 return resultobj;
4198 fail:
4199 return NULL;
4200 }
4201
4202
4203 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4204 PyObject *resultobj;
4205 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4206 wxRealPoint *arg2 = 0 ;
4207 wxRealPoint result;
4208 wxRealPoint temp2 ;
4209 PyObject * obj0 = 0 ;
4210 PyObject * obj1 = 0 ;
4211 char *kwnames[] = {
4212 (char *) "self",(char *) "pt", NULL
4213 };
4214
4215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4217 if (SWIG_arg_fail(1)) SWIG_fail;
4218 {
4219 arg2 = &temp2;
4220 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4221 }
4222 {
4223 PyThreadState* __tstate = wxPyBeginAllowThreads();
4224 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4225
4226 wxPyEndAllowThreads(__tstate);
4227 if (PyErr_Occurred()) SWIG_fail;
4228 }
4229 {
4230 wxRealPoint * resultptr;
4231 resultptr = new wxRealPoint((wxRealPoint &)(result));
4232 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4233 }
4234 return resultobj;
4235 fail:
4236 return NULL;
4237 }
4238
4239
4240 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4241 PyObject *resultobj;
4242 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4243 double arg2 ;
4244 double arg3 ;
4245 PyObject * obj0 = 0 ;
4246 PyObject * obj1 = 0 ;
4247 PyObject * obj2 = 0 ;
4248 char *kwnames[] = {
4249 (char *) "self",(char *) "x",(char *) "y", NULL
4250 };
4251
4252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4254 if (SWIG_arg_fail(1)) SWIG_fail;
4255 {
4256 arg2 = (double)(SWIG_As_double(obj1));
4257 if (SWIG_arg_fail(2)) SWIG_fail;
4258 }
4259 {
4260 arg3 = (double)(SWIG_As_double(obj2));
4261 if (SWIG_arg_fail(3)) SWIG_fail;
4262 }
4263 {
4264 PyThreadState* __tstate = wxPyBeginAllowThreads();
4265 wxRealPoint_Set(arg1,arg2,arg3);
4266
4267 wxPyEndAllowThreads(__tstate);
4268 if (PyErr_Occurred()) SWIG_fail;
4269 }
4270 Py_INCREF(Py_None); resultobj = Py_None;
4271 return resultobj;
4272 fail:
4273 return NULL;
4274 }
4275
4276
4277 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4278 PyObject *resultobj;
4279 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4280 PyObject *result;
4281 PyObject * obj0 = 0 ;
4282 char *kwnames[] = {
4283 (char *) "self", NULL
4284 };
4285
4286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4288 if (SWIG_arg_fail(1)) SWIG_fail;
4289 {
4290 PyThreadState* __tstate = wxPyBeginAllowThreads();
4291 result = (PyObject *)wxRealPoint_Get(arg1);
4292
4293 wxPyEndAllowThreads(__tstate);
4294 if (PyErr_Occurred()) SWIG_fail;
4295 }
4296 resultobj = result;
4297 return resultobj;
4298 fail:
4299 return NULL;
4300 }
4301
4302
4303 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4304 PyObject *obj;
4305 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4306 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4307 Py_INCREF(obj);
4308 return Py_BuildValue((char *)"");
4309 }
4310 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4311 PyObject *resultobj;
4312 wxPoint *arg1 = (wxPoint *) 0 ;
4313 int arg2 ;
4314 PyObject * obj0 = 0 ;
4315 PyObject * obj1 = 0 ;
4316 char *kwnames[] = {
4317 (char *) "self",(char *) "x", NULL
4318 };
4319
4320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4322 if (SWIG_arg_fail(1)) SWIG_fail;
4323 {
4324 arg2 = (int)(SWIG_As_int(obj1));
4325 if (SWIG_arg_fail(2)) SWIG_fail;
4326 }
4327 if (arg1) (arg1)->x = arg2;
4328
4329 Py_INCREF(Py_None); resultobj = Py_None;
4330 return resultobj;
4331 fail:
4332 return NULL;
4333 }
4334
4335
4336 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4337 PyObject *resultobj;
4338 wxPoint *arg1 = (wxPoint *) 0 ;
4339 int result;
4340 PyObject * obj0 = 0 ;
4341 char *kwnames[] = {
4342 (char *) "self", NULL
4343 };
4344
4345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4347 if (SWIG_arg_fail(1)) SWIG_fail;
4348 result = (int) ((arg1)->x);
4349
4350 {
4351 resultobj = SWIG_From_int((int)(result));
4352 }
4353 return resultobj;
4354 fail:
4355 return NULL;
4356 }
4357
4358
4359 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4360 PyObject *resultobj;
4361 wxPoint *arg1 = (wxPoint *) 0 ;
4362 int arg2 ;
4363 PyObject * obj0 = 0 ;
4364 PyObject * obj1 = 0 ;
4365 char *kwnames[] = {
4366 (char *) "self",(char *) "y", NULL
4367 };
4368
4369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4371 if (SWIG_arg_fail(1)) SWIG_fail;
4372 {
4373 arg2 = (int)(SWIG_As_int(obj1));
4374 if (SWIG_arg_fail(2)) SWIG_fail;
4375 }
4376 if (arg1) (arg1)->y = arg2;
4377
4378 Py_INCREF(Py_None); resultobj = Py_None;
4379 return resultobj;
4380 fail:
4381 return NULL;
4382 }
4383
4384
4385 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4386 PyObject *resultobj;
4387 wxPoint *arg1 = (wxPoint *) 0 ;
4388 int result;
4389 PyObject * obj0 = 0 ;
4390 char *kwnames[] = {
4391 (char *) "self", NULL
4392 };
4393
4394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4396 if (SWIG_arg_fail(1)) SWIG_fail;
4397 result = (int) ((arg1)->y);
4398
4399 {
4400 resultobj = SWIG_From_int((int)(result));
4401 }
4402 return resultobj;
4403 fail:
4404 return NULL;
4405 }
4406
4407
4408 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4409 PyObject *resultobj;
4410 int arg1 = (int) 0 ;
4411 int arg2 = (int) 0 ;
4412 wxPoint *result;
4413 PyObject * obj0 = 0 ;
4414 PyObject * obj1 = 0 ;
4415 char *kwnames[] = {
4416 (char *) "x",(char *) "y", NULL
4417 };
4418
4419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4420 if (obj0) {
4421 {
4422 arg1 = (int)(SWIG_As_int(obj0));
4423 if (SWIG_arg_fail(1)) SWIG_fail;
4424 }
4425 }
4426 if (obj1) {
4427 {
4428 arg2 = (int)(SWIG_As_int(obj1));
4429 if (SWIG_arg_fail(2)) SWIG_fail;
4430 }
4431 }
4432 {
4433 PyThreadState* __tstate = wxPyBeginAllowThreads();
4434 result = (wxPoint *)new wxPoint(arg1,arg2);
4435
4436 wxPyEndAllowThreads(__tstate);
4437 if (PyErr_Occurred()) SWIG_fail;
4438 }
4439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4440 return resultobj;
4441 fail:
4442 return NULL;
4443 }
4444
4445
4446 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4447 PyObject *resultobj;
4448 wxPoint *arg1 = (wxPoint *) 0 ;
4449 PyObject * obj0 = 0 ;
4450 char *kwnames[] = {
4451 (char *) "self", NULL
4452 };
4453
4454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4456 if (SWIG_arg_fail(1)) SWIG_fail;
4457 {
4458 PyThreadState* __tstate = wxPyBeginAllowThreads();
4459 delete arg1;
4460
4461 wxPyEndAllowThreads(__tstate);
4462 if (PyErr_Occurred()) SWIG_fail;
4463 }
4464 Py_INCREF(Py_None); resultobj = Py_None;
4465 return resultobj;
4466 fail:
4467 return NULL;
4468 }
4469
4470
4471 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4472 PyObject *resultobj;
4473 wxPoint *arg1 = (wxPoint *) 0 ;
4474 wxPoint *arg2 = 0 ;
4475 bool result;
4476 wxPoint temp2 ;
4477 PyObject * obj0 = 0 ;
4478 PyObject * obj1 = 0 ;
4479 char *kwnames[] = {
4480 (char *) "self",(char *) "pt", NULL
4481 };
4482
4483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4485 if (SWIG_arg_fail(1)) SWIG_fail;
4486 {
4487 arg2 = &temp2;
4488 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4489 }
4490 {
4491 PyThreadState* __tstate = wxPyBeginAllowThreads();
4492 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4493
4494 wxPyEndAllowThreads(__tstate);
4495 if (PyErr_Occurred()) SWIG_fail;
4496 }
4497 {
4498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4499 }
4500 return resultobj;
4501 fail:
4502 return NULL;
4503 }
4504
4505
4506 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4507 PyObject *resultobj;
4508 wxPoint *arg1 = (wxPoint *) 0 ;
4509 wxPoint *arg2 = 0 ;
4510 bool result;
4511 wxPoint temp2 ;
4512 PyObject * obj0 = 0 ;
4513 PyObject * obj1 = 0 ;
4514 char *kwnames[] = {
4515 (char *) "self",(char *) "pt", NULL
4516 };
4517
4518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4520 if (SWIG_arg_fail(1)) SWIG_fail;
4521 {
4522 arg2 = &temp2;
4523 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4524 }
4525 {
4526 PyThreadState* __tstate = wxPyBeginAllowThreads();
4527 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4528
4529 wxPyEndAllowThreads(__tstate);
4530 if (PyErr_Occurred()) SWIG_fail;
4531 }
4532 {
4533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4534 }
4535 return resultobj;
4536 fail:
4537 return NULL;
4538 }
4539
4540
4541 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4542 PyObject *resultobj;
4543 wxPoint *arg1 = (wxPoint *) 0 ;
4544 wxPoint *arg2 = 0 ;
4545 wxPoint result;
4546 wxPoint temp2 ;
4547 PyObject * obj0 = 0 ;
4548 PyObject * obj1 = 0 ;
4549 char *kwnames[] = {
4550 (char *) "self",(char *) "pt", NULL
4551 };
4552
4553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4555 if (SWIG_arg_fail(1)) SWIG_fail;
4556 {
4557 arg2 = &temp2;
4558 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4559 }
4560 {
4561 PyThreadState* __tstate = wxPyBeginAllowThreads();
4562 result = (arg1)->operator +((wxPoint const &)*arg2);
4563
4564 wxPyEndAllowThreads(__tstate);
4565 if (PyErr_Occurred()) SWIG_fail;
4566 }
4567 {
4568 wxPoint * resultptr;
4569 resultptr = new wxPoint((wxPoint &)(result));
4570 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4571 }
4572 return resultobj;
4573 fail:
4574 return NULL;
4575 }
4576
4577
4578 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4579 PyObject *resultobj;
4580 wxPoint *arg1 = (wxPoint *) 0 ;
4581 wxPoint *arg2 = 0 ;
4582 wxPoint result;
4583 wxPoint temp2 ;
4584 PyObject * obj0 = 0 ;
4585 PyObject * obj1 = 0 ;
4586 char *kwnames[] = {
4587 (char *) "self",(char *) "pt", NULL
4588 };
4589
4590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4592 if (SWIG_arg_fail(1)) SWIG_fail;
4593 {
4594 arg2 = &temp2;
4595 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4596 }
4597 {
4598 PyThreadState* __tstate = wxPyBeginAllowThreads();
4599 result = (arg1)->operator -((wxPoint const &)*arg2);
4600
4601 wxPyEndAllowThreads(__tstate);
4602 if (PyErr_Occurred()) SWIG_fail;
4603 }
4604 {
4605 wxPoint * resultptr;
4606 resultptr = new wxPoint((wxPoint &)(result));
4607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4608 }
4609 return resultobj;
4610 fail:
4611 return NULL;
4612 }
4613
4614
4615 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4616 PyObject *resultobj;
4617 wxPoint *arg1 = (wxPoint *) 0 ;
4618 wxPoint *arg2 = 0 ;
4619 wxPoint *result;
4620 wxPoint temp2 ;
4621 PyObject * obj0 = 0 ;
4622 PyObject * obj1 = 0 ;
4623 char *kwnames[] = {
4624 (char *) "self",(char *) "pt", NULL
4625 };
4626
4627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4629 if (SWIG_arg_fail(1)) SWIG_fail;
4630 {
4631 arg2 = &temp2;
4632 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4633 }
4634 {
4635 PyThreadState* __tstate = wxPyBeginAllowThreads();
4636 {
4637 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4638 result = (wxPoint *) &_result_ref;
4639 }
4640
4641 wxPyEndAllowThreads(__tstate);
4642 if (PyErr_Occurred()) SWIG_fail;
4643 }
4644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4645 return resultobj;
4646 fail:
4647 return NULL;
4648 }
4649
4650
4651 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4652 PyObject *resultobj;
4653 wxPoint *arg1 = (wxPoint *) 0 ;
4654 wxPoint *arg2 = 0 ;
4655 wxPoint *result;
4656 wxPoint temp2 ;
4657 PyObject * obj0 = 0 ;
4658 PyObject * obj1 = 0 ;
4659 char *kwnames[] = {
4660 (char *) "self",(char *) "pt", NULL
4661 };
4662
4663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4665 if (SWIG_arg_fail(1)) SWIG_fail;
4666 {
4667 arg2 = &temp2;
4668 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4669 }
4670 {
4671 PyThreadState* __tstate = wxPyBeginAllowThreads();
4672 {
4673 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4674 result = (wxPoint *) &_result_ref;
4675 }
4676
4677 wxPyEndAllowThreads(__tstate);
4678 if (PyErr_Occurred()) SWIG_fail;
4679 }
4680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4681 return resultobj;
4682 fail:
4683 return NULL;
4684 }
4685
4686
4687 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4688 PyObject *resultobj;
4689 wxPoint *arg1 = (wxPoint *) 0 ;
4690 long arg2 ;
4691 long arg3 ;
4692 PyObject * obj0 = 0 ;
4693 PyObject * obj1 = 0 ;
4694 PyObject * obj2 = 0 ;
4695 char *kwnames[] = {
4696 (char *) "self",(char *) "x",(char *) "y", NULL
4697 };
4698
4699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4701 if (SWIG_arg_fail(1)) SWIG_fail;
4702 {
4703 arg2 = (long)(SWIG_As_long(obj1));
4704 if (SWIG_arg_fail(2)) SWIG_fail;
4705 }
4706 {
4707 arg3 = (long)(SWIG_As_long(obj2));
4708 if (SWIG_arg_fail(3)) SWIG_fail;
4709 }
4710 {
4711 PyThreadState* __tstate = wxPyBeginAllowThreads();
4712 wxPoint_Set(arg1,arg2,arg3);
4713
4714 wxPyEndAllowThreads(__tstate);
4715 if (PyErr_Occurred()) SWIG_fail;
4716 }
4717 Py_INCREF(Py_None); resultobj = Py_None;
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj;
4726 wxPoint *arg1 = (wxPoint *) 0 ;
4727 PyObject *result;
4728 PyObject * obj0 = 0 ;
4729 char *kwnames[] = {
4730 (char *) "self", NULL
4731 };
4732
4733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4735 if (SWIG_arg_fail(1)) SWIG_fail;
4736 {
4737 PyThreadState* __tstate = wxPyBeginAllowThreads();
4738 result = (PyObject *)wxPoint_Get(arg1);
4739
4740 wxPyEndAllowThreads(__tstate);
4741 if (PyErr_Occurred()) SWIG_fail;
4742 }
4743 resultobj = result;
4744 return resultobj;
4745 fail:
4746 return NULL;
4747 }
4748
4749
4750 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4751 PyObject *obj;
4752 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4753 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4754 Py_INCREF(obj);
4755 return Py_BuildValue((char *)"");
4756 }
4757 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4758 PyObject *resultobj;
4759 int arg1 = (int) 0 ;
4760 int arg2 = (int) 0 ;
4761 int arg3 = (int) 0 ;
4762 int arg4 = (int) 0 ;
4763 wxRect *result;
4764 PyObject * obj0 = 0 ;
4765 PyObject * obj1 = 0 ;
4766 PyObject * obj2 = 0 ;
4767 PyObject * obj3 = 0 ;
4768 char *kwnames[] = {
4769 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4770 };
4771
4772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4773 if (obj0) {
4774 {
4775 arg1 = (int)(SWIG_As_int(obj0));
4776 if (SWIG_arg_fail(1)) SWIG_fail;
4777 }
4778 }
4779 if (obj1) {
4780 {
4781 arg2 = (int)(SWIG_As_int(obj1));
4782 if (SWIG_arg_fail(2)) SWIG_fail;
4783 }
4784 }
4785 if (obj2) {
4786 {
4787 arg3 = (int)(SWIG_As_int(obj2));
4788 if (SWIG_arg_fail(3)) SWIG_fail;
4789 }
4790 }
4791 if (obj3) {
4792 {
4793 arg4 = (int)(SWIG_As_int(obj3));
4794 if (SWIG_arg_fail(4)) SWIG_fail;
4795 }
4796 }
4797 {
4798 PyThreadState* __tstate = wxPyBeginAllowThreads();
4799 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4800
4801 wxPyEndAllowThreads(__tstate);
4802 if (PyErr_Occurred()) SWIG_fail;
4803 }
4804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4805 return resultobj;
4806 fail:
4807 return NULL;
4808 }
4809
4810
4811 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4812 PyObject *resultobj;
4813 wxPoint *arg1 = 0 ;
4814 wxPoint *arg2 = 0 ;
4815 wxRect *result;
4816 wxPoint temp1 ;
4817 wxPoint temp2 ;
4818 PyObject * obj0 = 0 ;
4819 PyObject * obj1 = 0 ;
4820 char *kwnames[] = {
4821 (char *) "topLeft",(char *) "bottomRight", NULL
4822 };
4823
4824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4825 {
4826 arg1 = &temp1;
4827 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4828 }
4829 {
4830 arg2 = &temp2;
4831 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4832 }
4833 {
4834 PyThreadState* __tstate = wxPyBeginAllowThreads();
4835 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4836
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4841 return resultobj;
4842 fail:
4843 return NULL;
4844 }
4845
4846
4847 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4848 PyObject *resultobj;
4849 wxPoint *arg1 = 0 ;
4850 wxSize *arg2 = 0 ;
4851 wxRect *result;
4852 wxPoint temp1 ;
4853 wxSize temp2 ;
4854 PyObject * obj0 = 0 ;
4855 PyObject * obj1 = 0 ;
4856 char *kwnames[] = {
4857 (char *) "pos",(char *) "size", NULL
4858 };
4859
4860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4861 {
4862 arg1 = &temp1;
4863 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4864 }
4865 {
4866 arg2 = &temp2;
4867 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4868 }
4869 {
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4872
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4877 return resultobj;
4878 fail:
4879 return NULL;
4880 }
4881
4882
4883 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4884 PyObject *resultobj;
4885 wxSize *arg1 = 0 ;
4886 wxRect *result;
4887 wxSize temp1 ;
4888 PyObject * obj0 = 0 ;
4889 char *kwnames[] = {
4890 (char *) "size", NULL
4891 };
4892
4893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4894 {
4895 arg1 = &temp1;
4896 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4897 }
4898 {
4899 PyThreadState* __tstate = wxPyBeginAllowThreads();
4900 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4901
4902 wxPyEndAllowThreads(__tstate);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4913 PyObject *resultobj;
4914 wxRect *arg1 = (wxRect *) 0 ;
4915 PyObject * obj0 = 0 ;
4916 char *kwnames[] = {
4917 (char *) "self", NULL
4918 };
4919
4920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4922 if (SWIG_arg_fail(1)) SWIG_fail;
4923 {
4924 PyThreadState* __tstate = wxPyBeginAllowThreads();
4925 delete arg1;
4926
4927 wxPyEndAllowThreads(__tstate);
4928 if (PyErr_Occurred()) SWIG_fail;
4929 }
4930 Py_INCREF(Py_None); resultobj = Py_None;
4931 return resultobj;
4932 fail:
4933 return NULL;
4934 }
4935
4936
4937 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4938 PyObject *resultobj;
4939 wxRect *arg1 = (wxRect *) 0 ;
4940 int result;
4941 PyObject * obj0 = 0 ;
4942 char *kwnames[] = {
4943 (char *) "self", NULL
4944 };
4945
4946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4948 if (SWIG_arg_fail(1)) SWIG_fail;
4949 {
4950 PyThreadState* __tstate = wxPyBeginAllowThreads();
4951 result = (int)((wxRect const *)arg1)->GetX();
4952
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 {
4957 resultobj = SWIG_From_int((int)(result));
4958 }
4959 return resultobj;
4960 fail:
4961 return NULL;
4962 }
4963
4964
4965 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4966 PyObject *resultobj;
4967 wxRect *arg1 = (wxRect *) 0 ;
4968 int arg2 ;
4969 PyObject * obj0 = 0 ;
4970 PyObject * obj1 = 0 ;
4971 char *kwnames[] = {
4972 (char *) "self",(char *) "x", NULL
4973 };
4974
4975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4977 if (SWIG_arg_fail(1)) SWIG_fail;
4978 {
4979 arg2 = (int)(SWIG_As_int(obj1));
4980 if (SWIG_arg_fail(2)) SWIG_fail;
4981 }
4982 {
4983 PyThreadState* __tstate = wxPyBeginAllowThreads();
4984 (arg1)->SetX(arg2);
4985
4986 wxPyEndAllowThreads(__tstate);
4987 if (PyErr_Occurred()) SWIG_fail;
4988 }
4989 Py_INCREF(Py_None); resultobj = Py_None;
4990 return resultobj;
4991 fail:
4992 return NULL;
4993 }
4994
4995
4996 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4997 PyObject *resultobj;
4998 wxRect *arg1 = (wxRect *) 0 ;
4999 int result;
5000 PyObject * obj0 = 0 ;
5001 char *kwnames[] = {
5002 (char *) "self", NULL
5003 };
5004
5005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5007 if (SWIG_arg_fail(1)) SWIG_fail;
5008 {
5009 PyThreadState* __tstate = wxPyBeginAllowThreads();
5010 result = (int)(arg1)->GetY();
5011
5012 wxPyEndAllowThreads(__tstate);
5013 if (PyErr_Occurred()) SWIG_fail;
5014 }
5015 {
5016 resultobj = SWIG_From_int((int)(result));
5017 }
5018 return resultobj;
5019 fail:
5020 return NULL;
5021 }
5022
5023
5024 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5025 PyObject *resultobj;
5026 wxRect *arg1 = (wxRect *) 0 ;
5027 int arg2 ;
5028 PyObject * obj0 = 0 ;
5029 PyObject * obj1 = 0 ;
5030 char *kwnames[] = {
5031 (char *) "self",(char *) "y", NULL
5032 };
5033
5034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5036 if (SWIG_arg_fail(1)) SWIG_fail;
5037 {
5038 arg2 = (int)(SWIG_As_int(obj1));
5039 if (SWIG_arg_fail(2)) SWIG_fail;
5040 }
5041 {
5042 PyThreadState* __tstate = wxPyBeginAllowThreads();
5043 (arg1)->SetY(arg2);
5044
5045 wxPyEndAllowThreads(__tstate);
5046 if (PyErr_Occurred()) SWIG_fail;
5047 }
5048 Py_INCREF(Py_None); resultobj = Py_None;
5049 return resultobj;
5050 fail:
5051 return NULL;
5052 }
5053
5054
5055 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5056 PyObject *resultobj;
5057 wxRect *arg1 = (wxRect *) 0 ;
5058 int result;
5059 PyObject * obj0 = 0 ;
5060 char *kwnames[] = {
5061 (char *) "self", NULL
5062 };
5063
5064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5066 if (SWIG_arg_fail(1)) SWIG_fail;
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = (int)((wxRect const *)arg1)->GetWidth();
5070
5071 wxPyEndAllowThreads(__tstate);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 {
5075 resultobj = SWIG_From_int((int)(result));
5076 }
5077 return resultobj;
5078 fail:
5079 return NULL;
5080 }
5081
5082
5083 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5084 PyObject *resultobj;
5085 wxRect *arg1 = (wxRect *) 0 ;
5086 int arg2 ;
5087 PyObject * obj0 = 0 ;
5088 PyObject * obj1 = 0 ;
5089 char *kwnames[] = {
5090 (char *) "self",(char *) "w", NULL
5091 };
5092
5093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5095 if (SWIG_arg_fail(1)) SWIG_fail;
5096 {
5097 arg2 = (int)(SWIG_As_int(obj1));
5098 if (SWIG_arg_fail(2)) SWIG_fail;
5099 }
5100 {
5101 PyThreadState* __tstate = wxPyBeginAllowThreads();
5102 (arg1)->SetWidth(arg2);
5103
5104 wxPyEndAllowThreads(__tstate);
5105 if (PyErr_Occurred()) SWIG_fail;
5106 }
5107 Py_INCREF(Py_None); resultobj = Py_None;
5108 return resultobj;
5109 fail:
5110 return NULL;
5111 }
5112
5113
5114 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5115 PyObject *resultobj;
5116 wxRect *arg1 = (wxRect *) 0 ;
5117 int result;
5118 PyObject * obj0 = 0 ;
5119 char *kwnames[] = {
5120 (char *) "self", NULL
5121 };
5122
5123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5125 if (SWIG_arg_fail(1)) SWIG_fail;
5126 {
5127 PyThreadState* __tstate = wxPyBeginAllowThreads();
5128 result = (int)((wxRect const *)arg1)->GetHeight();
5129
5130 wxPyEndAllowThreads(__tstate);
5131 if (PyErr_Occurred()) SWIG_fail;
5132 }
5133 {
5134 resultobj = SWIG_From_int((int)(result));
5135 }
5136 return resultobj;
5137 fail:
5138 return NULL;
5139 }
5140
5141
5142 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5143 PyObject *resultobj;
5144 wxRect *arg1 = (wxRect *) 0 ;
5145 int arg2 ;
5146 PyObject * obj0 = 0 ;
5147 PyObject * obj1 = 0 ;
5148 char *kwnames[] = {
5149 (char *) "self",(char *) "h", NULL
5150 };
5151
5152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5154 if (SWIG_arg_fail(1)) SWIG_fail;
5155 {
5156 arg2 = (int)(SWIG_As_int(obj1));
5157 if (SWIG_arg_fail(2)) SWIG_fail;
5158 }
5159 {
5160 PyThreadState* __tstate = wxPyBeginAllowThreads();
5161 (arg1)->SetHeight(arg2);
5162
5163 wxPyEndAllowThreads(__tstate);
5164 if (PyErr_Occurred()) SWIG_fail;
5165 }
5166 Py_INCREF(Py_None); resultobj = Py_None;
5167 return resultobj;
5168 fail:
5169 return NULL;
5170 }
5171
5172
5173 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5174 PyObject *resultobj;
5175 wxRect *arg1 = (wxRect *) 0 ;
5176 wxPoint result;
5177 PyObject * obj0 = 0 ;
5178 char *kwnames[] = {
5179 (char *) "self", NULL
5180 };
5181
5182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5184 if (SWIG_arg_fail(1)) SWIG_fail;
5185 {
5186 PyThreadState* __tstate = wxPyBeginAllowThreads();
5187 result = ((wxRect const *)arg1)->GetPosition();
5188
5189 wxPyEndAllowThreads(__tstate);
5190 if (PyErr_Occurred()) SWIG_fail;
5191 }
5192 {
5193 wxPoint * resultptr;
5194 resultptr = new wxPoint((wxPoint &)(result));
5195 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5196 }
5197 return resultobj;
5198 fail:
5199 return NULL;
5200 }
5201
5202
5203 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5204 PyObject *resultobj;
5205 wxRect *arg1 = (wxRect *) 0 ;
5206 wxPoint *arg2 = 0 ;
5207 wxPoint temp2 ;
5208 PyObject * obj0 = 0 ;
5209 PyObject * obj1 = 0 ;
5210 char *kwnames[] = {
5211 (char *) "self",(char *) "p", NULL
5212 };
5213
5214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5216 if (SWIG_arg_fail(1)) SWIG_fail;
5217 {
5218 arg2 = &temp2;
5219 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5220 }
5221 {
5222 PyThreadState* __tstate = wxPyBeginAllowThreads();
5223 (arg1)->SetPosition((wxPoint const &)*arg2);
5224
5225 wxPyEndAllowThreads(__tstate);
5226 if (PyErr_Occurred()) SWIG_fail;
5227 }
5228 Py_INCREF(Py_None); resultobj = Py_None;
5229 return resultobj;
5230 fail:
5231 return NULL;
5232 }
5233
5234
5235 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5236 PyObject *resultobj;
5237 wxRect *arg1 = (wxRect *) 0 ;
5238 wxSize result;
5239 PyObject * obj0 = 0 ;
5240 char *kwnames[] = {
5241 (char *) "self", NULL
5242 };
5243
5244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5246 if (SWIG_arg_fail(1)) SWIG_fail;
5247 {
5248 PyThreadState* __tstate = wxPyBeginAllowThreads();
5249 result = ((wxRect const *)arg1)->GetSize();
5250
5251 wxPyEndAllowThreads(__tstate);
5252 if (PyErr_Occurred()) SWIG_fail;
5253 }
5254 {
5255 wxSize * resultptr;
5256 resultptr = new wxSize((wxSize &)(result));
5257 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5258 }
5259 return resultobj;
5260 fail:
5261 return NULL;
5262 }
5263
5264
5265 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5266 PyObject *resultobj;
5267 wxRect *arg1 = (wxRect *) 0 ;
5268 wxSize *arg2 = 0 ;
5269 wxSize temp2 ;
5270 PyObject * obj0 = 0 ;
5271 PyObject * obj1 = 0 ;
5272 char *kwnames[] = {
5273 (char *) "self",(char *) "s", NULL
5274 };
5275
5276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5278 if (SWIG_arg_fail(1)) SWIG_fail;
5279 {
5280 arg2 = &temp2;
5281 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5282 }
5283 {
5284 PyThreadState* __tstate = wxPyBeginAllowThreads();
5285 (arg1)->SetSize((wxSize const &)*arg2);
5286
5287 wxPyEndAllowThreads(__tstate);
5288 if (PyErr_Occurred()) SWIG_fail;
5289 }
5290 Py_INCREF(Py_None); resultobj = Py_None;
5291 return resultobj;
5292 fail:
5293 return NULL;
5294 }
5295
5296
5297 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5298 PyObject *resultobj;
5299 wxRect *arg1 = (wxRect *) 0 ;
5300 wxPoint result;
5301 PyObject * obj0 = 0 ;
5302 char *kwnames[] = {
5303 (char *) "self", NULL
5304 };
5305
5306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5308 if (SWIG_arg_fail(1)) SWIG_fail;
5309 {
5310 PyThreadState* __tstate = wxPyBeginAllowThreads();
5311 result = ((wxRect const *)arg1)->GetTopLeft();
5312
5313 wxPyEndAllowThreads(__tstate);
5314 if (PyErr_Occurred()) SWIG_fail;
5315 }
5316 {
5317 wxPoint * resultptr;
5318 resultptr = new wxPoint((wxPoint &)(result));
5319 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5320 }
5321 return resultobj;
5322 fail:
5323 return NULL;
5324 }
5325
5326
5327 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5328 PyObject *resultobj;
5329 wxRect *arg1 = (wxRect *) 0 ;
5330 wxPoint *arg2 = 0 ;
5331 wxPoint temp2 ;
5332 PyObject * obj0 = 0 ;
5333 PyObject * obj1 = 0 ;
5334 char *kwnames[] = {
5335 (char *) "self",(char *) "p", NULL
5336 };
5337
5338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5340 if (SWIG_arg_fail(1)) SWIG_fail;
5341 {
5342 arg2 = &temp2;
5343 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5344 }
5345 {
5346 PyThreadState* __tstate = wxPyBeginAllowThreads();
5347 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5348
5349 wxPyEndAllowThreads(__tstate);
5350 if (PyErr_Occurred()) SWIG_fail;
5351 }
5352 Py_INCREF(Py_None); resultobj = Py_None;
5353 return resultobj;
5354 fail:
5355 return NULL;
5356 }
5357
5358
5359 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5360 PyObject *resultobj;
5361 wxRect *arg1 = (wxRect *) 0 ;
5362 wxPoint result;
5363 PyObject * obj0 = 0 ;
5364 char *kwnames[] = {
5365 (char *) "self", NULL
5366 };
5367
5368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5370 if (SWIG_arg_fail(1)) SWIG_fail;
5371 {
5372 PyThreadState* __tstate = wxPyBeginAllowThreads();
5373 result = ((wxRect const *)arg1)->GetBottomRight();
5374
5375 wxPyEndAllowThreads(__tstate);
5376 if (PyErr_Occurred()) SWIG_fail;
5377 }
5378 {
5379 wxPoint * resultptr;
5380 resultptr = new wxPoint((wxPoint &)(result));
5381 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5382 }
5383 return resultobj;
5384 fail:
5385 return NULL;
5386 }
5387
5388
5389 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5390 PyObject *resultobj;
5391 wxRect *arg1 = (wxRect *) 0 ;
5392 wxPoint *arg2 = 0 ;
5393 wxPoint temp2 ;
5394 PyObject * obj0 = 0 ;
5395 PyObject * obj1 = 0 ;
5396 char *kwnames[] = {
5397 (char *) "self",(char *) "p", NULL
5398 };
5399
5400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5402 if (SWIG_arg_fail(1)) SWIG_fail;
5403 {
5404 arg2 = &temp2;
5405 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5406 }
5407 {
5408 PyThreadState* __tstate = wxPyBeginAllowThreads();
5409 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5410
5411 wxPyEndAllowThreads(__tstate);
5412 if (PyErr_Occurred()) SWIG_fail;
5413 }
5414 Py_INCREF(Py_None); resultobj = Py_None;
5415 return resultobj;
5416 fail:
5417 return NULL;
5418 }
5419
5420
5421 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5422 PyObject *resultobj;
5423 wxRect *arg1 = (wxRect *) 0 ;
5424 int result;
5425 PyObject * obj0 = 0 ;
5426 char *kwnames[] = {
5427 (char *) "self", NULL
5428 };
5429
5430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5432 if (SWIG_arg_fail(1)) SWIG_fail;
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = (int)((wxRect const *)arg1)->GetLeft();
5436
5437 wxPyEndAllowThreads(__tstate);
5438 if (PyErr_Occurred()) SWIG_fail;
5439 }
5440 {
5441 resultobj = SWIG_From_int((int)(result));
5442 }
5443 return resultobj;
5444 fail:
5445 return NULL;
5446 }
5447
5448
5449 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5450 PyObject *resultobj;
5451 wxRect *arg1 = (wxRect *) 0 ;
5452 int result;
5453 PyObject * obj0 = 0 ;
5454 char *kwnames[] = {
5455 (char *) "self", NULL
5456 };
5457
5458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5460 if (SWIG_arg_fail(1)) SWIG_fail;
5461 {
5462 PyThreadState* __tstate = wxPyBeginAllowThreads();
5463 result = (int)((wxRect const *)arg1)->GetTop();
5464
5465 wxPyEndAllowThreads(__tstate);
5466 if (PyErr_Occurred()) SWIG_fail;
5467 }
5468 {
5469 resultobj = SWIG_From_int((int)(result));
5470 }
5471 return resultobj;
5472 fail:
5473 return NULL;
5474 }
5475
5476
5477 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5478 PyObject *resultobj;
5479 wxRect *arg1 = (wxRect *) 0 ;
5480 int result;
5481 PyObject * obj0 = 0 ;
5482 char *kwnames[] = {
5483 (char *) "self", NULL
5484 };
5485
5486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5488 if (SWIG_arg_fail(1)) SWIG_fail;
5489 {
5490 PyThreadState* __tstate = wxPyBeginAllowThreads();
5491 result = (int)((wxRect const *)arg1)->GetBottom();
5492
5493 wxPyEndAllowThreads(__tstate);
5494 if (PyErr_Occurred()) SWIG_fail;
5495 }
5496 {
5497 resultobj = SWIG_From_int((int)(result));
5498 }
5499 return resultobj;
5500 fail:
5501 return NULL;
5502 }
5503
5504
5505 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5506 PyObject *resultobj;
5507 wxRect *arg1 = (wxRect *) 0 ;
5508 int result;
5509 PyObject * obj0 = 0 ;
5510 char *kwnames[] = {
5511 (char *) "self", NULL
5512 };
5513
5514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5516 if (SWIG_arg_fail(1)) SWIG_fail;
5517 {
5518 PyThreadState* __tstate = wxPyBeginAllowThreads();
5519 result = (int)((wxRect const *)arg1)->GetRight();
5520
5521 wxPyEndAllowThreads(__tstate);
5522 if (PyErr_Occurred()) SWIG_fail;
5523 }
5524 {
5525 resultobj = SWIG_From_int((int)(result));
5526 }
5527 return resultobj;
5528 fail:
5529 return NULL;
5530 }
5531
5532
5533 static PyObject *_wrap_Rect_SetLeft(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 *) "left", NULL
5541 };
5542
5543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",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)->SetLeft(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_SetRight(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 *) "right", NULL
5572 };
5573
5574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",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)->SetRight(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_SetTop(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 *) "top", NULL
5603 };
5604
5605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",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)->SetTop(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_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5627 PyObject *resultobj;
5628 wxRect *arg1 = (wxRect *) 0 ;
5629 int arg2 ;
5630 PyObject * obj0 = 0 ;
5631 PyObject * obj1 = 0 ;
5632 char *kwnames[] = {
5633 (char *) "self",(char *) "bottom", NULL
5634 };
5635
5636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5638 if (SWIG_arg_fail(1)) SWIG_fail;
5639 {
5640 arg2 = (int)(SWIG_As_int(obj1));
5641 if (SWIG_arg_fail(2)) SWIG_fail;
5642 }
5643 {
5644 PyThreadState* __tstate = wxPyBeginAllowThreads();
5645 (arg1)->SetBottom(arg2);
5646
5647 wxPyEndAllowThreads(__tstate);
5648 if (PyErr_Occurred()) SWIG_fail;
5649 }
5650 Py_INCREF(Py_None); resultobj = Py_None;
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5658 PyObject *resultobj;
5659 wxRect *arg1 = (wxRect *) 0 ;
5660 int arg2 ;
5661 int arg3 ;
5662 wxRect *result;
5663 PyObject * obj0 = 0 ;
5664 PyObject * obj1 = 0 ;
5665 PyObject * obj2 = 0 ;
5666 char *kwnames[] = {
5667 (char *) "self",(char *) "dx",(char *) "dy", NULL
5668 };
5669
5670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5672 if (SWIG_arg_fail(1)) SWIG_fail;
5673 {
5674 arg2 = (int)(SWIG_As_int(obj1));
5675 if (SWIG_arg_fail(2)) SWIG_fail;
5676 }
5677 {
5678 arg3 = (int)(SWIG_As_int(obj2));
5679 if (SWIG_arg_fail(3)) SWIG_fail;
5680 }
5681 {
5682 PyThreadState* __tstate = wxPyBeginAllowThreads();
5683 {
5684 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5685 result = (wxRect *) &_result_ref;
5686 }
5687
5688 wxPyEndAllowThreads(__tstate);
5689 if (PyErr_Occurred()) SWIG_fail;
5690 }
5691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5692 return resultobj;
5693 fail:
5694 return NULL;
5695 }
5696
5697
5698 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5699 PyObject *resultobj;
5700 wxRect *arg1 = (wxRect *) 0 ;
5701 int arg2 ;
5702 int arg3 ;
5703 wxRect *result;
5704 PyObject * obj0 = 0 ;
5705 PyObject * obj1 = 0 ;
5706 PyObject * obj2 = 0 ;
5707 char *kwnames[] = {
5708 (char *) "self",(char *) "dx",(char *) "dy", NULL
5709 };
5710
5711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5713 if (SWIG_arg_fail(1)) SWIG_fail;
5714 {
5715 arg2 = (int)(SWIG_As_int(obj1));
5716 if (SWIG_arg_fail(2)) SWIG_fail;
5717 }
5718 {
5719 arg3 = (int)(SWIG_As_int(obj2));
5720 if (SWIG_arg_fail(3)) SWIG_fail;
5721 }
5722 {
5723 PyThreadState* __tstate = wxPyBeginAllowThreads();
5724 {
5725 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5726 result = (wxRect *) &_result_ref;
5727 }
5728
5729 wxPyEndAllowThreads(__tstate);
5730 if (PyErr_Occurred()) SWIG_fail;
5731 }
5732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5733 return resultobj;
5734 fail:
5735 return NULL;
5736 }
5737
5738
5739 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5740 PyObject *resultobj;
5741 wxRect *arg1 = (wxRect *) 0 ;
5742 int arg2 ;
5743 int arg3 ;
5744 PyObject * obj0 = 0 ;
5745 PyObject * obj1 = 0 ;
5746 PyObject * obj2 = 0 ;
5747 char *kwnames[] = {
5748 (char *) "self",(char *) "dx",(char *) "dy", NULL
5749 };
5750
5751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5753 if (SWIG_arg_fail(1)) SWIG_fail;
5754 {
5755 arg2 = (int)(SWIG_As_int(obj1));
5756 if (SWIG_arg_fail(2)) SWIG_fail;
5757 }
5758 {
5759 arg3 = (int)(SWIG_As_int(obj2));
5760 if (SWIG_arg_fail(3)) SWIG_fail;
5761 }
5762 {
5763 PyThreadState* __tstate = wxPyBeginAllowThreads();
5764 (arg1)->Offset(arg2,arg3);
5765
5766 wxPyEndAllowThreads(__tstate);
5767 if (PyErr_Occurred()) SWIG_fail;
5768 }
5769 Py_INCREF(Py_None); resultobj = Py_None;
5770 return resultobj;
5771 fail:
5772 return NULL;
5773 }
5774
5775
5776 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj;
5778 wxRect *arg1 = (wxRect *) 0 ;
5779 wxPoint *arg2 = 0 ;
5780 wxPoint temp2 ;
5781 PyObject * obj0 = 0 ;
5782 PyObject * obj1 = 0 ;
5783 char *kwnames[] = {
5784 (char *) "self",(char *) "pt", NULL
5785 };
5786
5787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5789 if (SWIG_arg_fail(1)) SWIG_fail;
5790 {
5791 arg2 = &temp2;
5792 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5793 }
5794 {
5795 PyThreadState* __tstate = wxPyBeginAllowThreads();
5796 (arg1)->Offset((wxPoint const &)*arg2);
5797
5798 wxPyEndAllowThreads(__tstate);
5799 if (PyErr_Occurred()) SWIG_fail;
5800 }
5801 Py_INCREF(Py_None); resultobj = Py_None;
5802 return resultobj;
5803 fail:
5804 return NULL;
5805 }
5806
5807
5808 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5809 PyObject *resultobj;
5810 wxRect *arg1 = (wxRect *) 0 ;
5811 wxRect *arg2 = 0 ;
5812 wxRect result;
5813 wxRect temp2 ;
5814 PyObject * obj0 = 0 ;
5815 PyObject * obj1 = 0 ;
5816 char *kwnames[] = {
5817 (char *) "self",(char *) "rect", NULL
5818 };
5819
5820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5822 if (SWIG_arg_fail(1)) SWIG_fail;
5823 {
5824 arg2 = &temp2;
5825 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5826 }
5827 {
5828 PyThreadState* __tstate = wxPyBeginAllowThreads();
5829 result = (arg1)->Intersect((wxRect const &)*arg2);
5830
5831 wxPyEndAllowThreads(__tstate);
5832 if (PyErr_Occurred()) SWIG_fail;
5833 }
5834 {
5835 wxRect * resultptr;
5836 resultptr = new wxRect((wxRect &)(result));
5837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5838 }
5839 return resultobj;
5840 fail:
5841 return NULL;
5842 }
5843
5844
5845 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj;
5847 wxRect *arg1 = (wxRect *) 0 ;
5848 wxRect *arg2 = 0 ;
5849 wxRect result;
5850 wxRect temp2 ;
5851 PyObject * obj0 = 0 ;
5852 PyObject * obj1 = 0 ;
5853 char *kwnames[] = {
5854 (char *) "self",(char *) "rect", NULL
5855 };
5856
5857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5859 if (SWIG_arg_fail(1)) SWIG_fail;
5860 {
5861 arg2 = &temp2;
5862 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5863 }
5864 {
5865 PyThreadState* __tstate = wxPyBeginAllowThreads();
5866 result = (arg1)->Union((wxRect const &)*arg2);
5867
5868 wxPyEndAllowThreads(__tstate);
5869 if (PyErr_Occurred()) SWIG_fail;
5870 }
5871 {
5872 wxRect * resultptr;
5873 resultptr = new wxRect((wxRect &)(result));
5874 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5875 }
5876 return resultobj;
5877 fail:
5878 return NULL;
5879 }
5880
5881
5882 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5883 PyObject *resultobj;
5884 wxRect *arg1 = (wxRect *) 0 ;
5885 wxRect *arg2 = 0 ;
5886 wxRect result;
5887 wxRect temp2 ;
5888 PyObject * obj0 = 0 ;
5889 PyObject * obj1 = 0 ;
5890 char *kwnames[] = {
5891 (char *) "self",(char *) "rect", NULL
5892 };
5893
5894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5896 if (SWIG_arg_fail(1)) SWIG_fail;
5897 {
5898 arg2 = &temp2;
5899 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5900 }
5901 {
5902 PyThreadState* __tstate = wxPyBeginAllowThreads();
5903 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5904
5905 wxPyEndAllowThreads(__tstate);
5906 if (PyErr_Occurred()) SWIG_fail;
5907 }
5908 {
5909 wxRect * resultptr;
5910 resultptr = new wxRect((wxRect &)(result));
5911 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5912 }
5913 return resultobj;
5914 fail:
5915 return NULL;
5916 }
5917
5918
5919 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5920 PyObject *resultobj;
5921 wxRect *arg1 = (wxRect *) 0 ;
5922 wxRect *arg2 = 0 ;
5923 wxRect *result;
5924 wxRect temp2 ;
5925 PyObject * obj0 = 0 ;
5926 PyObject * obj1 = 0 ;
5927 char *kwnames[] = {
5928 (char *) "self",(char *) "rect", NULL
5929 };
5930
5931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5933 if (SWIG_arg_fail(1)) SWIG_fail;
5934 {
5935 arg2 = &temp2;
5936 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5937 }
5938 {
5939 PyThreadState* __tstate = wxPyBeginAllowThreads();
5940 {
5941 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5942 result = (wxRect *) &_result_ref;
5943 }
5944
5945 wxPyEndAllowThreads(__tstate);
5946 if (PyErr_Occurred()) SWIG_fail;
5947 }
5948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5949 return resultobj;
5950 fail:
5951 return NULL;
5952 }
5953
5954
5955 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5956 PyObject *resultobj;
5957 wxRect *arg1 = (wxRect *) 0 ;
5958 wxRect *arg2 = 0 ;
5959 bool result;
5960 wxRect temp2 ;
5961 PyObject * obj0 = 0 ;
5962 PyObject * obj1 = 0 ;
5963 char *kwnames[] = {
5964 (char *) "self",(char *) "rect", NULL
5965 };
5966
5967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5969 if (SWIG_arg_fail(1)) SWIG_fail;
5970 {
5971 arg2 = &temp2;
5972 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5973 }
5974 {
5975 PyThreadState* __tstate = wxPyBeginAllowThreads();
5976 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5977
5978 wxPyEndAllowThreads(__tstate);
5979 if (PyErr_Occurred()) SWIG_fail;
5980 }
5981 {
5982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5983 }
5984 return resultobj;
5985 fail:
5986 return NULL;
5987 }
5988
5989
5990 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5991 PyObject *resultobj;
5992 wxRect *arg1 = (wxRect *) 0 ;
5993 wxRect *arg2 = 0 ;
5994 bool result;
5995 wxRect temp2 ;
5996 PyObject * obj0 = 0 ;
5997 PyObject * obj1 = 0 ;
5998 char *kwnames[] = {
5999 (char *) "self",(char *) "rect", NULL
6000 };
6001
6002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6004 if (SWIG_arg_fail(1)) SWIG_fail;
6005 {
6006 arg2 = &temp2;
6007 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6008 }
6009 {
6010 PyThreadState* __tstate = wxPyBeginAllowThreads();
6011 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6012
6013 wxPyEndAllowThreads(__tstate);
6014 if (PyErr_Occurred()) SWIG_fail;
6015 }
6016 {
6017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6018 }
6019 return resultobj;
6020 fail:
6021 return NULL;
6022 }
6023
6024
6025 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6026 PyObject *resultobj;
6027 wxRect *arg1 = (wxRect *) 0 ;
6028 int arg2 ;
6029 int arg3 ;
6030 bool result;
6031 PyObject * obj0 = 0 ;
6032 PyObject * obj1 = 0 ;
6033 PyObject * obj2 = 0 ;
6034 char *kwnames[] = {
6035 (char *) "self",(char *) "x",(char *) "y", NULL
6036 };
6037
6038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6040 if (SWIG_arg_fail(1)) SWIG_fail;
6041 {
6042 arg2 = (int)(SWIG_As_int(obj1));
6043 if (SWIG_arg_fail(2)) SWIG_fail;
6044 }
6045 {
6046 arg3 = (int)(SWIG_As_int(obj2));
6047 if (SWIG_arg_fail(3)) SWIG_fail;
6048 }
6049 {
6050 PyThreadState* __tstate = wxPyBeginAllowThreads();
6051 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6052
6053 wxPyEndAllowThreads(__tstate);
6054 if (PyErr_Occurred()) SWIG_fail;
6055 }
6056 {
6057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6058 }
6059 return resultobj;
6060 fail:
6061 return NULL;
6062 }
6063
6064
6065 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6066 PyObject *resultobj;
6067 wxRect *arg1 = (wxRect *) 0 ;
6068 wxPoint *arg2 = 0 ;
6069 bool result;
6070 wxPoint temp2 ;
6071 PyObject * obj0 = 0 ;
6072 PyObject * obj1 = 0 ;
6073 char *kwnames[] = {
6074 (char *) "self",(char *) "pt", NULL
6075 };
6076
6077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6079 if (SWIG_arg_fail(1)) SWIG_fail;
6080 {
6081 arg2 = &temp2;
6082 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6083 }
6084 {
6085 PyThreadState* __tstate = wxPyBeginAllowThreads();
6086 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6087
6088 wxPyEndAllowThreads(__tstate);
6089 if (PyErr_Occurred()) SWIG_fail;
6090 }
6091 {
6092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6093 }
6094 return resultobj;
6095 fail:
6096 return NULL;
6097 }
6098
6099
6100 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6101 PyObject *resultobj;
6102 wxRect *arg1 = (wxRect *) 0 ;
6103 wxRect *arg2 = 0 ;
6104 bool result;
6105 wxRect temp2 ;
6106 PyObject * obj0 = 0 ;
6107 PyObject * obj1 = 0 ;
6108 char *kwnames[] = {
6109 (char *) "self",(char *) "rect", NULL
6110 };
6111
6112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6114 if (SWIG_arg_fail(1)) SWIG_fail;
6115 {
6116 arg2 = &temp2;
6117 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6118 }
6119 {
6120 PyThreadState* __tstate = wxPyBeginAllowThreads();
6121 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6122
6123 wxPyEndAllowThreads(__tstate);
6124 if (PyErr_Occurred()) SWIG_fail;
6125 }
6126 {
6127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6128 }
6129 return resultobj;
6130 fail:
6131 return NULL;
6132 }
6133
6134
6135 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6136 PyObject *resultobj;
6137 wxRect *arg1 = (wxRect *) 0 ;
6138 int arg2 ;
6139 PyObject * obj0 = 0 ;
6140 PyObject * obj1 = 0 ;
6141 char *kwnames[] = {
6142 (char *) "self",(char *) "x", NULL
6143 };
6144
6145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6147 if (SWIG_arg_fail(1)) SWIG_fail;
6148 {
6149 arg2 = (int)(SWIG_As_int(obj1));
6150 if (SWIG_arg_fail(2)) SWIG_fail;
6151 }
6152 if (arg1) (arg1)->x = arg2;
6153
6154 Py_INCREF(Py_None); resultobj = Py_None;
6155 return resultobj;
6156 fail:
6157 return NULL;
6158 }
6159
6160
6161 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6162 PyObject *resultobj;
6163 wxRect *arg1 = (wxRect *) 0 ;
6164 int result;
6165 PyObject * obj0 = 0 ;
6166 char *kwnames[] = {
6167 (char *) "self", NULL
6168 };
6169
6170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6172 if (SWIG_arg_fail(1)) SWIG_fail;
6173 result = (int) ((arg1)->x);
6174
6175 {
6176 resultobj = SWIG_From_int((int)(result));
6177 }
6178 return resultobj;
6179 fail:
6180 return NULL;
6181 }
6182
6183
6184 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6185 PyObject *resultobj;
6186 wxRect *arg1 = (wxRect *) 0 ;
6187 int arg2 ;
6188 PyObject * obj0 = 0 ;
6189 PyObject * obj1 = 0 ;
6190 char *kwnames[] = {
6191 (char *) "self",(char *) "y", NULL
6192 };
6193
6194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6196 if (SWIG_arg_fail(1)) SWIG_fail;
6197 {
6198 arg2 = (int)(SWIG_As_int(obj1));
6199 if (SWIG_arg_fail(2)) SWIG_fail;
6200 }
6201 if (arg1) (arg1)->y = arg2;
6202
6203 Py_INCREF(Py_None); resultobj = Py_None;
6204 return resultobj;
6205 fail:
6206 return NULL;
6207 }
6208
6209
6210 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6211 PyObject *resultobj;
6212 wxRect *arg1 = (wxRect *) 0 ;
6213 int result;
6214 PyObject * obj0 = 0 ;
6215 char *kwnames[] = {
6216 (char *) "self", NULL
6217 };
6218
6219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6221 if (SWIG_arg_fail(1)) SWIG_fail;
6222 result = (int) ((arg1)->y);
6223
6224 {
6225 resultobj = SWIG_From_int((int)(result));
6226 }
6227 return resultobj;
6228 fail:
6229 return NULL;
6230 }
6231
6232
6233 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6234 PyObject *resultobj;
6235 wxRect *arg1 = (wxRect *) 0 ;
6236 int arg2 ;
6237 PyObject * obj0 = 0 ;
6238 PyObject * obj1 = 0 ;
6239 char *kwnames[] = {
6240 (char *) "self",(char *) "width", NULL
6241 };
6242
6243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6245 if (SWIG_arg_fail(1)) SWIG_fail;
6246 {
6247 arg2 = (int)(SWIG_As_int(obj1));
6248 if (SWIG_arg_fail(2)) SWIG_fail;
6249 }
6250 if (arg1) (arg1)->width = arg2;
6251
6252 Py_INCREF(Py_None); resultobj = Py_None;
6253 return resultobj;
6254 fail:
6255 return NULL;
6256 }
6257
6258
6259 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6260 PyObject *resultobj;
6261 wxRect *arg1 = (wxRect *) 0 ;
6262 int result;
6263 PyObject * obj0 = 0 ;
6264 char *kwnames[] = {
6265 (char *) "self", NULL
6266 };
6267
6268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6270 if (SWIG_arg_fail(1)) SWIG_fail;
6271 result = (int) ((arg1)->width);
6272
6273 {
6274 resultobj = SWIG_From_int((int)(result));
6275 }
6276 return resultobj;
6277 fail:
6278 return NULL;
6279 }
6280
6281
6282 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6283 PyObject *resultobj;
6284 wxRect *arg1 = (wxRect *) 0 ;
6285 int arg2 ;
6286 PyObject * obj0 = 0 ;
6287 PyObject * obj1 = 0 ;
6288 char *kwnames[] = {
6289 (char *) "self",(char *) "height", NULL
6290 };
6291
6292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6294 if (SWIG_arg_fail(1)) SWIG_fail;
6295 {
6296 arg2 = (int)(SWIG_As_int(obj1));
6297 if (SWIG_arg_fail(2)) SWIG_fail;
6298 }
6299 if (arg1) (arg1)->height = arg2;
6300
6301 Py_INCREF(Py_None); resultobj = Py_None;
6302 return resultobj;
6303 fail:
6304 return NULL;
6305 }
6306
6307
6308 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6309 PyObject *resultobj;
6310 wxRect *arg1 = (wxRect *) 0 ;
6311 int result;
6312 PyObject * obj0 = 0 ;
6313 char *kwnames[] = {
6314 (char *) "self", NULL
6315 };
6316
6317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6319 if (SWIG_arg_fail(1)) SWIG_fail;
6320 result = (int) ((arg1)->height);
6321
6322 {
6323 resultobj = SWIG_From_int((int)(result));
6324 }
6325 return resultobj;
6326 fail:
6327 return NULL;
6328 }
6329
6330
6331 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6332 PyObject *resultobj;
6333 wxRect *arg1 = (wxRect *) 0 ;
6334 int arg2 = (int) 0 ;
6335 int arg3 = (int) 0 ;
6336 int arg4 = (int) 0 ;
6337 int arg5 = (int) 0 ;
6338 PyObject * obj0 = 0 ;
6339 PyObject * obj1 = 0 ;
6340 PyObject * obj2 = 0 ;
6341 PyObject * obj3 = 0 ;
6342 PyObject * obj4 = 0 ;
6343 char *kwnames[] = {
6344 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6345 };
6346
6347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6349 if (SWIG_arg_fail(1)) SWIG_fail;
6350 if (obj1) {
6351 {
6352 arg2 = (int)(SWIG_As_int(obj1));
6353 if (SWIG_arg_fail(2)) SWIG_fail;
6354 }
6355 }
6356 if (obj2) {
6357 {
6358 arg3 = (int)(SWIG_As_int(obj2));
6359 if (SWIG_arg_fail(3)) SWIG_fail;
6360 }
6361 }
6362 if (obj3) {
6363 {
6364 arg4 = (int)(SWIG_As_int(obj3));
6365 if (SWIG_arg_fail(4)) SWIG_fail;
6366 }
6367 }
6368 if (obj4) {
6369 {
6370 arg5 = (int)(SWIG_As_int(obj4));
6371 if (SWIG_arg_fail(5)) SWIG_fail;
6372 }
6373 }
6374 {
6375 PyThreadState* __tstate = wxPyBeginAllowThreads();
6376 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6377
6378 wxPyEndAllowThreads(__tstate);
6379 if (PyErr_Occurred()) SWIG_fail;
6380 }
6381 Py_INCREF(Py_None); resultobj = Py_None;
6382 return resultobj;
6383 fail:
6384 return NULL;
6385 }
6386
6387
6388 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6389 PyObject *resultobj;
6390 wxRect *arg1 = (wxRect *) 0 ;
6391 PyObject *result;
6392 PyObject * obj0 = 0 ;
6393 char *kwnames[] = {
6394 (char *) "self", NULL
6395 };
6396
6397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6399 if (SWIG_arg_fail(1)) SWIG_fail;
6400 {
6401 PyThreadState* __tstate = wxPyBeginAllowThreads();
6402 result = (PyObject *)wxRect_Get(arg1);
6403
6404 wxPyEndAllowThreads(__tstate);
6405 if (PyErr_Occurred()) SWIG_fail;
6406 }
6407 resultobj = result;
6408 return resultobj;
6409 fail:
6410 return NULL;
6411 }
6412
6413
6414 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6415 PyObject *obj;
6416 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6417 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6418 Py_INCREF(obj);
6419 return Py_BuildValue((char *)"");
6420 }
6421 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6422 PyObject *resultobj;
6423 wxRect *arg1 = (wxRect *) 0 ;
6424 wxRect *arg2 = (wxRect *) 0 ;
6425 PyObject *result;
6426 PyObject * obj0 = 0 ;
6427 PyObject * obj1 = 0 ;
6428 char *kwnames[] = {
6429 (char *) "r1",(char *) "r2", NULL
6430 };
6431
6432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6434 if (SWIG_arg_fail(1)) SWIG_fail;
6435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6436 if (SWIG_arg_fail(2)) SWIG_fail;
6437 {
6438 if (!wxPyCheckForApp()) SWIG_fail;
6439 PyThreadState* __tstate = wxPyBeginAllowThreads();
6440 result = (PyObject *)wxIntersectRect(arg1,arg2);
6441
6442 wxPyEndAllowThreads(__tstate);
6443 if (PyErr_Occurred()) SWIG_fail;
6444 }
6445 resultobj = result;
6446 return resultobj;
6447 fail:
6448 return NULL;
6449 }
6450
6451
6452 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6453 PyObject *resultobj;
6454 double arg1 = (double) 0.0 ;
6455 double arg2 = (double) 0.0 ;
6456 wxPoint2D *result;
6457 PyObject * obj0 = 0 ;
6458 PyObject * obj1 = 0 ;
6459 char *kwnames[] = {
6460 (char *) "x",(char *) "y", NULL
6461 };
6462
6463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6464 if (obj0) {
6465 {
6466 arg1 = (double)(SWIG_As_double(obj0));
6467 if (SWIG_arg_fail(1)) SWIG_fail;
6468 }
6469 }
6470 if (obj1) {
6471 {
6472 arg2 = (double)(SWIG_As_double(obj1));
6473 if (SWIG_arg_fail(2)) SWIG_fail;
6474 }
6475 }
6476 {
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6479
6480 wxPyEndAllowThreads(__tstate);
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6491 PyObject *resultobj;
6492 wxPoint2D *arg1 = 0 ;
6493 wxPoint2D *result;
6494 wxPoint2D temp1 ;
6495 PyObject * obj0 = 0 ;
6496 char *kwnames[] = {
6497 (char *) "pt", NULL
6498 };
6499
6500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6501 {
6502 arg1 = &temp1;
6503 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6504 }
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6508
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6513 return resultobj;
6514 fail:
6515 return NULL;
6516 }
6517
6518
6519 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6520 PyObject *resultobj;
6521 wxPoint *arg1 = 0 ;
6522 wxPoint2D *result;
6523 wxPoint temp1 ;
6524 PyObject * obj0 = 0 ;
6525 char *kwnames[] = {
6526 (char *) "pt", NULL
6527 };
6528
6529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6530 {
6531 arg1 = &temp1;
6532 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6533 }
6534 {
6535 PyThreadState* __tstate = wxPyBeginAllowThreads();
6536 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6537
6538 wxPyEndAllowThreads(__tstate);
6539 if (PyErr_Occurred()) SWIG_fail;
6540 }
6541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6542 return resultobj;
6543 fail:
6544 return NULL;
6545 }
6546
6547
6548 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6549 PyObject *resultobj;
6550 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6551 int *arg2 = (int *) 0 ;
6552 int *arg3 = (int *) 0 ;
6553 int temp2 ;
6554 int res2 = 0 ;
6555 int temp3 ;
6556 int res3 = 0 ;
6557 PyObject * obj0 = 0 ;
6558 char *kwnames[] = {
6559 (char *) "self", NULL
6560 };
6561
6562 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6563 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6566 if (SWIG_arg_fail(1)) SWIG_fail;
6567 {
6568 PyThreadState* __tstate = wxPyBeginAllowThreads();
6569 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6570
6571 wxPyEndAllowThreads(__tstate);
6572 if (PyErr_Occurred()) SWIG_fail;
6573 }
6574 Py_INCREF(Py_None); resultobj = Py_None;
6575 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6576 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6577 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6578 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6579 return resultobj;
6580 fail:
6581 return NULL;
6582 }
6583
6584
6585 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6586 PyObject *resultobj;
6587 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6588 int *arg2 = (int *) 0 ;
6589 int *arg3 = (int *) 0 ;
6590 int temp2 ;
6591 int res2 = 0 ;
6592 int temp3 ;
6593 int res3 = 0 ;
6594 PyObject * obj0 = 0 ;
6595 char *kwnames[] = {
6596 (char *) "self", NULL
6597 };
6598
6599 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6600 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6603 if (SWIG_arg_fail(1)) SWIG_fail;
6604 {
6605 PyThreadState* __tstate = wxPyBeginAllowThreads();
6606 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6607
6608 wxPyEndAllowThreads(__tstate);
6609 if (PyErr_Occurred()) SWIG_fail;
6610 }
6611 Py_INCREF(Py_None); resultobj = Py_None;
6612 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6613 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6614 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6615 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6616 return resultobj;
6617 fail:
6618 return NULL;
6619 }
6620
6621
6622 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6623 PyObject *resultobj;
6624 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6625 double result;
6626 PyObject * obj0 = 0 ;
6627 char *kwnames[] = {
6628 (char *) "self", NULL
6629 };
6630
6631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6633 if (SWIG_arg_fail(1)) SWIG_fail;
6634 {
6635 PyThreadState* __tstate = wxPyBeginAllowThreads();
6636 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6637
6638 wxPyEndAllowThreads(__tstate);
6639 if (PyErr_Occurred()) SWIG_fail;
6640 }
6641 {
6642 resultobj = SWIG_From_double((double)(result));
6643 }
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6651 PyObject *resultobj;
6652 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6653 double result;
6654 PyObject * obj0 = 0 ;
6655 char *kwnames[] = {
6656 (char *) "self", NULL
6657 };
6658
6659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6661 if (SWIG_arg_fail(1)) SWIG_fail;
6662 {
6663 PyThreadState* __tstate = wxPyBeginAllowThreads();
6664 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6665
6666 wxPyEndAllowThreads(__tstate);
6667 if (PyErr_Occurred()) SWIG_fail;
6668 }
6669 {
6670 resultobj = SWIG_From_double((double)(result));
6671 }
6672 return resultobj;
6673 fail:
6674 return NULL;
6675 }
6676
6677
6678 static PyObject *_wrap_Point2D_SetVectorLength(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 *) "length", NULL
6686 };
6687
6688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",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)->SetVectorLength(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_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6710 PyObject *resultobj;
6711 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6712 double arg2 ;
6713 PyObject * obj0 = 0 ;
6714 PyObject * obj1 = 0 ;
6715 char *kwnames[] = {
6716 (char *) "self",(char *) "degrees", NULL
6717 };
6718
6719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6721 if (SWIG_arg_fail(1)) SWIG_fail;
6722 {
6723 arg2 = (double)(SWIG_As_double(obj1));
6724 if (SWIG_arg_fail(2)) SWIG_fail;
6725 }
6726 {
6727 PyThreadState* __tstate = wxPyBeginAllowThreads();
6728 (arg1)->SetVectorAngle(arg2);
6729
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 Py_INCREF(Py_None); resultobj = Py_None;
6734 return resultobj;
6735 fail:
6736 return NULL;
6737 }
6738
6739
6740 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6741 PyObject *resultobj;
6742 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6743 wxPoint2D *arg2 = 0 ;
6744 double result;
6745 wxPoint2D temp2 ;
6746 PyObject * obj0 = 0 ;
6747 PyObject * obj1 = 0 ;
6748 char *kwnames[] = {
6749 (char *) "self",(char *) "pt", NULL
6750 };
6751
6752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6754 if (SWIG_arg_fail(1)) SWIG_fail;
6755 {
6756 arg2 = &temp2;
6757 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6758 }
6759 {
6760 PyThreadState* __tstate = wxPyBeginAllowThreads();
6761 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6762
6763 wxPyEndAllowThreads(__tstate);
6764 if (PyErr_Occurred()) SWIG_fail;
6765 }
6766 {
6767 resultobj = SWIG_From_double((double)(result));
6768 }
6769 return resultobj;
6770 fail:
6771 return NULL;
6772 }
6773
6774
6775 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6776 PyObject *resultobj;
6777 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6778 wxPoint2D *arg2 = 0 ;
6779 double result;
6780 wxPoint2D temp2 ;
6781 PyObject * obj0 = 0 ;
6782 PyObject * obj1 = 0 ;
6783 char *kwnames[] = {
6784 (char *) "self",(char *) "pt", NULL
6785 };
6786
6787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6789 if (SWIG_arg_fail(1)) SWIG_fail;
6790 {
6791 arg2 = &temp2;
6792 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6793 }
6794 {
6795 PyThreadState* __tstate = wxPyBeginAllowThreads();
6796 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6797
6798 wxPyEndAllowThreads(__tstate);
6799 if (PyErr_Occurred()) SWIG_fail;
6800 }
6801 {
6802 resultobj = SWIG_From_double((double)(result));
6803 }
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6811 PyObject *resultobj;
6812 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6813 wxPoint2D *arg2 = 0 ;
6814 double result;
6815 wxPoint2D temp2 ;
6816 PyObject * obj0 = 0 ;
6817 PyObject * obj1 = 0 ;
6818 char *kwnames[] = {
6819 (char *) "self",(char *) "vec", NULL
6820 };
6821
6822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6824 if (SWIG_arg_fail(1)) SWIG_fail;
6825 {
6826 arg2 = &temp2;
6827 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6828 }
6829 {
6830 PyThreadState* __tstate = wxPyBeginAllowThreads();
6831 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6832
6833 wxPyEndAllowThreads(__tstate);
6834 if (PyErr_Occurred()) SWIG_fail;
6835 }
6836 {
6837 resultobj = SWIG_From_double((double)(result));
6838 }
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6846 PyObject *resultobj;
6847 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6848 wxPoint2D *arg2 = 0 ;
6849 double result;
6850 wxPoint2D temp2 ;
6851 PyObject * obj0 = 0 ;
6852 PyObject * obj1 = 0 ;
6853 char *kwnames[] = {
6854 (char *) "self",(char *) "vec", NULL
6855 };
6856
6857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6859 if (SWIG_arg_fail(1)) SWIG_fail;
6860 {
6861 arg2 = &temp2;
6862 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6863 }
6864 {
6865 PyThreadState* __tstate = wxPyBeginAllowThreads();
6866 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6867
6868 wxPyEndAllowThreads(__tstate);
6869 if (PyErr_Occurred()) SWIG_fail;
6870 }
6871 {
6872 resultobj = SWIG_From_double((double)(result));
6873 }
6874 return resultobj;
6875 fail:
6876 return NULL;
6877 }
6878
6879
6880 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6881 PyObject *resultobj;
6882 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6883 wxPoint2D result;
6884 PyObject * obj0 = 0 ;
6885 char *kwnames[] = {
6886 (char *) "self", NULL
6887 };
6888
6889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6891 if (SWIG_arg_fail(1)) SWIG_fail;
6892 {
6893 PyThreadState* __tstate = wxPyBeginAllowThreads();
6894 result = (arg1)->operator -();
6895
6896 wxPyEndAllowThreads(__tstate);
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 {
6900 wxPoint2D * resultptr;
6901 resultptr = new wxPoint2D((wxPoint2D &)(result));
6902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6903 }
6904 return resultobj;
6905 fail:
6906 return NULL;
6907 }
6908
6909
6910 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6911 PyObject *resultobj;
6912 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6913 wxPoint2D *arg2 = 0 ;
6914 wxPoint2D *result;
6915 wxPoint2D temp2 ;
6916 PyObject * obj0 = 0 ;
6917 PyObject * obj1 = 0 ;
6918 char *kwnames[] = {
6919 (char *) "self",(char *) "pt", NULL
6920 };
6921
6922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6924 if (SWIG_arg_fail(1)) SWIG_fail;
6925 {
6926 arg2 = &temp2;
6927 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6928 }
6929 {
6930 PyThreadState* __tstate = wxPyBeginAllowThreads();
6931 {
6932 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6933 result = (wxPoint2D *) &_result_ref;
6934 }
6935
6936 wxPyEndAllowThreads(__tstate);
6937 if (PyErr_Occurred()) SWIG_fail;
6938 }
6939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6940 return resultobj;
6941 fail:
6942 return NULL;
6943 }
6944
6945
6946 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6947 PyObject *resultobj;
6948 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6949 wxPoint2D *arg2 = 0 ;
6950 wxPoint2D *result;
6951 wxPoint2D temp2 ;
6952 PyObject * obj0 = 0 ;
6953 PyObject * obj1 = 0 ;
6954 char *kwnames[] = {
6955 (char *) "self",(char *) "pt", NULL
6956 };
6957
6958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6960 if (SWIG_arg_fail(1)) SWIG_fail;
6961 {
6962 arg2 = &temp2;
6963 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6964 }
6965 {
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 {
6968 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6969 result = (wxPoint2D *) &_result_ref;
6970 }
6971
6972 wxPyEndAllowThreads(__tstate);
6973 if (PyErr_Occurred()) SWIG_fail;
6974 }
6975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6976 return resultobj;
6977 fail:
6978 return NULL;
6979 }
6980
6981
6982 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6983 PyObject *resultobj;
6984 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6985 wxPoint2D *arg2 = 0 ;
6986 wxPoint2D *result;
6987 wxPoint2D temp2 ;
6988 PyObject * obj0 = 0 ;
6989 PyObject * obj1 = 0 ;
6990 char *kwnames[] = {
6991 (char *) "self",(char *) "pt", NULL
6992 };
6993
6994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6996 if (SWIG_arg_fail(1)) SWIG_fail;
6997 {
6998 arg2 = &temp2;
6999 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7000 }
7001 {
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 {
7004 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7005 result = (wxPoint2D *) &_result_ref;
7006 }
7007
7008 wxPyEndAllowThreads(__tstate);
7009 if (PyErr_Occurred()) SWIG_fail;
7010 }
7011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7012 return resultobj;
7013 fail:
7014 return NULL;
7015 }
7016
7017
7018 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7019 PyObject *resultobj;
7020 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7021 wxPoint2D *arg2 = 0 ;
7022 wxPoint2D *result;
7023 wxPoint2D temp2 ;
7024 PyObject * obj0 = 0 ;
7025 PyObject * obj1 = 0 ;
7026 char *kwnames[] = {
7027 (char *) "self",(char *) "pt", NULL
7028 };
7029
7030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7032 if (SWIG_arg_fail(1)) SWIG_fail;
7033 {
7034 arg2 = &temp2;
7035 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7036 }
7037 {
7038 PyThreadState* __tstate = wxPyBeginAllowThreads();
7039 {
7040 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7041 result = (wxPoint2D *) &_result_ref;
7042 }
7043
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj;
7056 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7057 wxPoint2D *arg2 = 0 ;
7058 bool result;
7059 wxPoint2D temp2 ;
7060 PyObject * obj0 = 0 ;
7061 PyObject * obj1 = 0 ;
7062 char *kwnames[] = {
7063 (char *) "self",(char *) "pt", NULL
7064 };
7065
7066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7068 if (SWIG_arg_fail(1)) SWIG_fail;
7069 {
7070 arg2 = &temp2;
7071 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7072 }
7073 {
7074 PyThreadState* __tstate = wxPyBeginAllowThreads();
7075 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7076
7077 wxPyEndAllowThreads(__tstate);
7078 if (PyErr_Occurred()) SWIG_fail;
7079 }
7080 {
7081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7082 }
7083 return resultobj;
7084 fail:
7085 return NULL;
7086 }
7087
7088
7089 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7090 PyObject *resultobj;
7091 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7092 wxPoint2D *arg2 = 0 ;
7093 bool result;
7094 wxPoint2D temp2 ;
7095 PyObject * obj0 = 0 ;
7096 PyObject * obj1 = 0 ;
7097 char *kwnames[] = {
7098 (char *) "self",(char *) "pt", NULL
7099 };
7100
7101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7103 if (SWIG_arg_fail(1)) SWIG_fail;
7104 {
7105 arg2 = &temp2;
7106 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7107 }
7108 {
7109 PyThreadState* __tstate = wxPyBeginAllowThreads();
7110 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7111
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 {
7116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7117 }
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7125 PyObject *resultobj;
7126 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7127 double arg2 ;
7128 PyObject * obj0 = 0 ;
7129 PyObject * obj1 = 0 ;
7130 char *kwnames[] = {
7131 (char *) "self",(char *) "m_x", NULL
7132 };
7133
7134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7136 if (SWIG_arg_fail(1)) SWIG_fail;
7137 {
7138 arg2 = (double)(SWIG_As_double(obj1));
7139 if (SWIG_arg_fail(2)) SWIG_fail;
7140 }
7141 if (arg1) (arg1)->m_x = arg2;
7142
7143 Py_INCREF(Py_None); resultobj = Py_None;
7144 return resultobj;
7145 fail:
7146 return NULL;
7147 }
7148
7149
7150 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7151 PyObject *resultobj;
7152 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7153 double result;
7154 PyObject * obj0 = 0 ;
7155 char *kwnames[] = {
7156 (char *) "self", NULL
7157 };
7158
7159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7161 if (SWIG_arg_fail(1)) SWIG_fail;
7162 result = (double) ((arg1)->m_x);
7163
7164 {
7165 resultobj = SWIG_From_double((double)(result));
7166 }
7167 return resultobj;
7168 fail:
7169 return NULL;
7170 }
7171
7172
7173 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7174 PyObject *resultobj;
7175 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7176 double arg2 ;
7177 PyObject * obj0 = 0 ;
7178 PyObject * obj1 = 0 ;
7179 char *kwnames[] = {
7180 (char *) "self",(char *) "m_y", NULL
7181 };
7182
7183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7185 if (SWIG_arg_fail(1)) SWIG_fail;
7186 {
7187 arg2 = (double)(SWIG_As_double(obj1));
7188 if (SWIG_arg_fail(2)) SWIG_fail;
7189 }
7190 if (arg1) (arg1)->m_y = arg2;
7191
7192 Py_INCREF(Py_None); resultobj = Py_None;
7193 return resultobj;
7194 fail:
7195 return NULL;
7196 }
7197
7198
7199 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7200 PyObject *resultobj;
7201 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7202 double result;
7203 PyObject * obj0 = 0 ;
7204 char *kwnames[] = {
7205 (char *) "self", NULL
7206 };
7207
7208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7210 if (SWIG_arg_fail(1)) SWIG_fail;
7211 result = (double) ((arg1)->m_y);
7212
7213 {
7214 resultobj = SWIG_From_double((double)(result));
7215 }
7216 return resultobj;
7217 fail:
7218 return NULL;
7219 }
7220
7221
7222 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7223 PyObject *resultobj;
7224 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7225 double arg2 = (double) 0 ;
7226 double arg3 = (double) 0 ;
7227 PyObject * obj0 = 0 ;
7228 PyObject * obj1 = 0 ;
7229 PyObject * obj2 = 0 ;
7230 char *kwnames[] = {
7231 (char *) "self",(char *) "x",(char *) "y", NULL
7232 };
7233
7234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7236 if (SWIG_arg_fail(1)) SWIG_fail;
7237 if (obj1) {
7238 {
7239 arg2 = (double)(SWIG_As_double(obj1));
7240 if (SWIG_arg_fail(2)) SWIG_fail;
7241 }
7242 }
7243 if (obj2) {
7244 {
7245 arg3 = (double)(SWIG_As_double(obj2));
7246 if (SWIG_arg_fail(3)) SWIG_fail;
7247 }
7248 }
7249 {
7250 PyThreadState* __tstate = wxPyBeginAllowThreads();
7251 wxPoint2D_Set(arg1,arg2,arg3);
7252
7253 wxPyEndAllowThreads(__tstate);
7254 if (PyErr_Occurred()) SWIG_fail;
7255 }
7256 Py_INCREF(Py_None); resultobj = Py_None;
7257 return resultobj;
7258 fail:
7259 return NULL;
7260 }
7261
7262
7263 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7264 PyObject *resultobj;
7265 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7266 PyObject *result;
7267 PyObject * obj0 = 0 ;
7268 char *kwnames[] = {
7269 (char *) "self", NULL
7270 };
7271
7272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7274 if (SWIG_arg_fail(1)) SWIG_fail;
7275 {
7276 PyThreadState* __tstate = wxPyBeginAllowThreads();
7277 result = (PyObject *)wxPoint2D_Get(arg1);
7278
7279 wxPyEndAllowThreads(__tstate);
7280 if (PyErr_Occurred()) SWIG_fail;
7281 }
7282 resultobj = result;
7283 return resultobj;
7284 fail:
7285 return NULL;
7286 }
7287
7288
7289 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7290 PyObject *obj;
7291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7292 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7293 Py_INCREF(obj);
7294 return Py_BuildValue((char *)"");
7295 }
7296 static int _wrap_DefaultPosition_set(PyObject *) {
7297 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7298 return 1;
7299 }
7300
7301
7302 static PyObject *_wrap_DefaultPosition_get(void) {
7303 PyObject *pyobj;
7304
7305 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7306 return pyobj;
7307 }
7308
7309
7310 static int _wrap_DefaultSize_set(PyObject *) {
7311 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7312 return 1;
7313 }
7314
7315
7316 static PyObject *_wrap_DefaultSize_get(void) {
7317 PyObject *pyobj;
7318
7319 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7320 return pyobj;
7321 }
7322
7323
7324 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7325 PyObject *resultobj;
7326 PyObject *arg1 = (PyObject *) 0 ;
7327 wxPyInputStream *result;
7328 PyObject * obj0 = 0 ;
7329 char *kwnames[] = {
7330 (char *) "p", NULL
7331 };
7332
7333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7334 arg1 = obj0;
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7338
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7343 return resultobj;
7344 fail:
7345 return NULL;
7346 }
7347
7348
7349 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7350 PyObject *resultobj;
7351 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7352 PyObject * obj0 = 0 ;
7353 char *kwnames[] = {
7354 (char *) "self", NULL
7355 };
7356
7357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7359 if (SWIG_arg_fail(1)) SWIG_fail;
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 delete arg1;
7363
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 Py_INCREF(Py_None); resultobj = Py_None;
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj;
7376 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7377 PyObject * obj0 = 0 ;
7378 char *kwnames[] = {
7379 (char *) "self", NULL
7380 };
7381
7382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7384 if (SWIG_arg_fail(1)) SWIG_fail;
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 (arg1)->close();
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 Py_INCREF(Py_None); resultobj = Py_None;
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj;
7401 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7402 PyObject * obj0 = 0 ;
7403 char *kwnames[] = {
7404 (char *) "self", NULL
7405 };
7406
7407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7409 if (SWIG_arg_fail(1)) SWIG_fail;
7410 {
7411 PyThreadState* __tstate = wxPyBeginAllowThreads();
7412 (arg1)->flush();
7413
7414 wxPyEndAllowThreads(__tstate);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 Py_INCREF(Py_None); resultobj = Py_None;
7418 return resultobj;
7419 fail:
7420 return NULL;
7421 }
7422
7423
7424 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7425 PyObject *resultobj;
7426 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7427 bool result;
7428 PyObject * obj0 = 0 ;
7429 char *kwnames[] = {
7430 (char *) "self", NULL
7431 };
7432
7433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7435 if (SWIG_arg_fail(1)) SWIG_fail;
7436 {
7437 PyThreadState* __tstate = wxPyBeginAllowThreads();
7438 result = (bool)(arg1)->eof();
7439
7440 wxPyEndAllowThreads(__tstate);
7441 if (PyErr_Occurred()) SWIG_fail;
7442 }
7443 {
7444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7445 }
7446 return resultobj;
7447 fail:
7448 return NULL;
7449 }
7450
7451
7452 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7453 PyObject *resultobj;
7454 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7455 int arg2 = (int) -1 ;
7456 PyObject *result;
7457 PyObject * obj0 = 0 ;
7458 PyObject * obj1 = 0 ;
7459 char *kwnames[] = {
7460 (char *) "self",(char *) "size", NULL
7461 };
7462
7463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7465 if (SWIG_arg_fail(1)) SWIG_fail;
7466 if (obj1) {
7467 {
7468 arg2 = (int)(SWIG_As_int(obj1));
7469 if (SWIG_arg_fail(2)) SWIG_fail;
7470 }
7471 }
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 result = (PyObject *)(arg1)->read(arg2);
7475
7476 wxPyEndAllowThreads(__tstate);
7477 if (PyErr_Occurred()) SWIG_fail;
7478 }
7479 resultobj = result;
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7487 PyObject *resultobj;
7488 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7489 int arg2 = (int) -1 ;
7490 PyObject *result;
7491 PyObject * obj0 = 0 ;
7492 PyObject * obj1 = 0 ;
7493 char *kwnames[] = {
7494 (char *) "self",(char *) "size", NULL
7495 };
7496
7497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7499 if (SWIG_arg_fail(1)) SWIG_fail;
7500 if (obj1) {
7501 {
7502 arg2 = (int)(SWIG_As_int(obj1));
7503 if (SWIG_arg_fail(2)) SWIG_fail;
7504 }
7505 }
7506 {
7507 PyThreadState* __tstate = wxPyBeginAllowThreads();
7508 result = (PyObject *)(arg1)->readline(arg2);
7509
7510 wxPyEndAllowThreads(__tstate);
7511 if (PyErr_Occurred()) SWIG_fail;
7512 }
7513 resultobj = result;
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7521 PyObject *resultobj;
7522 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7523 int arg2 = (int) -1 ;
7524 PyObject *result;
7525 PyObject * obj0 = 0 ;
7526 PyObject * obj1 = 0 ;
7527 char *kwnames[] = {
7528 (char *) "self",(char *) "sizehint", NULL
7529 };
7530
7531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7533 if (SWIG_arg_fail(1)) SWIG_fail;
7534 if (obj1) {
7535 {
7536 arg2 = (int)(SWIG_As_int(obj1));
7537 if (SWIG_arg_fail(2)) SWIG_fail;
7538 }
7539 }
7540 {
7541 PyThreadState* __tstate = wxPyBeginAllowThreads();
7542 result = (PyObject *)(arg1)->readlines(arg2);
7543
7544 wxPyEndAllowThreads(__tstate);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 resultobj = result;
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj;
7556 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7557 int arg2 ;
7558 int arg3 = (int) 0 ;
7559 PyObject * obj0 = 0 ;
7560 PyObject * obj1 = 0 ;
7561 PyObject * obj2 = 0 ;
7562 char *kwnames[] = {
7563 (char *) "self",(char *) "offset",(char *) "whence", NULL
7564 };
7565
7566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7568 if (SWIG_arg_fail(1)) SWIG_fail;
7569 {
7570 arg2 = (int)(SWIG_As_int(obj1));
7571 if (SWIG_arg_fail(2)) SWIG_fail;
7572 }
7573 if (obj2) {
7574 {
7575 arg3 = (int)(SWIG_As_int(obj2));
7576 if (SWIG_arg_fail(3)) SWIG_fail;
7577 }
7578 }
7579 {
7580 PyThreadState* __tstate = wxPyBeginAllowThreads();
7581 (arg1)->seek(arg2,arg3);
7582
7583 wxPyEndAllowThreads(__tstate);
7584 if (PyErr_Occurred()) SWIG_fail;
7585 }
7586 Py_INCREF(Py_None); resultobj = Py_None;
7587 return resultobj;
7588 fail:
7589 return NULL;
7590 }
7591
7592
7593 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7594 PyObject *resultobj;
7595 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7596 int result;
7597 PyObject * obj0 = 0 ;
7598 char *kwnames[] = {
7599 (char *) "self", NULL
7600 };
7601
7602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7604 if (SWIG_arg_fail(1)) SWIG_fail;
7605 {
7606 PyThreadState* __tstate = wxPyBeginAllowThreads();
7607 result = (int)(arg1)->tell();
7608
7609 wxPyEndAllowThreads(__tstate);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 {
7613 resultobj = SWIG_From_int((int)(result));
7614 }
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj;
7623 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7624 char result;
7625 PyObject * obj0 = 0 ;
7626 char *kwnames[] = {
7627 (char *) "self", NULL
7628 };
7629
7630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7632 if (SWIG_arg_fail(1)) SWIG_fail;
7633 {
7634 PyThreadState* __tstate = wxPyBeginAllowThreads();
7635 result = (char)(arg1)->Peek();
7636
7637 wxPyEndAllowThreads(__tstate);
7638 if (PyErr_Occurred()) SWIG_fail;
7639 }
7640 {
7641 resultobj = SWIG_From_char((char)(result));
7642 }
7643 return resultobj;
7644 fail:
7645 return NULL;
7646 }
7647
7648
7649 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7650 PyObject *resultobj;
7651 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7652 char result;
7653 PyObject * obj0 = 0 ;
7654 char *kwnames[] = {
7655 (char *) "self", NULL
7656 };
7657
7658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7660 if (SWIG_arg_fail(1)) SWIG_fail;
7661 {
7662 PyThreadState* __tstate = wxPyBeginAllowThreads();
7663 result = (char)(arg1)->GetC();
7664
7665 wxPyEndAllowThreads(__tstate);
7666 if (PyErr_Occurred()) SWIG_fail;
7667 }
7668 {
7669 resultobj = SWIG_From_char((char)(result));
7670 }
7671 return resultobj;
7672 fail:
7673 return NULL;
7674 }
7675
7676
7677 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7678 PyObject *resultobj;
7679 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7680 size_t result;
7681 PyObject * obj0 = 0 ;
7682 char *kwnames[] = {
7683 (char *) "self", NULL
7684 };
7685
7686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7688 if (SWIG_arg_fail(1)) SWIG_fail;
7689 {
7690 PyThreadState* __tstate = wxPyBeginAllowThreads();
7691 result = (size_t)(arg1)->LastRead();
7692
7693 wxPyEndAllowThreads(__tstate);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 {
7697 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7698 }
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7706 PyObject *resultobj;
7707 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7708 bool result;
7709 PyObject * obj0 = 0 ;
7710 char *kwnames[] = {
7711 (char *) "self", NULL
7712 };
7713
7714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7716 if (SWIG_arg_fail(1)) SWIG_fail;
7717 {
7718 PyThreadState* __tstate = wxPyBeginAllowThreads();
7719 result = (bool)(arg1)->CanRead();
7720
7721 wxPyEndAllowThreads(__tstate);
7722 if (PyErr_Occurred()) SWIG_fail;
7723 }
7724 {
7725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7726 }
7727 return resultobj;
7728 fail:
7729 return NULL;
7730 }
7731
7732
7733 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7734 PyObject *resultobj;
7735 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7736 bool result;
7737 PyObject * obj0 = 0 ;
7738 char *kwnames[] = {
7739 (char *) "self", NULL
7740 };
7741
7742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7744 if (SWIG_arg_fail(1)) SWIG_fail;
7745 {
7746 PyThreadState* __tstate = wxPyBeginAllowThreads();
7747 result = (bool)(arg1)->Eof();
7748
7749 wxPyEndAllowThreads(__tstate);
7750 if (PyErr_Occurred()) SWIG_fail;
7751 }
7752 {
7753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7754 }
7755 return resultobj;
7756 fail:
7757 return NULL;
7758 }
7759
7760
7761 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7762 PyObject *resultobj;
7763 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7764 char arg2 ;
7765 bool result;
7766 PyObject * obj0 = 0 ;
7767 PyObject * obj1 = 0 ;
7768 char *kwnames[] = {
7769 (char *) "self",(char *) "c", NULL
7770 };
7771
7772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7774 if (SWIG_arg_fail(1)) SWIG_fail;
7775 {
7776 arg2 = (char)(SWIG_As_char(obj1));
7777 if (SWIG_arg_fail(2)) SWIG_fail;
7778 }
7779 {
7780 PyThreadState* __tstate = wxPyBeginAllowThreads();
7781 result = (bool)(arg1)->Ungetch(arg2);
7782
7783 wxPyEndAllowThreads(__tstate);
7784 if (PyErr_Occurred()) SWIG_fail;
7785 }
7786 {
7787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7788 }
7789 return resultobj;
7790 fail:
7791 return NULL;
7792 }
7793
7794
7795 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7796 PyObject *resultobj;
7797 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7798 long arg2 ;
7799 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7800 long result;
7801 PyObject * obj0 = 0 ;
7802 PyObject * obj1 = 0 ;
7803 PyObject * obj2 = 0 ;
7804 char *kwnames[] = {
7805 (char *) "self",(char *) "pos",(char *) "mode", NULL
7806 };
7807
7808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7810 if (SWIG_arg_fail(1)) SWIG_fail;
7811 {
7812 arg2 = (long)(SWIG_As_long(obj1));
7813 if (SWIG_arg_fail(2)) SWIG_fail;
7814 }
7815 if (obj2) {
7816 {
7817 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7818 if (SWIG_arg_fail(3)) SWIG_fail;
7819 }
7820 }
7821 {
7822 PyThreadState* __tstate = wxPyBeginAllowThreads();
7823 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7824
7825 wxPyEndAllowThreads(__tstate);
7826 if (PyErr_Occurred()) SWIG_fail;
7827 }
7828 {
7829 resultobj = SWIG_From_long((long)(result));
7830 }
7831 return resultobj;
7832 fail:
7833 return NULL;
7834 }
7835
7836
7837 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7838 PyObject *resultobj;
7839 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7840 long result;
7841 PyObject * obj0 = 0 ;
7842 char *kwnames[] = {
7843 (char *) "self", NULL
7844 };
7845
7846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7848 if (SWIG_arg_fail(1)) SWIG_fail;
7849 {
7850 PyThreadState* __tstate = wxPyBeginAllowThreads();
7851 result = (long)(arg1)->TellI();
7852
7853 wxPyEndAllowThreads(__tstate);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 {
7857 resultobj = SWIG_From_long((long)(result));
7858 }
7859 return resultobj;
7860 fail:
7861 return NULL;
7862 }
7863
7864
7865 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7866 PyObject *obj;
7867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7868 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7869 Py_INCREF(obj);
7870 return Py_BuildValue((char *)"");
7871 }
7872 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7873 PyObject *resultobj;
7874 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7875 PyObject *arg2 = (PyObject *) 0 ;
7876 PyObject * obj0 = 0 ;
7877 PyObject * obj1 = 0 ;
7878 char *kwnames[] = {
7879 (char *) "self",(char *) "obj", NULL
7880 };
7881
7882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7884 if (SWIG_arg_fail(1)) SWIG_fail;
7885 arg2 = obj1;
7886 {
7887 PyThreadState* __tstate = wxPyBeginAllowThreads();
7888 wxOutputStream_write(arg1,arg2);
7889
7890 wxPyEndAllowThreads(__tstate);
7891 if (PyErr_Occurred()) SWIG_fail;
7892 }
7893 Py_INCREF(Py_None); resultobj = Py_None;
7894 return resultobj;
7895 fail:
7896 return NULL;
7897 }
7898
7899
7900 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7901 PyObject *obj;
7902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7903 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7904 Py_INCREF(obj);
7905 return Py_BuildValue((char *)"");
7906 }
7907 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7908 PyObject *resultobj;
7909 wxInputStream *arg1 = (wxInputStream *) 0 ;
7910 wxString *arg2 = 0 ;
7911 wxString *arg3 = 0 ;
7912 wxString *arg4 = 0 ;
7913 wxDateTime arg5 ;
7914 wxFSFile *result;
7915 wxPyInputStream *temp1 ;
7916 bool created1 ;
7917 bool temp2 = false ;
7918 bool temp3 = false ;
7919 bool temp4 = false ;
7920 PyObject * obj0 = 0 ;
7921 PyObject * obj1 = 0 ;
7922 PyObject * obj2 = 0 ;
7923 PyObject * obj3 = 0 ;
7924 PyObject * obj4 = 0 ;
7925 char *kwnames[] = {
7926 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7927 };
7928
7929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7930 {
7931 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7932 arg1 = temp1->m_wxis;
7933 created1 = false;
7934 } else {
7935 PyErr_Clear(); // clear the failure of the wxPyConvert above
7936 arg1 = wxPyCBInputStream_create(obj0, false);
7937 if (arg1 == NULL) {
7938 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7939 SWIG_fail;
7940 }
7941 created1 = true;
7942 }
7943 }
7944 {
7945 arg2 = wxString_in_helper(obj1);
7946 if (arg2 == NULL) SWIG_fail;
7947 temp2 = true;
7948 }
7949 {
7950 arg3 = wxString_in_helper(obj2);
7951 if (arg3 == NULL) SWIG_fail;
7952 temp3 = true;
7953 }
7954 {
7955 arg4 = wxString_in_helper(obj3);
7956 if (arg4 == NULL) SWIG_fail;
7957 temp4 = true;
7958 }
7959 {
7960 wxDateTime * argp;
7961 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7962 if (SWIG_arg_fail(5)) SWIG_fail;
7963 if (argp == NULL) {
7964 SWIG_null_ref("wxDateTime");
7965 }
7966 if (SWIG_arg_fail(5)) SWIG_fail;
7967 arg5 = *argp;
7968 }
7969 {
7970 PyThreadState* __tstate = wxPyBeginAllowThreads();
7971 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7972
7973 wxPyEndAllowThreads(__tstate);
7974 if (PyErr_Occurred()) SWIG_fail;
7975 }
7976 {
7977 resultobj = wxPyMake_wxObject(result, 1);
7978 }
7979 {
7980 if (created1)
7981 delete arg1;
7982 }
7983 {
7984 if (temp2)
7985 delete arg2;
7986 }
7987 {
7988 if (temp3)
7989 delete arg3;
7990 }
7991 {
7992 if (temp4)
7993 delete arg4;
7994 }
7995 return resultobj;
7996 fail:
7997 {
7998 if (created1)
7999 delete arg1;
8000 }
8001 {
8002 if (temp2)
8003 delete arg2;
8004 }
8005 {
8006 if (temp3)
8007 delete arg3;
8008 }
8009 {
8010 if (temp4)
8011 delete arg4;
8012 }
8013 return NULL;
8014 }
8015
8016
8017 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8018 PyObject *resultobj;
8019 wxFSFile *arg1 = (wxFSFile *) 0 ;
8020 PyObject * obj0 = 0 ;
8021 char *kwnames[] = {
8022 (char *) "self", NULL
8023 };
8024
8025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8027 if (SWIG_arg_fail(1)) SWIG_fail;
8028 {
8029 PyThreadState* __tstate = wxPyBeginAllowThreads();
8030 delete arg1;
8031
8032 wxPyEndAllowThreads(__tstate);
8033 if (PyErr_Occurred()) SWIG_fail;
8034 }
8035 Py_INCREF(Py_None); resultobj = Py_None;
8036 return resultobj;
8037 fail:
8038 return NULL;
8039 }
8040
8041
8042 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8043 PyObject *resultobj;
8044 wxFSFile *arg1 = (wxFSFile *) 0 ;
8045 wxInputStream *result;
8046 PyObject * obj0 = 0 ;
8047 char *kwnames[] = {
8048 (char *) "self", NULL
8049 };
8050
8051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8053 if (SWIG_arg_fail(1)) SWIG_fail;
8054 {
8055 PyThreadState* __tstate = wxPyBeginAllowThreads();
8056 result = (wxInputStream *)(arg1)->GetStream();
8057
8058 wxPyEndAllowThreads(__tstate);
8059 if (PyErr_Occurred()) SWIG_fail;
8060 }
8061 {
8062 wxPyInputStream * _ptr = NULL;
8063
8064 if (result) {
8065 _ptr = new wxPyInputStream(result);
8066 }
8067 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8068 }
8069 return resultobj;
8070 fail:
8071 return NULL;
8072 }
8073
8074
8075 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8076 PyObject *resultobj;
8077 wxFSFile *arg1 = (wxFSFile *) 0 ;
8078 wxString *result;
8079 PyObject * obj0 = 0 ;
8080 char *kwnames[] = {
8081 (char *) "self", NULL
8082 };
8083
8084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8086 if (SWIG_arg_fail(1)) SWIG_fail;
8087 {
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 {
8090 wxString const &_result_ref = (arg1)->GetMimeType();
8091 result = (wxString *) &_result_ref;
8092 }
8093
8094 wxPyEndAllowThreads(__tstate);
8095 if (PyErr_Occurred()) SWIG_fail;
8096 }
8097 {
8098 #if wxUSE_UNICODE
8099 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8100 #else
8101 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8102 #endif
8103 }
8104 return resultobj;
8105 fail:
8106 return NULL;
8107 }
8108
8109
8110 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8111 PyObject *resultobj;
8112 wxFSFile *arg1 = (wxFSFile *) 0 ;
8113 wxString *result;
8114 PyObject * obj0 = 0 ;
8115 char *kwnames[] = {
8116 (char *) "self", NULL
8117 };
8118
8119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8121 if (SWIG_arg_fail(1)) SWIG_fail;
8122 {
8123 PyThreadState* __tstate = wxPyBeginAllowThreads();
8124 {
8125 wxString const &_result_ref = (arg1)->GetLocation();
8126 result = (wxString *) &_result_ref;
8127 }
8128
8129 wxPyEndAllowThreads(__tstate);
8130 if (PyErr_Occurred()) SWIG_fail;
8131 }
8132 {
8133 #if wxUSE_UNICODE
8134 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8135 #else
8136 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8137 #endif
8138 }
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj;
8147 wxFSFile *arg1 = (wxFSFile *) 0 ;
8148 wxString *result;
8149 PyObject * obj0 = 0 ;
8150 char *kwnames[] = {
8151 (char *) "self", NULL
8152 };
8153
8154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8156 if (SWIG_arg_fail(1)) SWIG_fail;
8157 {
8158 PyThreadState* __tstate = wxPyBeginAllowThreads();
8159 {
8160 wxString const &_result_ref = (arg1)->GetAnchor();
8161 result = (wxString *) &_result_ref;
8162 }
8163
8164 wxPyEndAllowThreads(__tstate);
8165 if (PyErr_Occurred()) SWIG_fail;
8166 }
8167 {
8168 #if wxUSE_UNICODE
8169 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8170 #else
8171 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8172 #endif
8173 }
8174 return resultobj;
8175 fail:
8176 return NULL;
8177 }
8178
8179
8180 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8181 PyObject *resultobj;
8182 wxFSFile *arg1 = (wxFSFile *) 0 ;
8183 wxDateTime result;
8184 PyObject * obj0 = 0 ;
8185 char *kwnames[] = {
8186 (char *) "self", NULL
8187 };
8188
8189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8191 if (SWIG_arg_fail(1)) SWIG_fail;
8192 {
8193 PyThreadState* __tstate = wxPyBeginAllowThreads();
8194 result = (arg1)->GetModificationTime();
8195
8196 wxPyEndAllowThreads(__tstate);
8197 if (PyErr_Occurred()) SWIG_fail;
8198 }
8199 {
8200 wxDateTime * resultptr;
8201 resultptr = new wxDateTime((wxDateTime &)(result));
8202 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8203 }
8204 return resultobj;
8205 fail:
8206 return NULL;
8207 }
8208
8209
8210 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8211 PyObject *obj;
8212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8213 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8214 Py_INCREF(obj);
8215 return Py_BuildValue((char *)"");
8216 }
8217 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8218 PyObject *obj;
8219 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8220 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8221 Py_INCREF(obj);
8222 return Py_BuildValue((char *)"");
8223 }
8224 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8225 PyObject *resultobj;
8226 wxPyFileSystemHandler *result;
8227 char *kwnames[] = {
8228 NULL
8229 };
8230
8231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8232 {
8233 PyThreadState* __tstate = wxPyBeginAllowThreads();
8234 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8235
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8240 return resultobj;
8241 fail:
8242 return NULL;
8243 }
8244
8245
8246 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8247 PyObject *resultobj;
8248 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8249 PyObject *arg2 = (PyObject *) 0 ;
8250 PyObject *arg3 = (PyObject *) 0 ;
8251 PyObject * obj0 = 0 ;
8252 PyObject * obj1 = 0 ;
8253 PyObject * obj2 = 0 ;
8254 char *kwnames[] = {
8255 (char *) "self",(char *) "self",(char *) "_class", NULL
8256 };
8257
8258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = obj1;
8262 arg3 = obj2;
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 (arg1)->_setCallbackInfo(arg2,arg3);
8266
8267 wxPyEndAllowThreads(__tstate);
8268 if (PyErr_Occurred()) SWIG_fail;
8269 }
8270 Py_INCREF(Py_None); resultobj = Py_None;
8271 return resultobj;
8272 fail:
8273 return NULL;
8274 }
8275
8276
8277 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8278 PyObject *resultobj;
8279 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8280 wxString *arg2 = 0 ;
8281 bool result;
8282 bool temp2 = false ;
8283 PyObject * obj0 = 0 ;
8284 PyObject * obj1 = 0 ;
8285 char *kwnames[] = {
8286 (char *) "self",(char *) "location", NULL
8287 };
8288
8289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8291 if (SWIG_arg_fail(1)) SWIG_fail;
8292 {
8293 arg2 = wxString_in_helper(obj1);
8294 if (arg2 == NULL) SWIG_fail;
8295 temp2 = true;
8296 }
8297 {
8298 PyThreadState* __tstate = wxPyBeginAllowThreads();
8299 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8300
8301 wxPyEndAllowThreads(__tstate);
8302 if (PyErr_Occurred()) SWIG_fail;
8303 }
8304 {
8305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8306 }
8307 {
8308 if (temp2)
8309 delete arg2;
8310 }
8311 return resultobj;
8312 fail:
8313 {
8314 if (temp2)
8315 delete arg2;
8316 }
8317 return NULL;
8318 }
8319
8320
8321 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8322 PyObject *resultobj;
8323 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8324 wxFileSystem *arg2 = 0 ;
8325 wxString *arg3 = 0 ;
8326 wxFSFile *result;
8327 bool temp3 = false ;
8328 PyObject * obj0 = 0 ;
8329 PyObject * obj1 = 0 ;
8330 PyObject * obj2 = 0 ;
8331 char *kwnames[] = {
8332 (char *) "self",(char *) "fs",(char *) "location", NULL
8333 };
8334
8335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8337 if (SWIG_arg_fail(1)) SWIG_fail;
8338 {
8339 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8340 if (SWIG_arg_fail(2)) SWIG_fail;
8341 if (arg2 == NULL) {
8342 SWIG_null_ref("wxFileSystem");
8343 }
8344 if (SWIG_arg_fail(2)) SWIG_fail;
8345 }
8346 {
8347 arg3 = wxString_in_helper(obj2);
8348 if (arg3 == NULL) SWIG_fail;
8349 temp3 = true;
8350 }
8351 {
8352 PyThreadState* __tstate = wxPyBeginAllowThreads();
8353 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8354
8355 wxPyEndAllowThreads(__tstate);
8356 if (PyErr_Occurred()) SWIG_fail;
8357 }
8358 {
8359 resultobj = wxPyMake_wxObject(result, 1);
8360 }
8361 {
8362 if (temp3)
8363 delete arg3;
8364 }
8365 return resultobj;
8366 fail:
8367 {
8368 if (temp3)
8369 delete arg3;
8370 }
8371 return NULL;
8372 }
8373
8374
8375 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8376 PyObject *resultobj;
8377 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8378 wxString *arg2 = 0 ;
8379 int arg3 = (int) 0 ;
8380 wxString result;
8381 bool temp2 = false ;
8382 PyObject * obj0 = 0 ;
8383 PyObject * obj1 = 0 ;
8384 PyObject * obj2 = 0 ;
8385 char *kwnames[] = {
8386 (char *) "self",(char *) "spec",(char *) "flags", NULL
8387 };
8388
8389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8391 if (SWIG_arg_fail(1)) SWIG_fail;
8392 {
8393 arg2 = wxString_in_helper(obj1);
8394 if (arg2 == NULL) SWIG_fail;
8395 temp2 = true;
8396 }
8397 if (obj2) {
8398 {
8399 arg3 = (int)(SWIG_As_int(obj2));
8400 if (SWIG_arg_fail(3)) SWIG_fail;
8401 }
8402 }
8403 {
8404 PyThreadState* __tstate = wxPyBeginAllowThreads();
8405 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8406
8407 wxPyEndAllowThreads(__tstate);
8408 if (PyErr_Occurred()) SWIG_fail;
8409 }
8410 {
8411 #if wxUSE_UNICODE
8412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8413 #else
8414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8415 #endif
8416 }
8417 {
8418 if (temp2)
8419 delete arg2;
8420 }
8421 return resultobj;
8422 fail:
8423 {
8424 if (temp2)
8425 delete arg2;
8426 }
8427 return NULL;
8428 }
8429
8430
8431 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8432 PyObject *resultobj;
8433 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8434 wxString result;
8435 PyObject * obj0 = 0 ;
8436 char *kwnames[] = {
8437 (char *) "self", NULL
8438 };
8439
8440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8442 if (SWIG_arg_fail(1)) SWIG_fail;
8443 {
8444 PyThreadState* __tstate = wxPyBeginAllowThreads();
8445 result = (arg1)->FindNext();
8446
8447 wxPyEndAllowThreads(__tstate);
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 {
8451 #if wxUSE_UNICODE
8452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8453 #else
8454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8455 #endif
8456 }
8457 return resultobj;
8458 fail:
8459 return NULL;
8460 }
8461
8462
8463 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8464 PyObject *resultobj;
8465 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8466 wxString *arg2 = 0 ;
8467 wxString result;
8468 bool temp2 = false ;
8469 PyObject * obj0 = 0 ;
8470 PyObject * obj1 = 0 ;
8471 char *kwnames[] = {
8472 (char *) "self",(char *) "location", NULL
8473 };
8474
8475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8477 if (SWIG_arg_fail(1)) SWIG_fail;
8478 {
8479 arg2 = wxString_in_helper(obj1);
8480 if (arg2 == NULL) SWIG_fail;
8481 temp2 = true;
8482 }
8483 {
8484 PyThreadState* __tstate = wxPyBeginAllowThreads();
8485 result = (arg1)->GetProtocol((wxString const &)*arg2);
8486
8487 wxPyEndAllowThreads(__tstate);
8488 if (PyErr_Occurred()) SWIG_fail;
8489 }
8490 {
8491 #if wxUSE_UNICODE
8492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8493 #else
8494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8495 #endif
8496 }
8497 {
8498 if (temp2)
8499 delete arg2;
8500 }
8501 return resultobj;
8502 fail:
8503 {
8504 if (temp2)
8505 delete arg2;
8506 }
8507 return NULL;
8508 }
8509
8510
8511 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8512 PyObject *resultobj;
8513 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8514 wxString *arg2 = 0 ;
8515 wxString result;
8516 bool temp2 = false ;
8517 PyObject * obj0 = 0 ;
8518 PyObject * obj1 = 0 ;
8519 char *kwnames[] = {
8520 (char *) "self",(char *) "location", NULL
8521 };
8522
8523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8525 if (SWIG_arg_fail(1)) SWIG_fail;
8526 {
8527 arg2 = wxString_in_helper(obj1);
8528 if (arg2 == NULL) SWIG_fail;
8529 temp2 = true;
8530 }
8531 {
8532 PyThreadState* __tstate = wxPyBeginAllowThreads();
8533 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8534
8535 wxPyEndAllowThreads(__tstate);
8536 if (PyErr_Occurred()) SWIG_fail;
8537 }
8538 {
8539 #if wxUSE_UNICODE
8540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8541 #else
8542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8543 #endif
8544 }
8545 {
8546 if (temp2)
8547 delete arg2;
8548 }
8549 return resultobj;
8550 fail:
8551 {
8552 if (temp2)
8553 delete arg2;
8554 }
8555 return NULL;
8556 }
8557
8558
8559 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8560 PyObject *resultobj;
8561 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8562 wxString *arg2 = 0 ;
8563 wxString result;
8564 bool temp2 = false ;
8565 PyObject * obj0 = 0 ;
8566 PyObject * obj1 = 0 ;
8567 char *kwnames[] = {
8568 (char *) "self",(char *) "location", NULL
8569 };
8570
8571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8573 if (SWIG_arg_fail(1)) SWIG_fail;
8574 {
8575 arg2 = wxString_in_helper(obj1);
8576 if (arg2 == NULL) SWIG_fail;
8577 temp2 = true;
8578 }
8579 {
8580 PyThreadState* __tstate = wxPyBeginAllowThreads();
8581 result = (arg1)->GetAnchor((wxString const &)*arg2);
8582
8583 wxPyEndAllowThreads(__tstate);
8584 if (PyErr_Occurred()) SWIG_fail;
8585 }
8586 {
8587 #if wxUSE_UNICODE
8588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8589 #else
8590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8591 #endif
8592 }
8593 {
8594 if (temp2)
8595 delete arg2;
8596 }
8597 return resultobj;
8598 fail:
8599 {
8600 if (temp2)
8601 delete arg2;
8602 }
8603 return NULL;
8604 }
8605
8606
8607 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8608 PyObject *resultobj;
8609 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8610 wxString *arg2 = 0 ;
8611 wxString result;
8612 bool temp2 = false ;
8613 PyObject * obj0 = 0 ;
8614 PyObject * obj1 = 0 ;
8615 char *kwnames[] = {
8616 (char *) "self",(char *) "location", NULL
8617 };
8618
8619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8621 if (SWIG_arg_fail(1)) SWIG_fail;
8622 {
8623 arg2 = wxString_in_helper(obj1);
8624 if (arg2 == NULL) SWIG_fail;
8625 temp2 = true;
8626 }
8627 {
8628 PyThreadState* __tstate = wxPyBeginAllowThreads();
8629 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8630
8631 wxPyEndAllowThreads(__tstate);
8632 if (PyErr_Occurred()) SWIG_fail;
8633 }
8634 {
8635 #if wxUSE_UNICODE
8636 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8637 #else
8638 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8639 #endif
8640 }
8641 {
8642 if (temp2)
8643 delete arg2;
8644 }
8645 return resultobj;
8646 fail:
8647 {
8648 if (temp2)
8649 delete arg2;
8650 }
8651 return NULL;
8652 }
8653
8654
8655 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8656 PyObject *resultobj;
8657 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8658 wxString *arg2 = 0 ;
8659 wxString result;
8660 bool temp2 = false ;
8661 PyObject * obj0 = 0 ;
8662 PyObject * obj1 = 0 ;
8663 char *kwnames[] = {
8664 (char *) "self",(char *) "location", NULL
8665 };
8666
8667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8669 if (SWIG_arg_fail(1)) SWIG_fail;
8670 {
8671 arg2 = wxString_in_helper(obj1);
8672 if (arg2 == NULL) SWIG_fail;
8673 temp2 = true;
8674 }
8675 {
8676 PyThreadState* __tstate = wxPyBeginAllowThreads();
8677 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8678
8679 wxPyEndAllowThreads(__tstate);
8680 if (PyErr_Occurred()) SWIG_fail;
8681 }
8682 {
8683 #if wxUSE_UNICODE
8684 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8685 #else
8686 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8687 #endif
8688 }
8689 {
8690 if (temp2)
8691 delete arg2;
8692 }
8693 return resultobj;
8694 fail:
8695 {
8696 if (temp2)
8697 delete arg2;
8698 }
8699 return NULL;
8700 }
8701
8702
8703 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8704 PyObject *obj;
8705 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8706 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8707 Py_INCREF(obj);
8708 return Py_BuildValue((char *)"");
8709 }
8710 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8711 PyObject *resultobj;
8712 wxFileSystem *result;
8713 char *kwnames[] = {
8714 NULL
8715 };
8716
8717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8718 {
8719 PyThreadState* __tstate = wxPyBeginAllowThreads();
8720 result = (wxFileSystem *)new wxFileSystem();
8721
8722 wxPyEndAllowThreads(__tstate);
8723 if (PyErr_Occurred()) SWIG_fail;
8724 }
8725 {
8726 resultobj = wxPyMake_wxObject(result, 1);
8727 }
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj;
8736 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8737 PyObject * obj0 = 0 ;
8738 char *kwnames[] = {
8739 (char *) "self", NULL
8740 };
8741
8742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8744 if (SWIG_arg_fail(1)) SWIG_fail;
8745 {
8746 PyThreadState* __tstate = wxPyBeginAllowThreads();
8747 delete arg1;
8748
8749 wxPyEndAllowThreads(__tstate);
8750 if (PyErr_Occurred()) SWIG_fail;
8751 }
8752 Py_INCREF(Py_None); resultobj = Py_None;
8753 return resultobj;
8754 fail:
8755 return NULL;
8756 }
8757
8758
8759 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8760 PyObject *resultobj;
8761 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8762 wxString *arg2 = 0 ;
8763 bool arg3 = (bool) false ;
8764 bool temp2 = false ;
8765 PyObject * obj0 = 0 ;
8766 PyObject * obj1 = 0 ;
8767 PyObject * obj2 = 0 ;
8768 char *kwnames[] = {
8769 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8770 };
8771
8772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8774 if (SWIG_arg_fail(1)) SWIG_fail;
8775 {
8776 arg2 = wxString_in_helper(obj1);
8777 if (arg2 == NULL) SWIG_fail;
8778 temp2 = true;
8779 }
8780 if (obj2) {
8781 {
8782 arg3 = (bool)(SWIG_As_bool(obj2));
8783 if (SWIG_arg_fail(3)) SWIG_fail;
8784 }
8785 }
8786 {
8787 PyThreadState* __tstate = wxPyBeginAllowThreads();
8788 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8789
8790 wxPyEndAllowThreads(__tstate);
8791 if (PyErr_Occurred()) SWIG_fail;
8792 }
8793 Py_INCREF(Py_None); resultobj = Py_None;
8794 {
8795 if (temp2)
8796 delete arg2;
8797 }
8798 return resultobj;
8799 fail:
8800 {
8801 if (temp2)
8802 delete arg2;
8803 }
8804 return NULL;
8805 }
8806
8807
8808 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8809 PyObject *resultobj;
8810 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8811 wxString result;
8812 PyObject * obj0 = 0 ;
8813 char *kwnames[] = {
8814 (char *) "self", NULL
8815 };
8816
8817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8819 if (SWIG_arg_fail(1)) SWIG_fail;
8820 {
8821 PyThreadState* __tstate = wxPyBeginAllowThreads();
8822 result = (arg1)->GetPath();
8823
8824 wxPyEndAllowThreads(__tstate);
8825 if (PyErr_Occurred()) SWIG_fail;
8826 }
8827 {
8828 #if wxUSE_UNICODE
8829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8830 #else
8831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8832 #endif
8833 }
8834 return resultobj;
8835 fail:
8836 return NULL;
8837 }
8838
8839
8840 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8841 PyObject *resultobj;
8842 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8843 wxString *arg2 = 0 ;
8844 wxFSFile *result;
8845 bool temp2 = false ;
8846 PyObject * obj0 = 0 ;
8847 PyObject * obj1 = 0 ;
8848 char *kwnames[] = {
8849 (char *) "self",(char *) "location", NULL
8850 };
8851
8852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8854 if (SWIG_arg_fail(1)) SWIG_fail;
8855 {
8856 arg2 = wxString_in_helper(obj1);
8857 if (arg2 == NULL) SWIG_fail;
8858 temp2 = true;
8859 }
8860 {
8861 PyThreadState* __tstate = wxPyBeginAllowThreads();
8862 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8863
8864 wxPyEndAllowThreads(__tstate);
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 {
8868 resultobj = wxPyMake_wxObject(result, 1);
8869 }
8870 {
8871 if (temp2)
8872 delete arg2;
8873 }
8874 return resultobj;
8875 fail:
8876 {
8877 if (temp2)
8878 delete arg2;
8879 }
8880 return NULL;
8881 }
8882
8883
8884 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj;
8886 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8887 wxString *arg2 = 0 ;
8888 int arg3 = (int) 0 ;
8889 wxString result;
8890 bool temp2 = false ;
8891 PyObject * obj0 = 0 ;
8892 PyObject * obj1 = 0 ;
8893 PyObject * obj2 = 0 ;
8894 char *kwnames[] = {
8895 (char *) "self",(char *) "spec",(char *) "flags", NULL
8896 };
8897
8898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8900 if (SWIG_arg_fail(1)) SWIG_fail;
8901 {
8902 arg2 = wxString_in_helper(obj1);
8903 if (arg2 == NULL) SWIG_fail;
8904 temp2 = true;
8905 }
8906 if (obj2) {
8907 {
8908 arg3 = (int)(SWIG_As_int(obj2));
8909 if (SWIG_arg_fail(3)) SWIG_fail;
8910 }
8911 }
8912 {
8913 PyThreadState* __tstate = wxPyBeginAllowThreads();
8914 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8915
8916 wxPyEndAllowThreads(__tstate);
8917 if (PyErr_Occurred()) SWIG_fail;
8918 }
8919 {
8920 #if wxUSE_UNICODE
8921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8922 #else
8923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8924 #endif
8925 }
8926 {
8927 if (temp2)
8928 delete arg2;
8929 }
8930 return resultobj;
8931 fail:
8932 {
8933 if (temp2)
8934 delete arg2;
8935 }
8936 return NULL;
8937 }
8938
8939
8940 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8941 PyObject *resultobj;
8942 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8943 wxString result;
8944 PyObject * obj0 = 0 ;
8945 char *kwnames[] = {
8946 (char *) "self", NULL
8947 };
8948
8949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8951 if (SWIG_arg_fail(1)) SWIG_fail;
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 result = (arg1)->FindNext();
8955
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 {
8960 #if wxUSE_UNICODE
8961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8962 #else
8963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8964 #endif
8965 }
8966 return resultobj;
8967 fail:
8968 return NULL;
8969 }
8970
8971
8972 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8973 PyObject *resultobj;
8974 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8975 PyObject * obj0 = 0 ;
8976 char *kwnames[] = {
8977 (char *) "handler", NULL
8978 };
8979
8980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8982 if (SWIG_arg_fail(1)) SWIG_fail;
8983 {
8984 PyThreadState* __tstate = wxPyBeginAllowThreads();
8985 wxFileSystem::AddHandler(arg1);
8986
8987 wxPyEndAllowThreads(__tstate);
8988 if (PyErr_Occurred()) SWIG_fail;
8989 }
8990 Py_INCREF(Py_None); resultobj = Py_None;
8991 return resultobj;
8992 fail:
8993 return NULL;
8994 }
8995
8996
8997 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8998 PyObject *resultobj;
8999 char *kwnames[] = {
9000 NULL
9001 };
9002
9003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9004 {
9005 PyThreadState* __tstate = wxPyBeginAllowThreads();
9006 wxFileSystem::CleanUpHandlers();
9007
9008 wxPyEndAllowThreads(__tstate);
9009 if (PyErr_Occurred()) SWIG_fail;
9010 }
9011 Py_INCREF(Py_None); resultobj = Py_None;
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9019 PyObject *resultobj;
9020 wxString *arg1 = 0 ;
9021 wxString result;
9022 bool temp1 = false ;
9023 PyObject * obj0 = 0 ;
9024 char *kwnames[] = {
9025 (char *) "filename", NULL
9026 };
9027
9028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9029 {
9030 arg1 = wxString_in_helper(obj0);
9031 if (arg1 == NULL) SWIG_fail;
9032 temp1 = true;
9033 }
9034 {
9035 PyThreadState* __tstate = wxPyBeginAllowThreads();
9036 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9037
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 {
9042 #if wxUSE_UNICODE
9043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9044 #else
9045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9046 #endif
9047 }
9048 {
9049 if (temp1)
9050 delete arg1;
9051 }
9052 return resultobj;
9053 fail:
9054 {
9055 if (temp1)
9056 delete arg1;
9057 }
9058 return NULL;
9059 }
9060
9061
9062 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9063 PyObject *resultobj;
9064 wxString *arg1 = 0 ;
9065 wxString result;
9066 bool temp1 = false ;
9067 PyObject * obj0 = 0 ;
9068 char *kwnames[] = {
9069 (char *) "url", NULL
9070 };
9071
9072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9073 {
9074 arg1 = wxString_in_helper(obj0);
9075 if (arg1 == NULL) SWIG_fail;
9076 temp1 = true;
9077 }
9078 {
9079 PyThreadState* __tstate = wxPyBeginAllowThreads();
9080 result = FileSystem_URLToFileName((wxString const &)*arg1);
9081
9082 wxPyEndAllowThreads(__tstate);
9083 if (PyErr_Occurred()) SWIG_fail;
9084 }
9085 {
9086 #if wxUSE_UNICODE
9087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9088 #else
9089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9090 #endif
9091 }
9092 {
9093 if (temp1)
9094 delete arg1;
9095 }
9096 return resultobj;
9097 fail:
9098 {
9099 if (temp1)
9100 delete arg1;
9101 }
9102 return NULL;
9103 }
9104
9105
9106 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9107 PyObject *obj;
9108 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9109 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9110 Py_INCREF(obj);
9111 return Py_BuildValue((char *)"");
9112 }
9113 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9114 PyObject *resultobj;
9115 wxInternetFSHandler *result;
9116 char *kwnames[] = {
9117 NULL
9118 };
9119
9120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9121 {
9122 PyThreadState* __tstate = wxPyBeginAllowThreads();
9123 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9124
9125 wxPyEndAllowThreads(__tstate);
9126 if (PyErr_Occurred()) SWIG_fail;
9127 }
9128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9136 PyObject *resultobj;
9137 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9138 wxString *arg2 = 0 ;
9139 bool result;
9140 bool temp2 = false ;
9141 PyObject * obj0 = 0 ;
9142 PyObject * obj1 = 0 ;
9143 char *kwnames[] = {
9144 (char *) "self",(char *) "location", NULL
9145 };
9146
9147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9149 if (SWIG_arg_fail(1)) SWIG_fail;
9150 {
9151 arg2 = wxString_in_helper(obj1);
9152 if (arg2 == NULL) SWIG_fail;
9153 temp2 = true;
9154 }
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9158
9159 wxPyEndAllowThreads(__tstate);
9160 if (PyErr_Occurred()) SWIG_fail;
9161 }
9162 {
9163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9164 }
9165 {
9166 if (temp2)
9167 delete arg2;
9168 }
9169 return resultobj;
9170 fail:
9171 {
9172 if (temp2)
9173 delete arg2;
9174 }
9175 return NULL;
9176 }
9177
9178
9179 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9180 PyObject *resultobj;
9181 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9182 wxFileSystem *arg2 = 0 ;
9183 wxString *arg3 = 0 ;
9184 wxFSFile *result;
9185 bool temp3 = false ;
9186 PyObject * obj0 = 0 ;
9187 PyObject * obj1 = 0 ;
9188 PyObject * obj2 = 0 ;
9189 char *kwnames[] = {
9190 (char *) "self",(char *) "fs",(char *) "location", NULL
9191 };
9192
9193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9195 if (SWIG_arg_fail(1)) SWIG_fail;
9196 {
9197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9198 if (SWIG_arg_fail(2)) SWIG_fail;
9199 if (arg2 == NULL) {
9200 SWIG_null_ref("wxFileSystem");
9201 }
9202 if (SWIG_arg_fail(2)) SWIG_fail;
9203 }
9204 {
9205 arg3 = wxString_in_helper(obj2);
9206 if (arg3 == NULL) SWIG_fail;
9207 temp3 = true;
9208 }
9209 {
9210 PyThreadState* __tstate = wxPyBeginAllowThreads();
9211 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9212
9213 wxPyEndAllowThreads(__tstate);
9214 if (PyErr_Occurred()) SWIG_fail;
9215 }
9216 {
9217 resultobj = wxPyMake_wxObject(result, 1);
9218 }
9219 {
9220 if (temp3)
9221 delete arg3;
9222 }
9223 return resultobj;
9224 fail:
9225 {
9226 if (temp3)
9227 delete arg3;
9228 }
9229 return NULL;
9230 }
9231
9232
9233 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9234 PyObject *obj;
9235 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9236 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9237 Py_INCREF(obj);
9238 return Py_BuildValue((char *)"");
9239 }
9240 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9241 PyObject *resultobj;
9242 wxZipFSHandler *result;
9243 char *kwnames[] = {
9244 NULL
9245 };
9246
9247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9248 {
9249 PyThreadState* __tstate = wxPyBeginAllowThreads();
9250 result = (wxZipFSHandler *)new wxZipFSHandler();
9251
9252 wxPyEndAllowThreads(__tstate);
9253 if (PyErr_Occurred()) SWIG_fail;
9254 }
9255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9256 return resultobj;
9257 fail:
9258 return NULL;
9259 }
9260
9261
9262 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9263 PyObject *resultobj;
9264 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9265 wxString *arg2 = 0 ;
9266 bool result;
9267 bool temp2 = false ;
9268 PyObject * obj0 = 0 ;
9269 PyObject * obj1 = 0 ;
9270 char *kwnames[] = {
9271 (char *) "self",(char *) "location", NULL
9272 };
9273
9274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9276 if (SWIG_arg_fail(1)) SWIG_fail;
9277 {
9278 arg2 = wxString_in_helper(obj1);
9279 if (arg2 == NULL) SWIG_fail;
9280 temp2 = true;
9281 }
9282 {
9283 PyThreadState* __tstate = wxPyBeginAllowThreads();
9284 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9285
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 {
9290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9291 }
9292 {
9293 if (temp2)
9294 delete arg2;
9295 }
9296 return resultobj;
9297 fail:
9298 {
9299 if (temp2)
9300 delete arg2;
9301 }
9302 return NULL;
9303 }
9304
9305
9306 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9307 PyObject *resultobj;
9308 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9309 wxFileSystem *arg2 = 0 ;
9310 wxString *arg3 = 0 ;
9311 wxFSFile *result;
9312 bool temp3 = false ;
9313 PyObject * obj0 = 0 ;
9314 PyObject * obj1 = 0 ;
9315 PyObject * obj2 = 0 ;
9316 char *kwnames[] = {
9317 (char *) "self",(char *) "fs",(char *) "location", NULL
9318 };
9319
9320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9322 if (SWIG_arg_fail(1)) SWIG_fail;
9323 {
9324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9325 if (SWIG_arg_fail(2)) SWIG_fail;
9326 if (arg2 == NULL) {
9327 SWIG_null_ref("wxFileSystem");
9328 }
9329 if (SWIG_arg_fail(2)) SWIG_fail;
9330 }
9331 {
9332 arg3 = wxString_in_helper(obj2);
9333 if (arg3 == NULL) SWIG_fail;
9334 temp3 = true;
9335 }
9336 {
9337 PyThreadState* __tstate = wxPyBeginAllowThreads();
9338 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9339
9340 wxPyEndAllowThreads(__tstate);
9341 if (PyErr_Occurred()) SWIG_fail;
9342 }
9343 {
9344 resultobj = wxPyMake_wxObject(result, 1);
9345 }
9346 {
9347 if (temp3)
9348 delete arg3;
9349 }
9350 return resultobj;
9351 fail:
9352 {
9353 if (temp3)
9354 delete arg3;
9355 }
9356 return NULL;
9357 }
9358
9359
9360 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9361 PyObject *resultobj;
9362 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9363 wxString *arg2 = 0 ;
9364 int arg3 = (int) 0 ;
9365 wxString result;
9366 bool temp2 = false ;
9367 PyObject * obj0 = 0 ;
9368 PyObject * obj1 = 0 ;
9369 PyObject * obj2 = 0 ;
9370 char *kwnames[] = {
9371 (char *) "self",(char *) "spec",(char *) "flags", NULL
9372 };
9373
9374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9376 if (SWIG_arg_fail(1)) SWIG_fail;
9377 {
9378 arg2 = wxString_in_helper(obj1);
9379 if (arg2 == NULL) SWIG_fail;
9380 temp2 = true;
9381 }
9382 if (obj2) {
9383 {
9384 arg3 = (int)(SWIG_As_int(obj2));
9385 if (SWIG_arg_fail(3)) SWIG_fail;
9386 }
9387 }
9388 {
9389 PyThreadState* __tstate = wxPyBeginAllowThreads();
9390 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9391
9392 wxPyEndAllowThreads(__tstate);
9393 if (PyErr_Occurred()) SWIG_fail;
9394 }
9395 {
9396 #if wxUSE_UNICODE
9397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9398 #else
9399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9400 #endif
9401 }
9402 {
9403 if (temp2)
9404 delete arg2;
9405 }
9406 return resultobj;
9407 fail:
9408 {
9409 if (temp2)
9410 delete arg2;
9411 }
9412 return NULL;
9413 }
9414
9415
9416 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9417 PyObject *resultobj;
9418 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9419 wxString result;
9420 PyObject * obj0 = 0 ;
9421 char *kwnames[] = {
9422 (char *) "self", NULL
9423 };
9424
9425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9427 if (SWIG_arg_fail(1)) SWIG_fail;
9428 {
9429 PyThreadState* __tstate = wxPyBeginAllowThreads();
9430 result = (arg1)->FindNext();
9431
9432 wxPyEndAllowThreads(__tstate);
9433 if (PyErr_Occurred()) SWIG_fail;
9434 }
9435 {
9436 #if wxUSE_UNICODE
9437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9438 #else
9439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9440 #endif
9441 }
9442 return resultobj;
9443 fail:
9444 return NULL;
9445 }
9446
9447
9448 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9449 PyObject *obj;
9450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9451 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9452 Py_INCREF(obj);
9453 return Py_BuildValue((char *)"");
9454 }
9455 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9456 PyObject *resultobj;
9457 wxString *arg1 = 0 ;
9458 wxImage *arg2 = 0 ;
9459 long arg3 ;
9460 bool temp1 = false ;
9461 PyObject * obj0 = 0 ;
9462 PyObject * obj1 = 0 ;
9463 PyObject * obj2 = 0 ;
9464 char *kwnames[] = {
9465 (char *) "filename",(char *) "image",(char *) "type", NULL
9466 };
9467
9468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9469 {
9470 arg1 = wxString_in_helper(obj0);
9471 if (arg1 == NULL) SWIG_fail;
9472 temp1 = true;
9473 }
9474 {
9475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9476 if (SWIG_arg_fail(2)) SWIG_fail;
9477 if (arg2 == NULL) {
9478 SWIG_null_ref("wxImage");
9479 }
9480 if (SWIG_arg_fail(2)) SWIG_fail;
9481 }
9482 {
9483 arg3 = (long)(SWIG_As_long(obj2));
9484 if (SWIG_arg_fail(3)) SWIG_fail;
9485 }
9486 {
9487 PyThreadState* __tstate = wxPyBeginAllowThreads();
9488 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9489
9490 wxPyEndAllowThreads(__tstate);
9491 if (PyErr_Occurred()) SWIG_fail;
9492 }
9493 Py_INCREF(Py_None); resultobj = Py_None;
9494 {
9495 if (temp1)
9496 delete arg1;
9497 }
9498 return resultobj;
9499 fail:
9500 {
9501 if (temp1)
9502 delete arg1;
9503 }
9504 return NULL;
9505 }
9506
9507
9508 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9509 PyObject *resultobj;
9510 wxString *arg1 = 0 ;
9511 wxBitmap *arg2 = 0 ;
9512 long arg3 ;
9513 bool temp1 = false ;
9514 PyObject * obj0 = 0 ;
9515 PyObject * obj1 = 0 ;
9516 PyObject * obj2 = 0 ;
9517 char *kwnames[] = {
9518 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9519 };
9520
9521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9522 {
9523 arg1 = wxString_in_helper(obj0);
9524 if (arg1 == NULL) SWIG_fail;
9525 temp1 = true;
9526 }
9527 {
9528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9529 if (SWIG_arg_fail(2)) SWIG_fail;
9530 if (arg2 == NULL) {
9531 SWIG_null_ref("wxBitmap");
9532 }
9533 if (SWIG_arg_fail(2)) SWIG_fail;
9534 }
9535 {
9536 arg3 = (long)(SWIG_As_long(obj2));
9537 if (SWIG_arg_fail(3)) SWIG_fail;
9538 }
9539 {
9540 PyThreadState* __tstate = wxPyBeginAllowThreads();
9541 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9542
9543 wxPyEndAllowThreads(__tstate);
9544 if (PyErr_Occurred()) SWIG_fail;
9545 }
9546 Py_INCREF(Py_None); resultobj = Py_None;
9547 {
9548 if (temp1)
9549 delete arg1;
9550 }
9551 return resultobj;
9552 fail:
9553 {
9554 if (temp1)
9555 delete arg1;
9556 }
9557 return NULL;
9558 }
9559
9560
9561 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9562 PyObject *resultobj;
9563 wxString *arg1 = 0 ;
9564 PyObject *arg2 = (PyObject *) 0 ;
9565 bool temp1 = false ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 char *kwnames[] = {
9569 (char *) "filename",(char *) "data", NULL
9570 };
9571
9572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9573 {
9574 arg1 = wxString_in_helper(obj0);
9575 if (arg1 == NULL) SWIG_fail;
9576 temp1 = true;
9577 }
9578 arg2 = obj1;
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9582
9583 wxPyEndAllowThreads(__tstate);
9584 if (PyErr_Occurred()) SWIG_fail;
9585 }
9586 Py_INCREF(Py_None); resultobj = Py_None;
9587 {
9588 if (temp1)
9589 delete arg1;
9590 }
9591 return resultobj;
9592 fail:
9593 {
9594 if (temp1)
9595 delete arg1;
9596 }
9597 return NULL;
9598 }
9599
9600
9601 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9602 PyObject *resultobj;
9603 wxMemoryFSHandler *result;
9604 char *kwnames[] = {
9605 NULL
9606 };
9607
9608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9609 {
9610 PyThreadState* __tstate = wxPyBeginAllowThreads();
9611 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9612
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9617 return resultobj;
9618 fail:
9619 return NULL;
9620 }
9621
9622
9623 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9624 PyObject *resultobj;
9625 wxString *arg1 = 0 ;
9626 bool temp1 = false ;
9627 PyObject * obj0 = 0 ;
9628 char *kwnames[] = {
9629 (char *) "filename", NULL
9630 };
9631
9632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9633 {
9634 arg1 = wxString_in_helper(obj0);
9635 if (arg1 == NULL) SWIG_fail;
9636 temp1 = true;
9637 }
9638 {
9639 PyThreadState* __tstate = wxPyBeginAllowThreads();
9640 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9641
9642 wxPyEndAllowThreads(__tstate);
9643 if (PyErr_Occurred()) SWIG_fail;
9644 }
9645 Py_INCREF(Py_None); resultobj = Py_None;
9646 {
9647 if (temp1)
9648 delete arg1;
9649 }
9650 return resultobj;
9651 fail:
9652 {
9653 if (temp1)
9654 delete arg1;
9655 }
9656 return NULL;
9657 }
9658
9659
9660 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9661 PyObject *resultobj;
9662 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9663 wxString *arg2 = 0 ;
9664 bool result;
9665 bool temp2 = false ;
9666 PyObject * obj0 = 0 ;
9667 PyObject * obj1 = 0 ;
9668 char *kwnames[] = {
9669 (char *) "self",(char *) "location", NULL
9670 };
9671
9672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9674 if (SWIG_arg_fail(1)) SWIG_fail;
9675 {
9676 arg2 = wxString_in_helper(obj1);
9677 if (arg2 == NULL) SWIG_fail;
9678 temp2 = true;
9679 }
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9683
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 {
9688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9689 }
9690 {
9691 if (temp2)
9692 delete arg2;
9693 }
9694 return resultobj;
9695 fail:
9696 {
9697 if (temp2)
9698 delete arg2;
9699 }
9700 return NULL;
9701 }
9702
9703
9704 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9705 PyObject *resultobj;
9706 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9707 wxFileSystem *arg2 = 0 ;
9708 wxString *arg3 = 0 ;
9709 wxFSFile *result;
9710 bool temp3 = false ;
9711 PyObject * obj0 = 0 ;
9712 PyObject * obj1 = 0 ;
9713 PyObject * obj2 = 0 ;
9714 char *kwnames[] = {
9715 (char *) "self",(char *) "fs",(char *) "location", NULL
9716 };
9717
9718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9720 if (SWIG_arg_fail(1)) SWIG_fail;
9721 {
9722 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9723 if (SWIG_arg_fail(2)) SWIG_fail;
9724 if (arg2 == NULL) {
9725 SWIG_null_ref("wxFileSystem");
9726 }
9727 if (SWIG_arg_fail(2)) SWIG_fail;
9728 }
9729 {
9730 arg3 = wxString_in_helper(obj2);
9731 if (arg3 == NULL) SWIG_fail;
9732 temp3 = true;
9733 }
9734 {
9735 PyThreadState* __tstate = wxPyBeginAllowThreads();
9736 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9737
9738 wxPyEndAllowThreads(__tstate);
9739 if (PyErr_Occurred()) SWIG_fail;
9740 }
9741 {
9742 resultobj = wxPyMake_wxObject(result, 1);
9743 }
9744 {
9745 if (temp3)
9746 delete arg3;
9747 }
9748 return resultobj;
9749 fail:
9750 {
9751 if (temp3)
9752 delete arg3;
9753 }
9754 return NULL;
9755 }
9756
9757
9758 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9759 PyObject *resultobj;
9760 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9761 wxString *arg2 = 0 ;
9762 int arg3 = (int) 0 ;
9763 wxString result;
9764 bool temp2 = false ;
9765 PyObject * obj0 = 0 ;
9766 PyObject * obj1 = 0 ;
9767 PyObject * obj2 = 0 ;
9768 char *kwnames[] = {
9769 (char *) "self",(char *) "spec",(char *) "flags", NULL
9770 };
9771
9772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9774 if (SWIG_arg_fail(1)) SWIG_fail;
9775 {
9776 arg2 = wxString_in_helper(obj1);
9777 if (arg2 == NULL) SWIG_fail;
9778 temp2 = true;
9779 }
9780 if (obj2) {
9781 {
9782 arg3 = (int)(SWIG_As_int(obj2));
9783 if (SWIG_arg_fail(3)) SWIG_fail;
9784 }
9785 }
9786 {
9787 PyThreadState* __tstate = wxPyBeginAllowThreads();
9788 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9789
9790 wxPyEndAllowThreads(__tstate);
9791 if (PyErr_Occurred()) SWIG_fail;
9792 }
9793 {
9794 #if wxUSE_UNICODE
9795 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9796 #else
9797 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9798 #endif
9799 }
9800 {
9801 if (temp2)
9802 delete arg2;
9803 }
9804 return resultobj;
9805 fail:
9806 {
9807 if (temp2)
9808 delete arg2;
9809 }
9810 return NULL;
9811 }
9812
9813
9814 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9815 PyObject *resultobj;
9816 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9817 wxString result;
9818 PyObject * obj0 = 0 ;
9819 char *kwnames[] = {
9820 (char *) "self", NULL
9821 };
9822
9823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9825 if (SWIG_arg_fail(1)) SWIG_fail;
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 result = (arg1)->FindNext();
9829
9830 wxPyEndAllowThreads(__tstate);
9831 if (PyErr_Occurred()) SWIG_fail;
9832 }
9833 {
9834 #if wxUSE_UNICODE
9835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9836 #else
9837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9838 #endif
9839 }
9840 return resultobj;
9841 fail:
9842 return NULL;
9843 }
9844
9845
9846 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9847 PyObject *obj;
9848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9849 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9850 Py_INCREF(obj);
9851 return Py_BuildValue((char *)"");
9852 }
9853 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9854 PyObject *resultobj;
9855 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9856 wxString result;
9857 PyObject * obj0 = 0 ;
9858 char *kwnames[] = {
9859 (char *) "self", NULL
9860 };
9861
9862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9864 if (SWIG_arg_fail(1)) SWIG_fail;
9865 {
9866 PyThreadState* __tstate = wxPyBeginAllowThreads();
9867 result = (arg1)->GetName();
9868
9869 wxPyEndAllowThreads(__tstate);
9870 if (PyErr_Occurred()) SWIG_fail;
9871 }
9872 {
9873 #if wxUSE_UNICODE
9874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9875 #else
9876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9877 #endif
9878 }
9879 return resultobj;
9880 fail:
9881 return NULL;
9882 }
9883
9884
9885 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9886 PyObject *resultobj;
9887 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9888 wxString result;
9889 PyObject * obj0 = 0 ;
9890 char *kwnames[] = {
9891 (char *) "self", NULL
9892 };
9893
9894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9896 if (SWIG_arg_fail(1)) SWIG_fail;
9897 {
9898 PyThreadState* __tstate = wxPyBeginAllowThreads();
9899 result = (arg1)->GetExtension();
9900
9901 wxPyEndAllowThreads(__tstate);
9902 if (PyErr_Occurred()) SWIG_fail;
9903 }
9904 {
9905 #if wxUSE_UNICODE
9906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9907 #else
9908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9909 #endif
9910 }
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9918 PyObject *resultobj;
9919 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9920 long result;
9921 PyObject * obj0 = 0 ;
9922 char *kwnames[] = {
9923 (char *) "self", NULL
9924 };
9925
9926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9928 if (SWIG_arg_fail(1)) SWIG_fail;
9929 {
9930 PyThreadState* __tstate = wxPyBeginAllowThreads();
9931 result = (long)(arg1)->GetType();
9932
9933 wxPyEndAllowThreads(__tstate);
9934 if (PyErr_Occurred()) SWIG_fail;
9935 }
9936 {
9937 resultobj = SWIG_From_long((long)(result));
9938 }
9939 return resultobj;
9940 fail:
9941 return NULL;
9942 }
9943
9944
9945 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9946 PyObject *resultobj;
9947 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9948 wxString result;
9949 PyObject * obj0 = 0 ;
9950 char *kwnames[] = {
9951 (char *) "self", NULL
9952 };
9953
9954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9956 if (SWIG_arg_fail(1)) SWIG_fail;
9957 {
9958 PyThreadState* __tstate = wxPyBeginAllowThreads();
9959 result = (arg1)->GetMimeType();
9960
9961 wxPyEndAllowThreads(__tstate);
9962 if (PyErr_Occurred()) SWIG_fail;
9963 }
9964 {
9965 #if wxUSE_UNICODE
9966 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9967 #else
9968 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9969 #endif
9970 }
9971 return resultobj;
9972 fail:
9973 return NULL;
9974 }
9975
9976
9977 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9978 PyObject *resultobj;
9979 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9980 wxString *arg2 = 0 ;
9981 bool result;
9982 bool temp2 = false ;
9983 PyObject * obj0 = 0 ;
9984 PyObject * obj1 = 0 ;
9985 char *kwnames[] = {
9986 (char *) "self",(char *) "name", NULL
9987 };
9988
9989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9991 if (SWIG_arg_fail(1)) SWIG_fail;
9992 {
9993 arg2 = wxString_in_helper(obj1);
9994 if (arg2 == NULL) SWIG_fail;
9995 temp2 = true;
9996 }
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10000
10001 wxPyEndAllowThreads(__tstate);
10002 if (PyErr_Occurred()) SWIG_fail;
10003 }
10004 {
10005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10006 }
10007 {
10008 if (temp2)
10009 delete arg2;
10010 }
10011 return resultobj;
10012 fail:
10013 {
10014 if (temp2)
10015 delete arg2;
10016 }
10017 return NULL;
10018 }
10019
10020
10021 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10022 PyObject *resultobj;
10023 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10024 wxString *arg2 = 0 ;
10025 bool temp2 = false ;
10026 PyObject * obj0 = 0 ;
10027 PyObject * obj1 = 0 ;
10028 char *kwnames[] = {
10029 (char *) "self",(char *) "name", NULL
10030 };
10031
10032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10034 if (SWIG_arg_fail(1)) SWIG_fail;
10035 {
10036 arg2 = wxString_in_helper(obj1);
10037 if (arg2 == NULL) SWIG_fail;
10038 temp2 = true;
10039 }
10040 {
10041 PyThreadState* __tstate = wxPyBeginAllowThreads();
10042 (arg1)->SetName((wxString const &)*arg2);
10043
10044 wxPyEndAllowThreads(__tstate);
10045 if (PyErr_Occurred()) SWIG_fail;
10046 }
10047 Py_INCREF(Py_None); resultobj = Py_None;
10048 {
10049 if (temp2)
10050 delete arg2;
10051 }
10052 return resultobj;
10053 fail:
10054 {
10055 if (temp2)
10056 delete arg2;
10057 }
10058 return NULL;
10059 }
10060
10061
10062 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10063 PyObject *resultobj;
10064 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10065 wxString *arg2 = 0 ;
10066 bool temp2 = false ;
10067 PyObject * obj0 = 0 ;
10068 PyObject * obj1 = 0 ;
10069 char *kwnames[] = {
10070 (char *) "self",(char *) "extension", NULL
10071 };
10072
10073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10075 if (SWIG_arg_fail(1)) SWIG_fail;
10076 {
10077 arg2 = wxString_in_helper(obj1);
10078 if (arg2 == NULL) SWIG_fail;
10079 temp2 = true;
10080 }
10081 {
10082 PyThreadState* __tstate = wxPyBeginAllowThreads();
10083 (arg1)->SetExtension((wxString const &)*arg2);
10084
10085 wxPyEndAllowThreads(__tstate);
10086 if (PyErr_Occurred()) SWIG_fail;
10087 }
10088 Py_INCREF(Py_None); resultobj = Py_None;
10089 {
10090 if (temp2)
10091 delete arg2;
10092 }
10093 return resultobj;
10094 fail:
10095 {
10096 if (temp2)
10097 delete arg2;
10098 }
10099 return NULL;
10100 }
10101
10102
10103 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj;
10105 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10106 long arg2 ;
10107 PyObject * obj0 = 0 ;
10108 PyObject * obj1 = 0 ;
10109 char *kwnames[] = {
10110 (char *) "self",(char *) "type", NULL
10111 };
10112
10113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10115 if (SWIG_arg_fail(1)) SWIG_fail;
10116 {
10117 arg2 = (long)(SWIG_As_long(obj1));
10118 if (SWIG_arg_fail(2)) SWIG_fail;
10119 }
10120 {
10121 PyThreadState* __tstate = wxPyBeginAllowThreads();
10122 (arg1)->SetType(arg2);
10123
10124 wxPyEndAllowThreads(__tstate);
10125 if (PyErr_Occurred()) SWIG_fail;
10126 }
10127 Py_INCREF(Py_None); resultobj = Py_None;
10128 return resultobj;
10129 fail:
10130 return NULL;
10131 }
10132
10133
10134 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10135 PyObject *resultobj;
10136 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10137 wxString *arg2 = 0 ;
10138 bool temp2 = false ;
10139 PyObject * obj0 = 0 ;
10140 PyObject * obj1 = 0 ;
10141 char *kwnames[] = {
10142 (char *) "self",(char *) "mimetype", NULL
10143 };
10144
10145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10147 if (SWIG_arg_fail(1)) SWIG_fail;
10148 {
10149 arg2 = wxString_in_helper(obj1);
10150 if (arg2 == NULL) SWIG_fail;
10151 temp2 = true;
10152 }
10153 {
10154 PyThreadState* __tstate = wxPyBeginAllowThreads();
10155 (arg1)->SetMimeType((wxString const &)*arg2);
10156
10157 wxPyEndAllowThreads(__tstate);
10158 if (PyErr_Occurred()) SWIG_fail;
10159 }
10160 Py_INCREF(Py_None); resultobj = Py_None;
10161 {
10162 if (temp2)
10163 delete arg2;
10164 }
10165 return resultobj;
10166 fail:
10167 {
10168 if (temp2)
10169 delete arg2;
10170 }
10171 return NULL;
10172 }
10173
10174
10175 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10176 PyObject *obj;
10177 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10178 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10179 Py_INCREF(obj);
10180 return Py_BuildValue((char *)"");
10181 }
10182 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10183 PyObject *resultobj;
10184 wxImageHistogram *result;
10185 char *kwnames[] = {
10186 NULL
10187 };
10188
10189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10190 {
10191 PyThreadState* __tstate = wxPyBeginAllowThreads();
10192 result = (wxImageHistogram *)new wxImageHistogram();
10193
10194 wxPyEndAllowThreads(__tstate);
10195 if (PyErr_Occurred()) SWIG_fail;
10196 }
10197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10198 return resultobj;
10199 fail:
10200 return NULL;
10201 }
10202
10203
10204 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10205 PyObject *resultobj;
10206 unsigned char arg1 ;
10207 unsigned char arg2 ;
10208 unsigned char arg3 ;
10209 unsigned long result;
10210 PyObject * obj0 = 0 ;
10211 PyObject * obj1 = 0 ;
10212 PyObject * obj2 = 0 ;
10213 char *kwnames[] = {
10214 (char *) "r",(char *) "g",(char *) "b", NULL
10215 };
10216
10217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10218 {
10219 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10220 if (SWIG_arg_fail(1)) SWIG_fail;
10221 }
10222 {
10223 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10224 if (SWIG_arg_fail(2)) SWIG_fail;
10225 }
10226 {
10227 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10228 if (SWIG_arg_fail(3)) SWIG_fail;
10229 }
10230 {
10231 PyThreadState* __tstate = wxPyBeginAllowThreads();
10232 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10233
10234 wxPyEndAllowThreads(__tstate);
10235 if (PyErr_Occurred()) SWIG_fail;
10236 }
10237 {
10238 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10239 }
10240 return resultobj;
10241 fail:
10242 return NULL;
10243 }
10244
10245
10246 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10247 PyObject *resultobj;
10248 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10249 unsigned char *arg2 = (unsigned char *) 0 ;
10250 unsigned char *arg3 = (unsigned char *) 0 ;
10251 unsigned char *arg4 = (unsigned char *) 0 ;
10252 unsigned char arg5 = (unsigned char) 1 ;
10253 unsigned char arg6 = (unsigned char) 0 ;
10254 unsigned char arg7 = (unsigned char) 0 ;
10255 bool result;
10256 unsigned char temp2 ;
10257 int res2 = 0 ;
10258 unsigned char temp3 ;
10259 int res3 = 0 ;
10260 unsigned char temp4 ;
10261 int res4 = 0 ;
10262 PyObject * obj0 = 0 ;
10263 PyObject * obj1 = 0 ;
10264 PyObject * obj2 = 0 ;
10265 PyObject * obj3 = 0 ;
10266 char *kwnames[] = {
10267 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10268 };
10269
10270 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10271 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10272 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10275 if (SWIG_arg_fail(1)) SWIG_fail;
10276 if (obj1) {
10277 {
10278 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10279 if (SWIG_arg_fail(5)) SWIG_fail;
10280 }
10281 }
10282 if (obj2) {
10283 {
10284 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10285 if (SWIG_arg_fail(6)) SWIG_fail;
10286 }
10287 }
10288 if (obj3) {
10289 {
10290 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10291 if (SWIG_arg_fail(7)) SWIG_fail;
10292 }
10293 }
10294 {
10295 PyThreadState* __tstate = wxPyBeginAllowThreads();
10296 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10297
10298 wxPyEndAllowThreads(__tstate);
10299 if (PyErr_Occurred()) SWIG_fail;
10300 }
10301 {
10302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10303 }
10304 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10305 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10306 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10307 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10308 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10309 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10310 return resultobj;
10311 fail:
10312 return NULL;
10313 }
10314
10315
10316 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10317 PyObject *obj;
10318 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10319 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10320 Py_INCREF(obj);
10321 return Py_BuildValue((char *)"");
10322 }
10323 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10324 PyObject *resultobj;
10325 wxString *arg1 = 0 ;
10326 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10327 int arg3 = (int) -1 ;
10328 wxImage *result;
10329 bool temp1 = false ;
10330 PyObject * obj0 = 0 ;
10331 PyObject * obj1 = 0 ;
10332 PyObject * obj2 = 0 ;
10333 char *kwnames[] = {
10334 (char *) "name",(char *) "type",(char *) "index", NULL
10335 };
10336
10337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10338 {
10339 arg1 = wxString_in_helper(obj0);
10340 if (arg1 == NULL) SWIG_fail;
10341 temp1 = true;
10342 }
10343 if (obj1) {
10344 {
10345 arg2 = (long)(SWIG_As_long(obj1));
10346 if (SWIG_arg_fail(2)) SWIG_fail;
10347 }
10348 }
10349 if (obj2) {
10350 {
10351 arg3 = (int)(SWIG_As_int(obj2));
10352 if (SWIG_arg_fail(3)) SWIG_fail;
10353 }
10354 }
10355 {
10356 PyThreadState* __tstate = wxPyBeginAllowThreads();
10357 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10358
10359 wxPyEndAllowThreads(__tstate);
10360 if (PyErr_Occurred()) SWIG_fail;
10361 }
10362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10363 {
10364 if (temp1)
10365 delete arg1;
10366 }
10367 return resultobj;
10368 fail:
10369 {
10370 if (temp1)
10371 delete arg1;
10372 }
10373 return NULL;
10374 }
10375
10376
10377 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10378 PyObject *resultobj;
10379 wxImage *arg1 = (wxImage *) 0 ;
10380 PyObject * obj0 = 0 ;
10381 char *kwnames[] = {
10382 (char *) "self", NULL
10383 };
10384
10385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10387 if (SWIG_arg_fail(1)) SWIG_fail;
10388 {
10389 PyThreadState* __tstate = wxPyBeginAllowThreads();
10390 delete arg1;
10391
10392 wxPyEndAllowThreads(__tstate);
10393 if (PyErr_Occurred()) SWIG_fail;
10394 }
10395 Py_INCREF(Py_None); resultobj = Py_None;
10396 return resultobj;
10397 fail:
10398 return NULL;
10399 }
10400
10401
10402 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10403 PyObject *resultobj;
10404 wxString *arg1 = 0 ;
10405 wxString *arg2 = 0 ;
10406 int arg3 = (int) -1 ;
10407 wxImage *result;
10408 bool temp1 = false ;
10409 bool temp2 = false ;
10410 PyObject * obj0 = 0 ;
10411 PyObject * obj1 = 0 ;
10412 PyObject * obj2 = 0 ;
10413 char *kwnames[] = {
10414 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10415 };
10416
10417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10418 {
10419 arg1 = wxString_in_helper(obj0);
10420 if (arg1 == NULL) SWIG_fail;
10421 temp1 = true;
10422 }
10423 {
10424 arg2 = wxString_in_helper(obj1);
10425 if (arg2 == NULL) SWIG_fail;
10426 temp2 = true;
10427 }
10428 if (obj2) {
10429 {
10430 arg3 = (int)(SWIG_As_int(obj2));
10431 if (SWIG_arg_fail(3)) SWIG_fail;
10432 }
10433 }
10434 {
10435 PyThreadState* __tstate = wxPyBeginAllowThreads();
10436 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10437
10438 wxPyEndAllowThreads(__tstate);
10439 if (PyErr_Occurred()) SWIG_fail;
10440 }
10441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10442 {
10443 if (temp1)
10444 delete arg1;
10445 }
10446 {
10447 if (temp2)
10448 delete arg2;
10449 }
10450 return resultobj;
10451 fail:
10452 {
10453 if (temp1)
10454 delete arg1;
10455 }
10456 {
10457 if (temp2)
10458 delete arg2;
10459 }
10460 return NULL;
10461 }
10462
10463
10464 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10465 PyObject *resultobj;
10466 wxInputStream *arg1 = 0 ;
10467 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10468 int arg3 = (int) -1 ;
10469 wxImage *result;
10470 wxPyInputStream *temp1 ;
10471 bool created1 ;
10472 PyObject * obj0 = 0 ;
10473 PyObject * obj1 = 0 ;
10474 PyObject * obj2 = 0 ;
10475 char *kwnames[] = {
10476 (char *) "stream",(char *) "type",(char *) "index", NULL
10477 };
10478
10479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10480 {
10481 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10482 arg1 = temp1->m_wxis;
10483 created1 = false;
10484 } else {
10485 PyErr_Clear(); // clear the failure of the wxPyConvert above
10486 arg1 = wxPyCBInputStream_create(obj0, false);
10487 if (arg1 == NULL) {
10488 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10489 SWIG_fail;
10490 }
10491 created1 = true;
10492 }
10493 }
10494 if (obj1) {
10495 {
10496 arg2 = (long)(SWIG_As_long(obj1));
10497 if (SWIG_arg_fail(2)) SWIG_fail;
10498 }
10499 }
10500 if (obj2) {
10501 {
10502 arg3 = (int)(SWIG_As_int(obj2));
10503 if (SWIG_arg_fail(3)) SWIG_fail;
10504 }
10505 }
10506 {
10507 PyThreadState* __tstate = wxPyBeginAllowThreads();
10508 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10509
10510 wxPyEndAllowThreads(__tstate);
10511 if (PyErr_Occurred()) SWIG_fail;
10512 }
10513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10514 {
10515 if (created1)
10516 delete arg1;
10517 }
10518 return resultobj;
10519 fail:
10520 {
10521 if (created1)
10522 delete arg1;
10523 }
10524 return NULL;
10525 }
10526
10527
10528 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10529 PyObject *resultobj;
10530 wxInputStream *arg1 = 0 ;
10531 wxString *arg2 = 0 ;
10532 int arg3 = (int) -1 ;
10533 wxImage *result;
10534 wxPyInputStream *temp1 ;
10535 bool created1 ;
10536 bool temp2 = false ;
10537 PyObject * obj0 = 0 ;
10538 PyObject * obj1 = 0 ;
10539 PyObject * obj2 = 0 ;
10540 char *kwnames[] = {
10541 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10542 };
10543
10544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10545 {
10546 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10547 arg1 = temp1->m_wxis;
10548 created1 = false;
10549 } else {
10550 PyErr_Clear(); // clear the failure of the wxPyConvert above
10551 arg1 = wxPyCBInputStream_create(obj0, false);
10552 if (arg1 == NULL) {
10553 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10554 SWIG_fail;
10555 }
10556 created1 = true;
10557 }
10558 }
10559 {
10560 arg2 = wxString_in_helper(obj1);
10561 if (arg2 == NULL) SWIG_fail;
10562 temp2 = true;
10563 }
10564 if (obj2) {
10565 {
10566 arg3 = (int)(SWIG_As_int(obj2));
10567 if (SWIG_arg_fail(3)) SWIG_fail;
10568 }
10569 }
10570 {
10571 PyThreadState* __tstate = wxPyBeginAllowThreads();
10572 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10573
10574 wxPyEndAllowThreads(__tstate);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10578 {
10579 if (created1)
10580 delete arg1;
10581 }
10582 {
10583 if (temp2)
10584 delete arg2;
10585 }
10586 return resultobj;
10587 fail:
10588 {
10589 if (created1)
10590 delete arg1;
10591 }
10592 {
10593 if (temp2)
10594 delete arg2;
10595 }
10596 return NULL;
10597 }
10598
10599
10600 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10601 PyObject *resultobj;
10602 int arg1 = (int) 0 ;
10603 int arg2 = (int) 0 ;
10604 bool arg3 = (bool) true ;
10605 wxImage *result;
10606 PyObject * obj0 = 0 ;
10607 PyObject * obj1 = 0 ;
10608 PyObject * obj2 = 0 ;
10609 char *kwnames[] = {
10610 (char *) "width",(char *) "height",(char *) "clear", NULL
10611 };
10612
10613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10614 if (obj0) {
10615 {
10616 arg1 = (int)(SWIG_As_int(obj0));
10617 if (SWIG_arg_fail(1)) SWIG_fail;
10618 }
10619 }
10620 if (obj1) {
10621 {
10622 arg2 = (int)(SWIG_As_int(obj1));
10623 if (SWIG_arg_fail(2)) SWIG_fail;
10624 }
10625 }
10626 if (obj2) {
10627 {
10628 arg3 = (bool)(SWIG_As_bool(obj2));
10629 if (SWIG_arg_fail(3)) SWIG_fail;
10630 }
10631 }
10632 {
10633 PyThreadState* __tstate = wxPyBeginAllowThreads();
10634 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10635
10636 wxPyEndAllowThreads(__tstate);
10637 if (PyErr_Occurred()) SWIG_fail;
10638 }
10639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10640 return resultobj;
10641 fail:
10642 return NULL;
10643 }
10644
10645
10646 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10647 PyObject *resultobj;
10648 wxBitmap *arg1 = 0 ;
10649 wxImage *result;
10650 PyObject * obj0 = 0 ;
10651 char *kwnames[] = {
10652 (char *) "bitmap", NULL
10653 };
10654
10655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10656 {
10657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10658 if (SWIG_arg_fail(1)) SWIG_fail;
10659 if (arg1 == NULL) {
10660 SWIG_null_ref("wxBitmap");
10661 }
10662 if (SWIG_arg_fail(1)) SWIG_fail;
10663 }
10664 {
10665 if (!wxPyCheckForApp()) SWIG_fail;
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10668
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10680 PyObject *resultobj;
10681 int arg1 ;
10682 int arg2 ;
10683 unsigned char *arg3 = (unsigned char *) 0 ;
10684 wxImage *result;
10685 PyObject * obj0 = 0 ;
10686 PyObject * obj1 = 0 ;
10687 PyObject * obj2 = 0 ;
10688 char *kwnames[] = {
10689 (char *) "width",(char *) "height",(char *) "data", NULL
10690 };
10691
10692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10693 {
10694 arg1 = (int)(SWIG_As_int(obj0));
10695 if (SWIG_arg_fail(1)) SWIG_fail;
10696 }
10697 {
10698 arg2 = (int)(SWIG_As_int(obj1));
10699 if (SWIG_arg_fail(2)) SWIG_fail;
10700 }
10701 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10702 if (SWIG_arg_fail(3)) SWIG_fail;
10703 {
10704 PyThreadState* __tstate = wxPyBeginAllowThreads();
10705 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10706
10707 wxPyEndAllowThreads(__tstate);
10708 if (PyErr_Occurred()) SWIG_fail;
10709 }
10710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10711 return resultobj;
10712 fail:
10713 return NULL;
10714 }
10715
10716
10717 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10718 PyObject *resultobj;
10719 int arg1 ;
10720 int arg2 ;
10721 unsigned char *arg3 = (unsigned char *) 0 ;
10722 unsigned char *arg4 = (unsigned char *) 0 ;
10723 wxImage *result;
10724 PyObject * obj0 = 0 ;
10725 PyObject * obj1 = 0 ;
10726 PyObject * obj2 = 0 ;
10727 PyObject * obj3 = 0 ;
10728 char *kwnames[] = {
10729 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10730 };
10731
10732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10733 {
10734 arg1 = (int)(SWIG_As_int(obj0));
10735 if (SWIG_arg_fail(1)) SWIG_fail;
10736 }
10737 {
10738 arg2 = (int)(SWIG_As_int(obj1));
10739 if (SWIG_arg_fail(2)) SWIG_fail;
10740 }
10741 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10742 if (SWIG_arg_fail(3)) SWIG_fail;
10743 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10744 if (SWIG_arg_fail(4)) SWIG_fail;
10745 {
10746 PyThreadState* __tstate = wxPyBeginAllowThreads();
10747 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10748
10749 wxPyEndAllowThreads(__tstate);
10750 if (PyErr_Occurred()) SWIG_fail;
10751 }
10752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10753 return resultobj;
10754 fail:
10755 return NULL;
10756 }
10757
10758
10759 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10760 PyObject *resultobj;
10761 wxImage *arg1 = (wxImage *) 0 ;
10762 int arg2 ;
10763 int arg3 ;
10764 PyObject * obj0 = 0 ;
10765 PyObject * obj1 = 0 ;
10766 PyObject * obj2 = 0 ;
10767 char *kwnames[] = {
10768 (char *) "self",(char *) "width",(char *) "height", NULL
10769 };
10770
10771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10773 if (SWIG_arg_fail(1)) SWIG_fail;
10774 {
10775 arg2 = (int)(SWIG_As_int(obj1));
10776 if (SWIG_arg_fail(2)) SWIG_fail;
10777 }
10778 {
10779 arg3 = (int)(SWIG_As_int(obj2));
10780 if (SWIG_arg_fail(3)) SWIG_fail;
10781 }
10782 {
10783 PyThreadState* __tstate = wxPyBeginAllowThreads();
10784 (arg1)->Create(arg2,arg3);
10785
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 Py_INCREF(Py_None); resultobj = Py_None;
10790 return resultobj;
10791 fail:
10792 return NULL;
10793 }
10794
10795
10796 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10797 PyObject *resultobj;
10798 wxImage *arg1 = (wxImage *) 0 ;
10799 PyObject * obj0 = 0 ;
10800 char *kwnames[] = {
10801 (char *) "self", NULL
10802 };
10803
10804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10806 if (SWIG_arg_fail(1)) SWIG_fail;
10807 {
10808 PyThreadState* __tstate = wxPyBeginAllowThreads();
10809 (arg1)->Destroy();
10810
10811 wxPyEndAllowThreads(__tstate);
10812 if (PyErr_Occurred()) SWIG_fail;
10813 }
10814 Py_INCREF(Py_None); resultobj = Py_None;
10815 return resultobj;
10816 fail:
10817 return NULL;
10818 }
10819
10820
10821 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10822 PyObject *resultobj;
10823 wxImage *arg1 = (wxImage *) 0 ;
10824 int arg2 ;
10825 int arg3 ;
10826 SwigValueWrapper<wxImage > result;
10827 PyObject * obj0 = 0 ;
10828 PyObject * obj1 = 0 ;
10829 PyObject * obj2 = 0 ;
10830 char *kwnames[] = {
10831 (char *) "self",(char *) "width",(char *) "height", NULL
10832 };
10833
10834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10836 if (SWIG_arg_fail(1)) SWIG_fail;
10837 {
10838 arg2 = (int)(SWIG_As_int(obj1));
10839 if (SWIG_arg_fail(2)) SWIG_fail;
10840 }
10841 {
10842 arg3 = (int)(SWIG_As_int(obj2));
10843 if (SWIG_arg_fail(3)) SWIG_fail;
10844 }
10845 {
10846 PyThreadState* __tstate = wxPyBeginAllowThreads();
10847 result = (arg1)->Scale(arg2,arg3);
10848
10849 wxPyEndAllowThreads(__tstate);
10850 if (PyErr_Occurred()) SWIG_fail;
10851 }
10852 {
10853 wxImage * resultptr;
10854 resultptr = new wxImage((wxImage &)(result));
10855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10856 }
10857 return resultobj;
10858 fail:
10859 return NULL;
10860 }
10861
10862
10863 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10864 PyObject *resultobj;
10865 wxImage *arg1 = (wxImage *) 0 ;
10866 int arg2 ;
10867 int arg3 ;
10868 SwigValueWrapper<wxImage > result;
10869 PyObject * obj0 = 0 ;
10870 PyObject * obj1 = 0 ;
10871 PyObject * obj2 = 0 ;
10872 char *kwnames[] = {
10873 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10874 };
10875
10876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10878 if (SWIG_arg_fail(1)) SWIG_fail;
10879 {
10880 arg2 = (int)(SWIG_As_int(obj1));
10881 if (SWIG_arg_fail(2)) SWIG_fail;
10882 }
10883 {
10884 arg3 = (int)(SWIG_As_int(obj2));
10885 if (SWIG_arg_fail(3)) SWIG_fail;
10886 }
10887 {
10888 PyThreadState* __tstate = wxPyBeginAllowThreads();
10889 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10890
10891 wxPyEndAllowThreads(__tstate);
10892 if (PyErr_Occurred()) SWIG_fail;
10893 }
10894 {
10895 wxImage * resultptr;
10896 resultptr = new wxImage((wxImage &)(result));
10897 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10898 }
10899 return resultobj;
10900 fail:
10901 return NULL;
10902 }
10903
10904
10905 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10906 PyObject *resultobj;
10907 wxImage *arg1 = (wxImage *) 0 ;
10908 int arg2 ;
10909 int arg3 ;
10910 wxImage *result;
10911 PyObject * obj0 = 0 ;
10912 PyObject * obj1 = 0 ;
10913 PyObject * obj2 = 0 ;
10914 char *kwnames[] = {
10915 (char *) "self",(char *) "width",(char *) "height", NULL
10916 };
10917
10918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10920 if (SWIG_arg_fail(1)) SWIG_fail;
10921 {
10922 arg2 = (int)(SWIG_As_int(obj1));
10923 if (SWIG_arg_fail(2)) SWIG_fail;
10924 }
10925 {
10926 arg3 = (int)(SWIG_As_int(obj2));
10927 if (SWIG_arg_fail(3)) SWIG_fail;
10928 }
10929 {
10930 PyThreadState* __tstate = wxPyBeginAllowThreads();
10931 {
10932 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10933 result = (wxImage *) &_result_ref;
10934 }
10935
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj;
10948 wxImage *arg1 = (wxImage *) 0 ;
10949 int arg2 ;
10950 int arg3 ;
10951 unsigned char arg4 ;
10952 unsigned char arg5 ;
10953 unsigned char arg6 ;
10954 PyObject * obj0 = 0 ;
10955 PyObject * obj1 = 0 ;
10956 PyObject * obj2 = 0 ;
10957 PyObject * obj3 = 0 ;
10958 PyObject * obj4 = 0 ;
10959 PyObject * obj5 = 0 ;
10960 char *kwnames[] = {
10961 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10962 };
10963
10964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10966 if (SWIG_arg_fail(1)) SWIG_fail;
10967 {
10968 arg2 = (int)(SWIG_As_int(obj1));
10969 if (SWIG_arg_fail(2)) SWIG_fail;
10970 }
10971 {
10972 arg3 = (int)(SWIG_As_int(obj2));
10973 if (SWIG_arg_fail(3)) SWIG_fail;
10974 }
10975 {
10976 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10977 if (SWIG_arg_fail(4)) SWIG_fail;
10978 }
10979 {
10980 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10981 if (SWIG_arg_fail(5)) SWIG_fail;
10982 }
10983 {
10984 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10985 if (SWIG_arg_fail(6)) SWIG_fail;
10986 }
10987 {
10988 PyThreadState* __tstate = wxPyBeginAllowThreads();
10989 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10990
10991 wxPyEndAllowThreads(__tstate);
10992 if (PyErr_Occurred()) SWIG_fail;
10993 }
10994 Py_INCREF(Py_None); resultobj = Py_None;
10995 return resultobj;
10996 fail:
10997 return NULL;
10998 }
10999
11000
11001 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11002 PyObject *resultobj;
11003 wxImage *arg1 = (wxImage *) 0 ;
11004 int arg2 ;
11005 int arg3 ;
11006 unsigned char result;
11007 PyObject * obj0 = 0 ;
11008 PyObject * obj1 = 0 ;
11009 PyObject * obj2 = 0 ;
11010 char *kwnames[] = {
11011 (char *) "self",(char *) "x",(char *) "y", NULL
11012 };
11013
11014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11016 if (SWIG_arg_fail(1)) SWIG_fail;
11017 {
11018 arg2 = (int)(SWIG_As_int(obj1));
11019 if (SWIG_arg_fail(2)) SWIG_fail;
11020 }
11021 {
11022 arg3 = (int)(SWIG_As_int(obj2));
11023 if (SWIG_arg_fail(3)) SWIG_fail;
11024 }
11025 {
11026 PyThreadState* __tstate = wxPyBeginAllowThreads();
11027 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11028
11029 wxPyEndAllowThreads(__tstate);
11030 if (PyErr_Occurred()) SWIG_fail;
11031 }
11032 {
11033 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11034 }
11035 return resultobj;
11036 fail:
11037 return NULL;
11038 }
11039
11040
11041 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11042 PyObject *resultobj;
11043 wxImage *arg1 = (wxImage *) 0 ;
11044 int arg2 ;
11045 int arg3 ;
11046 unsigned char result;
11047 PyObject * obj0 = 0 ;
11048 PyObject * obj1 = 0 ;
11049 PyObject * obj2 = 0 ;
11050 char *kwnames[] = {
11051 (char *) "self",(char *) "x",(char *) "y", NULL
11052 };
11053
11054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11056 if (SWIG_arg_fail(1)) SWIG_fail;
11057 {
11058 arg2 = (int)(SWIG_As_int(obj1));
11059 if (SWIG_arg_fail(2)) SWIG_fail;
11060 }
11061 {
11062 arg3 = (int)(SWIG_As_int(obj2));
11063 if (SWIG_arg_fail(3)) SWIG_fail;
11064 }
11065 {
11066 PyThreadState* __tstate = wxPyBeginAllowThreads();
11067 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11068
11069 wxPyEndAllowThreads(__tstate);
11070 if (PyErr_Occurred()) SWIG_fail;
11071 }
11072 {
11073 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11074 }
11075 return resultobj;
11076 fail:
11077 return NULL;
11078 }
11079
11080
11081 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11082 PyObject *resultobj;
11083 wxImage *arg1 = (wxImage *) 0 ;
11084 int arg2 ;
11085 int arg3 ;
11086 unsigned char result;
11087 PyObject * obj0 = 0 ;
11088 PyObject * obj1 = 0 ;
11089 PyObject * obj2 = 0 ;
11090 char *kwnames[] = {
11091 (char *) "self",(char *) "x",(char *) "y", NULL
11092 };
11093
11094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11096 if (SWIG_arg_fail(1)) SWIG_fail;
11097 {
11098 arg2 = (int)(SWIG_As_int(obj1));
11099 if (SWIG_arg_fail(2)) SWIG_fail;
11100 }
11101 {
11102 arg3 = (int)(SWIG_As_int(obj2));
11103 if (SWIG_arg_fail(3)) SWIG_fail;
11104 }
11105 {
11106 PyThreadState* __tstate = wxPyBeginAllowThreads();
11107 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11108
11109 wxPyEndAllowThreads(__tstate);
11110 if (PyErr_Occurred()) SWIG_fail;
11111 }
11112 {
11113 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11114 }
11115 return resultobj;
11116 fail:
11117 return NULL;
11118 }
11119
11120
11121 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11122 PyObject *resultobj;
11123 wxImage *arg1 = (wxImage *) 0 ;
11124 int arg2 ;
11125 int arg3 ;
11126 unsigned char arg4 ;
11127 PyObject * obj0 = 0 ;
11128 PyObject * obj1 = 0 ;
11129 PyObject * obj2 = 0 ;
11130 PyObject * obj3 = 0 ;
11131 char *kwnames[] = {
11132 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11133 };
11134
11135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11137 if (SWIG_arg_fail(1)) SWIG_fail;
11138 {
11139 arg2 = (int)(SWIG_As_int(obj1));
11140 if (SWIG_arg_fail(2)) SWIG_fail;
11141 }
11142 {
11143 arg3 = (int)(SWIG_As_int(obj2));
11144 if (SWIG_arg_fail(3)) SWIG_fail;
11145 }
11146 {
11147 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11148 if (SWIG_arg_fail(4)) SWIG_fail;
11149 }
11150 {
11151 PyThreadState* __tstate = wxPyBeginAllowThreads();
11152 (arg1)->SetAlpha(arg2,arg3,arg4);
11153
11154 wxPyEndAllowThreads(__tstate);
11155 if (PyErr_Occurred()) SWIG_fail;
11156 }
11157 Py_INCREF(Py_None); resultobj = Py_None;
11158 return resultobj;
11159 fail:
11160 return NULL;
11161 }
11162
11163
11164 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11165 PyObject *resultobj;
11166 wxImage *arg1 = (wxImage *) 0 ;
11167 int arg2 ;
11168 int arg3 ;
11169 unsigned char result;
11170 PyObject * obj0 = 0 ;
11171 PyObject * obj1 = 0 ;
11172 PyObject * obj2 = 0 ;
11173 char *kwnames[] = {
11174 (char *) "self",(char *) "x",(char *) "y", NULL
11175 };
11176
11177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11179 if (SWIG_arg_fail(1)) SWIG_fail;
11180 {
11181 arg2 = (int)(SWIG_As_int(obj1));
11182 if (SWIG_arg_fail(2)) SWIG_fail;
11183 }
11184 {
11185 arg3 = (int)(SWIG_As_int(obj2));
11186 if (SWIG_arg_fail(3)) SWIG_fail;
11187 }
11188 {
11189 PyThreadState* __tstate = wxPyBeginAllowThreads();
11190 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11191
11192 wxPyEndAllowThreads(__tstate);
11193 if (PyErr_Occurred()) SWIG_fail;
11194 }
11195 {
11196 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11197 }
11198 return resultobj;
11199 fail:
11200 return NULL;
11201 }
11202
11203
11204 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11205 PyObject *resultobj;
11206 wxImage *arg1 = (wxImage *) 0 ;
11207 bool result;
11208 PyObject * obj0 = 0 ;
11209 char *kwnames[] = {
11210 (char *) "self", NULL
11211 };
11212
11213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11215 if (SWIG_arg_fail(1)) SWIG_fail;
11216 {
11217 PyThreadState* __tstate = wxPyBeginAllowThreads();
11218 result = (bool)(arg1)->HasAlpha();
11219
11220 wxPyEndAllowThreads(__tstate);
11221 if (PyErr_Occurred()) SWIG_fail;
11222 }
11223 {
11224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11225 }
11226 return resultobj;
11227 fail:
11228 return NULL;
11229 }
11230
11231
11232 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11233 PyObject *resultobj;
11234 wxImage *arg1 = (wxImage *) 0 ;
11235 PyObject * obj0 = 0 ;
11236 char *kwnames[] = {
11237 (char *) "self", NULL
11238 };
11239
11240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11242 if (SWIG_arg_fail(1)) SWIG_fail;
11243 {
11244 PyThreadState* __tstate = wxPyBeginAllowThreads();
11245 (arg1)->InitAlpha();
11246
11247 wxPyEndAllowThreads(__tstate);
11248 if (PyErr_Occurred()) SWIG_fail;
11249 }
11250 Py_INCREF(Py_None); resultobj = Py_None;
11251 return resultobj;
11252 fail:
11253 return NULL;
11254 }
11255
11256
11257 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11258 PyObject *resultobj;
11259 wxImage *arg1 = (wxImage *) 0 ;
11260 byte *arg2 = (byte *) 0 ;
11261 byte *arg3 = (byte *) 0 ;
11262 byte *arg4 = (byte *) 0 ;
11263 byte arg5 = (byte) 0 ;
11264 byte arg6 = (byte) 0 ;
11265 byte arg7 = (byte) 0 ;
11266 bool result;
11267 byte temp2 ;
11268 int res2 = 0 ;
11269 byte temp3 ;
11270 int res3 = 0 ;
11271 byte temp4 ;
11272 int res4 = 0 ;
11273 PyObject * obj0 = 0 ;
11274 PyObject * obj1 = 0 ;
11275 PyObject * obj2 = 0 ;
11276 PyObject * obj3 = 0 ;
11277 char *kwnames[] = {
11278 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11279 };
11280
11281 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11282 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11283 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11286 if (SWIG_arg_fail(1)) SWIG_fail;
11287 if (obj1) {
11288 {
11289 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11290 if (SWIG_arg_fail(5)) SWIG_fail;
11291 }
11292 }
11293 if (obj2) {
11294 {
11295 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11296 if (SWIG_arg_fail(6)) SWIG_fail;
11297 }
11298 }
11299 if (obj3) {
11300 {
11301 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11302 if (SWIG_arg_fail(7)) SWIG_fail;
11303 }
11304 }
11305 {
11306 PyThreadState* __tstate = wxPyBeginAllowThreads();
11307 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11308
11309 wxPyEndAllowThreads(__tstate);
11310 if (PyErr_Occurred()) SWIG_fail;
11311 }
11312 {
11313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11314 }
11315 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11316 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11317 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11318 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11319 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11320 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11321 return resultobj;
11322 fail:
11323 return NULL;
11324 }
11325
11326
11327 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11328 PyObject *resultobj;
11329 wxImage *arg1 = (wxImage *) 0 ;
11330 byte arg2 = (byte) 128 ;
11331 bool result;
11332 PyObject * obj0 = 0 ;
11333 PyObject * obj1 = 0 ;
11334 char *kwnames[] = {
11335 (char *) "self",(char *) "threshold", NULL
11336 };
11337
11338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11340 if (SWIG_arg_fail(1)) SWIG_fail;
11341 if (obj1) {
11342 {
11343 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11344 if (SWIG_arg_fail(2)) SWIG_fail;
11345 }
11346 }
11347 {
11348 PyThreadState* __tstate = wxPyBeginAllowThreads();
11349 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11350
11351 wxPyEndAllowThreads(__tstate);
11352 if (PyErr_Occurred()) SWIG_fail;
11353 }
11354 {
11355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11356 }
11357 return resultobj;
11358 fail:
11359 return NULL;
11360 }
11361
11362
11363 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11364 PyObject *resultobj;
11365 wxImage *arg1 = (wxImage *) 0 ;
11366 unsigned char arg2 ;
11367 unsigned char arg3 ;
11368 unsigned char arg4 ;
11369 bool result;
11370 PyObject * obj0 = 0 ;
11371 PyObject * obj1 = 0 ;
11372 PyObject * obj2 = 0 ;
11373 PyObject * obj3 = 0 ;
11374 char *kwnames[] = {
11375 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11376 };
11377
11378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11380 if (SWIG_arg_fail(1)) SWIG_fail;
11381 {
11382 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11383 if (SWIG_arg_fail(2)) SWIG_fail;
11384 }
11385 {
11386 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11387 if (SWIG_arg_fail(3)) SWIG_fail;
11388 }
11389 {
11390 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11391 if (SWIG_arg_fail(4)) SWIG_fail;
11392 }
11393 {
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
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_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11410 PyObject *resultobj;
11411 wxImage *arg1 = (wxImage *) 0 ;
11412 wxImage *arg2 = 0 ;
11413 byte arg3 ;
11414 byte arg4 ;
11415 byte arg5 ;
11416 bool result;
11417 PyObject * obj0 = 0 ;
11418 PyObject * obj1 = 0 ;
11419 PyObject * obj2 = 0 ;
11420 PyObject * obj3 = 0 ;
11421 PyObject * obj4 = 0 ;
11422 char *kwnames[] = {
11423 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11424 };
11425
11426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11428 if (SWIG_arg_fail(1)) SWIG_fail;
11429 {
11430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11431 if (SWIG_arg_fail(2)) SWIG_fail;
11432 if (arg2 == NULL) {
11433 SWIG_null_ref("wxImage");
11434 }
11435 if (SWIG_arg_fail(2)) SWIG_fail;
11436 }
11437 {
11438 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11439 if (SWIG_arg_fail(3)) SWIG_fail;
11440 }
11441 {
11442 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11443 if (SWIG_arg_fail(4)) SWIG_fail;
11444 }
11445 {
11446 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11447 if (SWIG_arg_fail(5)) SWIG_fail;
11448 }
11449 {
11450 PyThreadState* __tstate = wxPyBeginAllowThreads();
11451 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11452
11453 wxPyEndAllowThreads(__tstate);
11454 if (PyErr_Occurred()) SWIG_fail;
11455 }
11456 {
11457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11458 }
11459 return resultobj;
11460 fail:
11461 return NULL;
11462 }
11463
11464
11465 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11466 PyObject *resultobj;
11467 wxString *arg1 = 0 ;
11468 bool result;
11469 bool temp1 = false ;
11470 PyObject * obj0 = 0 ;
11471 char *kwnames[] = {
11472 (char *) "name", NULL
11473 };
11474
11475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11476 {
11477 arg1 = wxString_in_helper(obj0);
11478 if (arg1 == NULL) SWIG_fail;
11479 temp1 = true;
11480 }
11481 {
11482 PyThreadState* __tstate = wxPyBeginAllowThreads();
11483 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11484
11485 wxPyEndAllowThreads(__tstate);
11486 if (PyErr_Occurred()) SWIG_fail;
11487 }
11488 {
11489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11490 }
11491 {
11492 if (temp1)
11493 delete arg1;
11494 }
11495 return resultobj;
11496 fail:
11497 {
11498 if (temp1)
11499 delete arg1;
11500 }
11501 return NULL;
11502 }
11503
11504
11505 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11506 PyObject *resultobj;
11507 wxString *arg1 = 0 ;
11508 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11509 int result;
11510 bool temp1 = false ;
11511 PyObject * obj0 = 0 ;
11512 PyObject * obj1 = 0 ;
11513 char *kwnames[] = {
11514 (char *) "name",(char *) "type", NULL
11515 };
11516
11517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11518 {
11519 arg1 = wxString_in_helper(obj0);
11520 if (arg1 == NULL) SWIG_fail;
11521 temp1 = true;
11522 }
11523 if (obj1) {
11524 {
11525 arg2 = (long)(SWIG_As_long(obj1));
11526 if (SWIG_arg_fail(2)) SWIG_fail;
11527 }
11528 }
11529 {
11530 PyThreadState* __tstate = wxPyBeginAllowThreads();
11531 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11532
11533 wxPyEndAllowThreads(__tstate);
11534 if (PyErr_Occurred()) SWIG_fail;
11535 }
11536 {
11537 resultobj = SWIG_From_int((int)(result));
11538 }
11539 {
11540 if (temp1)
11541 delete arg1;
11542 }
11543 return resultobj;
11544 fail:
11545 {
11546 if (temp1)
11547 delete arg1;
11548 }
11549 return NULL;
11550 }
11551
11552
11553 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11554 PyObject *resultobj;
11555 wxImage *arg1 = (wxImage *) 0 ;
11556 wxString *arg2 = 0 ;
11557 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11558 int arg4 = (int) -1 ;
11559 bool result;
11560 bool temp2 = false ;
11561 PyObject * obj0 = 0 ;
11562 PyObject * obj1 = 0 ;
11563 PyObject * obj2 = 0 ;
11564 PyObject * obj3 = 0 ;
11565 char *kwnames[] = {
11566 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11567 };
11568
11569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11571 if (SWIG_arg_fail(1)) SWIG_fail;
11572 {
11573 arg2 = wxString_in_helper(obj1);
11574 if (arg2 == NULL) SWIG_fail;
11575 temp2 = true;
11576 }
11577 if (obj2) {
11578 {
11579 arg3 = (long)(SWIG_As_long(obj2));
11580 if (SWIG_arg_fail(3)) SWIG_fail;
11581 }
11582 }
11583 if (obj3) {
11584 {
11585 arg4 = (int)(SWIG_As_int(obj3));
11586 if (SWIG_arg_fail(4)) SWIG_fail;
11587 }
11588 }
11589 {
11590 PyThreadState* __tstate = wxPyBeginAllowThreads();
11591 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11592
11593 wxPyEndAllowThreads(__tstate);
11594 if (PyErr_Occurred()) SWIG_fail;
11595 }
11596 {
11597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11598 }
11599 {
11600 if (temp2)
11601 delete arg2;
11602 }
11603 return resultobj;
11604 fail:
11605 {
11606 if (temp2)
11607 delete arg2;
11608 }
11609 return NULL;
11610 }
11611
11612
11613 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11614 PyObject *resultobj;
11615 wxImage *arg1 = (wxImage *) 0 ;
11616 wxString *arg2 = 0 ;
11617 wxString *arg3 = 0 ;
11618 int arg4 = (int) -1 ;
11619 bool result;
11620 bool temp2 = false ;
11621 bool temp3 = false ;
11622 PyObject * obj0 = 0 ;
11623 PyObject * obj1 = 0 ;
11624 PyObject * obj2 = 0 ;
11625 PyObject * obj3 = 0 ;
11626 char *kwnames[] = {
11627 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11628 };
11629
11630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11632 if (SWIG_arg_fail(1)) SWIG_fail;
11633 {
11634 arg2 = wxString_in_helper(obj1);
11635 if (arg2 == NULL) SWIG_fail;
11636 temp2 = true;
11637 }
11638 {
11639 arg3 = wxString_in_helper(obj2);
11640 if (arg3 == NULL) SWIG_fail;
11641 temp3 = true;
11642 }
11643 if (obj3) {
11644 {
11645 arg4 = (int)(SWIG_As_int(obj3));
11646 if (SWIG_arg_fail(4)) SWIG_fail;
11647 }
11648 }
11649 {
11650 PyThreadState* __tstate = wxPyBeginAllowThreads();
11651 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11652
11653 wxPyEndAllowThreads(__tstate);
11654 if (PyErr_Occurred()) SWIG_fail;
11655 }
11656 {
11657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11658 }
11659 {
11660 if (temp2)
11661 delete arg2;
11662 }
11663 {
11664 if (temp3)
11665 delete arg3;
11666 }
11667 return resultobj;
11668 fail:
11669 {
11670 if (temp2)
11671 delete arg2;
11672 }
11673 {
11674 if (temp3)
11675 delete arg3;
11676 }
11677 return NULL;
11678 }
11679
11680
11681 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11682 PyObject *resultobj;
11683 wxImage *arg1 = (wxImage *) 0 ;
11684 wxString *arg2 = 0 ;
11685 int arg3 ;
11686 bool result;
11687 bool temp2 = false ;
11688 PyObject * obj0 = 0 ;
11689 PyObject * obj1 = 0 ;
11690 PyObject * obj2 = 0 ;
11691 char *kwnames[] = {
11692 (char *) "self",(char *) "name",(char *) "type", NULL
11693 };
11694
11695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11697 if (SWIG_arg_fail(1)) SWIG_fail;
11698 {
11699 arg2 = wxString_in_helper(obj1);
11700 if (arg2 == NULL) SWIG_fail;
11701 temp2 = true;
11702 }
11703 {
11704 arg3 = (int)(SWIG_As_int(obj2));
11705 if (SWIG_arg_fail(3)) SWIG_fail;
11706 }
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11710
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 {
11715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11716 }
11717 {
11718 if (temp2)
11719 delete arg2;
11720 }
11721 return resultobj;
11722 fail:
11723 {
11724 if (temp2)
11725 delete arg2;
11726 }
11727 return NULL;
11728 }
11729
11730
11731 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11732 PyObject *resultobj;
11733 wxImage *arg1 = (wxImage *) 0 ;
11734 wxString *arg2 = 0 ;
11735 wxString *arg3 = 0 ;
11736 bool result;
11737 bool temp2 = false ;
11738 bool temp3 = false ;
11739 PyObject * obj0 = 0 ;
11740 PyObject * obj1 = 0 ;
11741 PyObject * obj2 = 0 ;
11742 char *kwnames[] = {
11743 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11744 };
11745
11746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11748 if (SWIG_arg_fail(1)) SWIG_fail;
11749 {
11750 arg2 = wxString_in_helper(obj1);
11751 if (arg2 == NULL) SWIG_fail;
11752 temp2 = true;
11753 }
11754 {
11755 arg3 = wxString_in_helper(obj2);
11756 if (arg3 == NULL) SWIG_fail;
11757 temp3 = true;
11758 }
11759 {
11760 PyThreadState* __tstate = wxPyBeginAllowThreads();
11761 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11762
11763 wxPyEndAllowThreads(__tstate);
11764 if (PyErr_Occurred()) SWIG_fail;
11765 }
11766 {
11767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11768 }
11769 {
11770 if (temp2)
11771 delete arg2;
11772 }
11773 {
11774 if (temp3)
11775 delete arg3;
11776 }
11777 return resultobj;
11778 fail:
11779 {
11780 if (temp2)
11781 delete arg2;
11782 }
11783 {
11784 if (temp3)
11785 delete arg3;
11786 }
11787 return NULL;
11788 }
11789
11790
11791 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11792 PyObject *resultobj;
11793 wxInputStream *arg1 = 0 ;
11794 bool result;
11795 wxPyInputStream *temp1 ;
11796 bool created1 ;
11797 PyObject * obj0 = 0 ;
11798 char *kwnames[] = {
11799 (char *) "stream", NULL
11800 };
11801
11802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11803 {
11804 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11805 arg1 = temp1->m_wxis;
11806 created1 = false;
11807 } else {
11808 PyErr_Clear(); // clear the failure of the wxPyConvert above
11809 arg1 = wxPyCBInputStream_create(obj0, false);
11810 if (arg1 == NULL) {
11811 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11812 SWIG_fail;
11813 }
11814 created1 = true;
11815 }
11816 }
11817 {
11818 PyThreadState* __tstate = wxPyBeginAllowThreads();
11819 result = (bool)wxImage::CanRead(*arg1);
11820
11821 wxPyEndAllowThreads(__tstate);
11822 if (PyErr_Occurred()) SWIG_fail;
11823 }
11824 {
11825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11826 }
11827 {
11828 if (created1)
11829 delete arg1;
11830 }
11831 return resultobj;
11832 fail:
11833 {
11834 if (created1)
11835 delete arg1;
11836 }
11837 return NULL;
11838 }
11839
11840
11841 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11842 PyObject *resultobj;
11843 wxImage *arg1 = (wxImage *) 0 ;
11844 wxInputStream *arg2 = 0 ;
11845 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11846 int arg4 = (int) -1 ;
11847 bool result;
11848 wxPyInputStream *temp2 ;
11849 bool created2 ;
11850 PyObject * obj0 = 0 ;
11851 PyObject * obj1 = 0 ;
11852 PyObject * obj2 = 0 ;
11853 PyObject * obj3 = 0 ;
11854 char *kwnames[] = {
11855 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11856 };
11857
11858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11860 if (SWIG_arg_fail(1)) SWIG_fail;
11861 {
11862 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11863 arg2 = temp2->m_wxis;
11864 created2 = false;
11865 } else {
11866 PyErr_Clear(); // clear the failure of the wxPyConvert above
11867 arg2 = wxPyCBInputStream_create(obj1, false);
11868 if (arg2 == NULL) {
11869 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11870 SWIG_fail;
11871 }
11872 created2 = true;
11873 }
11874 }
11875 if (obj2) {
11876 {
11877 arg3 = (long)(SWIG_As_long(obj2));
11878 if (SWIG_arg_fail(3)) SWIG_fail;
11879 }
11880 }
11881 if (obj3) {
11882 {
11883 arg4 = (int)(SWIG_As_int(obj3));
11884 if (SWIG_arg_fail(4)) SWIG_fail;
11885 }
11886 }
11887 {
11888 PyThreadState* __tstate = wxPyBeginAllowThreads();
11889 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11890
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 {
11895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11896 }
11897 {
11898 if (created2)
11899 delete arg2;
11900 }
11901 return resultobj;
11902 fail:
11903 {
11904 if (created2)
11905 delete arg2;
11906 }
11907 return NULL;
11908 }
11909
11910
11911 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11912 PyObject *resultobj;
11913 wxImage *arg1 = (wxImage *) 0 ;
11914 wxInputStream *arg2 = 0 ;
11915 wxString *arg3 = 0 ;
11916 int arg4 = (int) -1 ;
11917 bool result;
11918 wxPyInputStream *temp2 ;
11919 bool created2 ;
11920 bool temp3 = false ;
11921 PyObject * obj0 = 0 ;
11922 PyObject * obj1 = 0 ;
11923 PyObject * obj2 = 0 ;
11924 PyObject * obj3 = 0 ;
11925 char *kwnames[] = {
11926 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11927 };
11928
11929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11931 if (SWIG_arg_fail(1)) SWIG_fail;
11932 {
11933 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11934 arg2 = temp2->m_wxis;
11935 created2 = false;
11936 } else {
11937 PyErr_Clear(); // clear the failure of the wxPyConvert above
11938 arg2 = wxPyCBInputStream_create(obj1, false);
11939 if (arg2 == NULL) {
11940 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11941 SWIG_fail;
11942 }
11943 created2 = true;
11944 }
11945 }
11946 {
11947 arg3 = wxString_in_helper(obj2);
11948 if (arg3 == NULL) SWIG_fail;
11949 temp3 = true;
11950 }
11951 if (obj3) {
11952 {
11953 arg4 = (int)(SWIG_As_int(obj3));
11954 if (SWIG_arg_fail(4)) SWIG_fail;
11955 }
11956 }
11957 {
11958 PyThreadState* __tstate = wxPyBeginAllowThreads();
11959 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11960
11961 wxPyEndAllowThreads(__tstate);
11962 if (PyErr_Occurred()) SWIG_fail;
11963 }
11964 {
11965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11966 }
11967 {
11968 if (created2)
11969 delete arg2;
11970 }
11971 {
11972 if (temp3)
11973 delete arg3;
11974 }
11975 return resultobj;
11976 fail:
11977 {
11978 if (created2)
11979 delete arg2;
11980 }
11981 {
11982 if (temp3)
11983 delete arg3;
11984 }
11985 return NULL;
11986 }
11987
11988
11989 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11990 PyObject *resultobj;
11991 wxImage *arg1 = (wxImage *) 0 ;
11992 bool result;
11993 PyObject * obj0 = 0 ;
11994 char *kwnames[] = {
11995 (char *) "self", NULL
11996 };
11997
11998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",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 = (bool)(arg1)->Ok();
12004
12005 wxPyEndAllowThreads(__tstate);
12006 if (PyErr_Occurred()) SWIG_fail;
12007 }
12008 {
12009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12010 }
12011 return resultobj;
12012 fail:
12013 return NULL;
12014 }
12015
12016
12017 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj;
12019 wxImage *arg1 = (wxImage *) 0 ;
12020 int result;
12021 PyObject * obj0 = 0 ;
12022 char *kwnames[] = {
12023 (char *) "self", NULL
12024 };
12025
12026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",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 = (int)(arg1)->GetWidth();
12032
12033 wxPyEndAllowThreads(__tstate);
12034 if (PyErr_Occurred()) SWIG_fail;
12035 }
12036 {
12037 resultobj = SWIG_From_int((int)(result));
12038 }
12039 return resultobj;
12040 fail:
12041 return NULL;
12042 }
12043
12044
12045 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12046 PyObject *resultobj;
12047 wxImage *arg1 = (wxImage *) 0 ;
12048 int result;
12049 PyObject * obj0 = 0 ;
12050 char *kwnames[] = {
12051 (char *) "self", NULL
12052 };
12053
12054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12056 if (SWIG_arg_fail(1)) SWIG_fail;
12057 {
12058 PyThreadState* __tstate = wxPyBeginAllowThreads();
12059 result = (int)(arg1)->GetHeight();
12060
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 {
12065 resultobj = SWIG_From_int((int)(result));
12066 }
12067 return resultobj;
12068 fail:
12069 return NULL;
12070 }
12071
12072
12073 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12074 PyObject *resultobj;
12075 wxImage *arg1 = (wxImage *) 0 ;
12076 wxSize result;
12077 PyObject * obj0 = 0 ;
12078 char *kwnames[] = {
12079 (char *) "self", NULL
12080 };
12081
12082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12084 if (SWIG_arg_fail(1)) SWIG_fail;
12085 {
12086 PyThreadState* __tstate = wxPyBeginAllowThreads();
12087 result = wxImage_GetSize(arg1);
12088
12089 wxPyEndAllowThreads(__tstate);
12090 if (PyErr_Occurred()) SWIG_fail;
12091 }
12092 {
12093 wxSize * resultptr;
12094 resultptr = new wxSize((wxSize &)(result));
12095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12096 }
12097 return resultobj;
12098 fail:
12099 return NULL;
12100 }
12101
12102
12103 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12104 PyObject *resultobj;
12105 wxImage *arg1 = (wxImage *) 0 ;
12106 wxRect *arg2 = 0 ;
12107 SwigValueWrapper<wxImage > result;
12108 wxRect temp2 ;
12109 PyObject * obj0 = 0 ;
12110 PyObject * obj1 = 0 ;
12111 char *kwnames[] = {
12112 (char *) "self",(char *) "rect", NULL
12113 };
12114
12115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12117 if (SWIG_arg_fail(1)) SWIG_fail;
12118 {
12119 arg2 = &temp2;
12120 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12121 }
12122 {
12123 PyThreadState* __tstate = wxPyBeginAllowThreads();
12124 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12125
12126 wxPyEndAllowThreads(__tstate);
12127 if (PyErr_Occurred()) SWIG_fail;
12128 }
12129 {
12130 wxImage * resultptr;
12131 resultptr = new wxImage((wxImage &)(result));
12132 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12133 }
12134 return resultobj;
12135 fail:
12136 return NULL;
12137 }
12138
12139
12140 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12141 PyObject *resultobj;
12142 wxImage *arg1 = (wxImage *) 0 ;
12143 SwigValueWrapper<wxImage > result;
12144 PyObject * obj0 = 0 ;
12145 char *kwnames[] = {
12146 (char *) "self", NULL
12147 };
12148
12149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12151 if (SWIG_arg_fail(1)) SWIG_fail;
12152 {
12153 PyThreadState* __tstate = wxPyBeginAllowThreads();
12154 result = (arg1)->Copy();
12155
12156 wxPyEndAllowThreads(__tstate);
12157 if (PyErr_Occurred()) SWIG_fail;
12158 }
12159 {
12160 wxImage * resultptr;
12161 resultptr = new wxImage((wxImage &)(result));
12162 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12163 }
12164 return resultobj;
12165 fail:
12166 return NULL;
12167 }
12168
12169
12170 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12171 PyObject *resultobj;
12172 wxImage *arg1 = (wxImage *) 0 ;
12173 wxImage *arg2 = 0 ;
12174 int arg3 ;
12175 int arg4 ;
12176 PyObject * obj0 = 0 ;
12177 PyObject * obj1 = 0 ;
12178 PyObject * obj2 = 0 ;
12179 PyObject * obj3 = 0 ;
12180 char *kwnames[] = {
12181 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12182 };
12183
12184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12186 if (SWIG_arg_fail(1)) SWIG_fail;
12187 {
12188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12189 if (SWIG_arg_fail(2)) SWIG_fail;
12190 if (arg2 == NULL) {
12191 SWIG_null_ref("wxImage");
12192 }
12193 if (SWIG_arg_fail(2)) SWIG_fail;
12194 }
12195 {
12196 arg3 = (int)(SWIG_As_int(obj2));
12197 if (SWIG_arg_fail(3)) SWIG_fail;
12198 }
12199 {
12200 arg4 = (int)(SWIG_As_int(obj3));
12201 if (SWIG_arg_fail(4)) SWIG_fail;
12202 }
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12206
12207 wxPyEndAllowThreads(__tstate);
12208 if (PyErr_Occurred()) SWIG_fail;
12209 }
12210 Py_INCREF(Py_None); resultobj = Py_None;
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12218 PyObject *resultobj;
12219 wxImage *arg1 = (wxImage *) 0 ;
12220 PyObject *result;
12221 PyObject * obj0 = 0 ;
12222 char *kwnames[] = {
12223 (char *) "self", NULL
12224 };
12225
12226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12228 if (SWIG_arg_fail(1)) SWIG_fail;
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 result = (PyObject *)wxImage_GetData(arg1);
12232
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 resultobj = result;
12237 return resultobj;
12238 fail:
12239 return NULL;
12240 }
12241
12242
12243 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12244 PyObject *resultobj;
12245 wxImage *arg1 = (wxImage *) 0 ;
12246 PyObject *arg2 = (PyObject *) 0 ;
12247 PyObject * obj0 = 0 ;
12248 PyObject * obj1 = 0 ;
12249 char *kwnames[] = {
12250 (char *) "self",(char *) "data", NULL
12251 };
12252
12253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12255 if (SWIG_arg_fail(1)) SWIG_fail;
12256 arg2 = obj1;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 wxImage_SetData(arg1,arg2);
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 Py_INCREF(Py_None); resultobj = Py_None;
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj;
12273 wxImage *arg1 = (wxImage *) 0 ;
12274 PyObject *result;
12275 PyObject * obj0 = 0 ;
12276 char *kwnames[] = {
12277 (char *) "self", NULL
12278 };
12279
12280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12282 if (SWIG_arg_fail(1)) SWIG_fail;
12283 {
12284 PyThreadState* __tstate = wxPyBeginAllowThreads();
12285 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12286
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = result;
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12298 PyObject *resultobj;
12299 wxImage *arg1 = (wxImage *) 0 ;
12300 PyObject *arg2 = (PyObject *) 0 ;
12301 PyObject * obj0 = 0 ;
12302 PyObject * obj1 = 0 ;
12303 char *kwnames[] = {
12304 (char *) "self",(char *) "data", NULL
12305 };
12306
12307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12309 if (SWIG_arg_fail(1)) SWIG_fail;
12310 arg2 = obj1;
12311 {
12312 PyThreadState* __tstate = wxPyBeginAllowThreads();
12313 wxImage_SetDataBuffer(arg1,arg2);
12314
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 Py_INCREF(Py_None); resultobj = Py_None;
12319 return resultobj;
12320 fail:
12321 return NULL;
12322 }
12323
12324
12325 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12326 PyObject *resultobj;
12327 wxImage *arg1 = (wxImage *) 0 ;
12328 PyObject *result;
12329 PyObject * obj0 = 0 ;
12330 char *kwnames[] = {
12331 (char *) "self", NULL
12332 };
12333
12334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12336 if (SWIG_arg_fail(1)) SWIG_fail;
12337 {
12338 PyThreadState* __tstate = wxPyBeginAllowThreads();
12339 result = (PyObject *)wxImage_GetAlphaData(arg1);
12340
12341 wxPyEndAllowThreads(__tstate);
12342 if (PyErr_Occurred()) SWIG_fail;
12343 }
12344 resultobj = result;
12345 return resultobj;
12346 fail:
12347 return NULL;
12348 }
12349
12350
12351 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12352 PyObject *resultobj;
12353 wxImage *arg1 = (wxImage *) 0 ;
12354 PyObject *arg2 = (PyObject *) 0 ;
12355 PyObject * obj0 = 0 ;
12356 PyObject * obj1 = 0 ;
12357 char *kwnames[] = {
12358 (char *) "self",(char *) "data", NULL
12359 };
12360
12361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12363 if (SWIG_arg_fail(1)) SWIG_fail;
12364 arg2 = obj1;
12365 {
12366 PyThreadState* __tstate = wxPyBeginAllowThreads();
12367 wxImage_SetAlphaData(arg1,arg2);
12368
12369 wxPyEndAllowThreads(__tstate);
12370 if (PyErr_Occurred()) SWIG_fail;
12371 }
12372 Py_INCREF(Py_None); resultobj = Py_None;
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj;
12381 wxImage *arg1 = (wxImage *) 0 ;
12382 PyObject *result;
12383 PyObject * obj0 = 0 ;
12384 char *kwnames[] = {
12385 (char *) "self", NULL
12386 };
12387
12388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12390 if (SWIG_arg_fail(1)) SWIG_fail;
12391 {
12392 PyThreadState* __tstate = wxPyBeginAllowThreads();
12393 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12394
12395 wxPyEndAllowThreads(__tstate);
12396 if (PyErr_Occurred()) SWIG_fail;
12397 }
12398 resultobj = result;
12399 return resultobj;
12400 fail:
12401 return NULL;
12402 }
12403
12404
12405 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12406 PyObject *resultobj;
12407 wxImage *arg1 = (wxImage *) 0 ;
12408 PyObject *arg2 = (PyObject *) 0 ;
12409 PyObject * obj0 = 0 ;
12410 PyObject * obj1 = 0 ;
12411 char *kwnames[] = {
12412 (char *) "self",(char *) "data", NULL
12413 };
12414
12415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12417 if (SWIG_arg_fail(1)) SWIG_fail;
12418 arg2 = obj1;
12419 {
12420 PyThreadState* __tstate = wxPyBeginAllowThreads();
12421 wxImage_SetAlphaBuffer(arg1,arg2);
12422
12423 wxPyEndAllowThreads(__tstate);
12424 if (PyErr_Occurred()) SWIG_fail;
12425 }
12426 Py_INCREF(Py_None); resultobj = Py_None;
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj;
12435 wxImage *arg1 = (wxImage *) 0 ;
12436 unsigned char arg2 ;
12437 unsigned char arg3 ;
12438 unsigned char arg4 ;
12439 PyObject * obj0 = 0 ;
12440 PyObject * obj1 = 0 ;
12441 PyObject * obj2 = 0 ;
12442 PyObject * obj3 = 0 ;
12443 char *kwnames[] = {
12444 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12445 };
12446
12447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12449 if (SWIG_arg_fail(1)) SWIG_fail;
12450 {
12451 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12452 if (SWIG_arg_fail(2)) SWIG_fail;
12453 }
12454 {
12455 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12456 if (SWIG_arg_fail(3)) SWIG_fail;
12457 }
12458 {
12459 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12460 if (SWIG_arg_fail(4)) SWIG_fail;
12461 }
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 (arg1)->SetMaskColour(arg2,arg3,arg4);
12465
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 Py_INCREF(Py_None); resultobj = Py_None;
12470 return resultobj;
12471 fail:
12472 return NULL;
12473 }
12474
12475
12476 static PyObject *_wrap_Image_GetMaskRed(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_GetMaskRed",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)->GetMaskRed();
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_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12505 PyObject *resultobj;
12506 wxImage *arg1 = (wxImage *) 0 ;
12507 unsigned char result;
12508 PyObject * obj0 = 0 ;
12509 char *kwnames[] = {
12510 (char *) "self", NULL
12511 };
12512
12513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12515 if (SWIG_arg_fail(1)) SWIG_fail;
12516 {
12517 PyThreadState* __tstate = wxPyBeginAllowThreads();
12518 result = (unsigned char)(arg1)->GetMaskGreen();
12519
12520 wxPyEndAllowThreads(__tstate);
12521 if (PyErr_Occurred()) SWIG_fail;
12522 }
12523 {
12524 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12525 }
12526 return resultobj;
12527 fail:
12528 return NULL;
12529 }
12530
12531
12532 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12533 PyObject *resultobj;
12534 wxImage *arg1 = (wxImage *) 0 ;
12535 unsigned char result;
12536 PyObject * obj0 = 0 ;
12537 char *kwnames[] = {
12538 (char *) "self", NULL
12539 };
12540
12541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12543 if (SWIG_arg_fail(1)) SWIG_fail;
12544 {
12545 PyThreadState* __tstate = wxPyBeginAllowThreads();
12546 result = (unsigned char)(arg1)->GetMaskBlue();
12547
12548 wxPyEndAllowThreads(__tstate);
12549 if (PyErr_Occurred()) SWIG_fail;
12550 }
12551 {
12552 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12553 }
12554 return resultobj;
12555 fail:
12556 return NULL;
12557 }
12558
12559
12560 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12561 PyObject *resultobj;
12562 wxImage *arg1 = (wxImage *) 0 ;
12563 bool arg2 = (bool) true ;
12564 PyObject * obj0 = 0 ;
12565 PyObject * obj1 = 0 ;
12566 char *kwnames[] = {
12567 (char *) "self",(char *) "mask", NULL
12568 };
12569
12570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12572 if (SWIG_arg_fail(1)) SWIG_fail;
12573 if (obj1) {
12574 {
12575 arg2 = (bool)(SWIG_As_bool(obj1));
12576 if (SWIG_arg_fail(2)) SWIG_fail;
12577 }
12578 }
12579 {
12580 PyThreadState* __tstate = wxPyBeginAllowThreads();
12581 (arg1)->SetMask(arg2);
12582
12583 wxPyEndAllowThreads(__tstate);
12584 if (PyErr_Occurred()) SWIG_fail;
12585 }
12586 Py_INCREF(Py_None); resultobj = Py_None;
12587 return resultobj;
12588 fail:
12589 return NULL;
12590 }
12591
12592
12593 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12594 PyObject *resultobj;
12595 wxImage *arg1 = (wxImage *) 0 ;
12596 bool result;
12597 PyObject * obj0 = 0 ;
12598 char *kwnames[] = {
12599 (char *) "self", NULL
12600 };
12601
12602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12604 if (SWIG_arg_fail(1)) SWIG_fail;
12605 {
12606 PyThreadState* __tstate = wxPyBeginAllowThreads();
12607 result = (bool)(arg1)->HasMask();
12608
12609 wxPyEndAllowThreads(__tstate);
12610 if (PyErr_Occurred()) SWIG_fail;
12611 }
12612 {
12613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12614 }
12615 return resultobj;
12616 fail:
12617 return NULL;
12618 }
12619
12620
12621 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12622 PyObject *resultobj;
12623 wxImage *arg1 = (wxImage *) 0 ;
12624 double arg2 ;
12625 wxPoint *arg3 = 0 ;
12626 bool arg4 = (bool) true ;
12627 wxPoint *arg5 = (wxPoint *) NULL ;
12628 SwigValueWrapper<wxImage > result;
12629 wxPoint temp3 ;
12630 PyObject * obj0 = 0 ;
12631 PyObject * obj1 = 0 ;
12632 PyObject * obj2 = 0 ;
12633 PyObject * obj3 = 0 ;
12634 PyObject * obj4 = 0 ;
12635 char *kwnames[] = {
12636 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12637 };
12638
12639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12641 if (SWIG_arg_fail(1)) SWIG_fail;
12642 {
12643 arg2 = (double)(SWIG_As_double(obj1));
12644 if (SWIG_arg_fail(2)) SWIG_fail;
12645 }
12646 {
12647 arg3 = &temp3;
12648 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12649 }
12650 if (obj3) {
12651 {
12652 arg4 = (bool)(SWIG_As_bool(obj3));
12653 if (SWIG_arg_fail(4)) SWIG_fail;
12654 }
12655 }
12656 if (obj4) {
12657 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12658 if (SWIG_arg_fail(5)) SWIG_fail;
12659 }
12660 {
12661 PyThreadState* __tstate = wxPyBeginAllowThreads();
12662 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12663
12664 wxPyEndAllowThreads(__tstate);
12665 if (PyErr_Occurred()) SWIG_fail;
12666 }
12667 {
12668 wxImage * resultptr;
12669 resultptr = new wxImage((wxImage &)(result));
12670 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12671 }
12672 return resultobj;
12673 fail:
12674 return NULL;
12675 }
12676
12677
12678 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12679 PyObject *resultobj;
12680 wxImage *arg1 = (wxImage *) 0 ;
12681 bool arg2 = (bool) true ;
12682 SwigValueWrapper<wxImage > result;
12683 PyObject * obj0 = 0 ;
12684 PyObject * obj1 = 0 ;
12685 char *kwnames[] = {
12686 (char *) "self",(char *) "clockwise", NULL
12687 };
12688
12689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12691 if (SWIG_arg_fail(1)) SWIG_fail;
12692 if (obj1) {
12693 {
12694 arg2 = (bool)(SWIG_As_bool(obj1));
12695 if (SWIG_arg_fail(2)) SWIG_fail;
12696 }
12697 }
12698 {
12699 PyThreadState* __tstate = wxPyBeginAllowThreads();
12700 result = (arg1)->Rotate90(arg2);
12701
12702 wxPyEndAllowThreads(__tstate);
12703 if (PyErr_Occurred()) SWIG_fail;
12704 }
12705 {
12706 wxImage * resultptr;
12707 resultptr = new wxImage((wxImage &)(result));
12708 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12709 }
12710 return resultobj;
12711 fail:
12712 return NULL;
12713 }
12714
12715
12716 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12717 PyObject *resultobj;
12718 wxImage *arg1 = (wxImage *) 0 ;
12719 bool arg2 = (bool) true ;
12720 SwigValueWrapper<wxImage > result;
12721 PyObject * obj0 = 0 ;
12722 PyObject * obj1 = 0 ;
12723 char *kwnames[] = {
12724 (char *) "self",(char *) "horizontally", NULL
12725 };
12726
12727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12729 if (SWIG_arg_fail(1)) SWIG_fail;
12730 if (obj1) {
12731 {
12732 arg2 = (bool)(SWIG_As_bool(obj1));
12733 if (SWIG_arg_fail(2)) SWIG_fail;
12734 }
12735 }
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 result = (arg1)->Mirror(arg2);
12739
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 {
12744 wxImage * resultptr;
12745 resultptr = new wxImage((wxImage &)(result));
12746 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12747 }
12748 return resultobj;
12749 fail:
12750 return NULL;
12751 }
12752
12753
12754 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12755 PyObject *resultobj;
12756 wxImage *arg1 = (wxImage *) 0 ;
12757 unsigned char arg2 ;
12758 unsigned char arg3 ;
12759 unsigned char arg4 ;
12760 unsigned char arg5 ;
12761 unsigned char arg6 ;
12762 unsigned char arg7 ;
12763 PyObject * obj0 = 0 ;
12764 PyObject * obj1 = 0 ;
12765 PyObject * obj2 = 0 ;
12766 PyObject * obj3 = 0 ;
12767 PyObject * obj4 = 0 ;
12768 PyObject * obj5 = 0 ;
12769 PyObject * obj6 = 0 ;
12770 char *kwnames[] = {
12771 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12772 };
12773
12774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12791 if (SWIG_arg_fail(5)) SWIG_fail;
12792 }
12793 {
12794 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12795 if (SWIG_arg_fail(6)) SWIG_fail;
12796 }
12797 {
12798 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12799 if (SWIG_arg_fail(7)) SWIG_fail;
12800 }
12801 {
12802 PyThreadState* __tstate = wxPyBeginAllowThreads();
12803 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12804
12805 wxPyEndAllowThreads(__tstate);
12806 if (PyErr_Occurred()) SWIG_fail;
12807 }
12808 Py_INCREF(Py_None); resultobj = Py_None;
12809 return resultobj;
12810 fail:
12811 return NULL;
12812 }
12813
12814
12815 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12816 PyObject *resultobj;
12817 wxImage *arg1 = (wxImage *) 0 ;
12818 unsigned char arg2 ;
12819 unsigned char arg3 ;
12820 unsigned char arg4 ;
12821 SwigValueWrapper<wxImage > result;
12822 PyObject * obj0 = 0 ;
12823 PyObject * obj1 = 0 ;
12824 PyObject * obj2 = 0 ;
12825 PyObject * obj3 = 0 ;
12826 char *kwnames[] = {
12827 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12828 };
12829
12830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12832 if (SWIG_arg_fail(1)) SWIG_fail;
12833 {
12834 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12835 if (SWIG_arg_fail(2)) SWIG_fail;
12836 }
12837 {
12838 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12839 if (SWIG_arg_fail(3)) SWIG_fail;
12840 }
12841 {
12842 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12843 if (SWIG_arg_fail(4)) SWIG_fail;
12844 }
12845 {
12846 PyThreadState* __tstate = wxPyBeginAllowThreads();
12847 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12848
12849 wxPyEndAllowThreads(__tstate);
12850 if (PyErr_Occurred()) SWIG_fail;
12851 }
12852 {
12853 wxImage * resultptr;
12854 resultptr = new wxImage((wxImage &)(result));
12855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12856 }
12857 return resultobj;
12858 fail:
12859 return NULL;
12860 }
12861
12862
12863 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12864 PyObject *resultobj;
12865 wxImage *arg1 = (wxImage *) 0 ;
12866 wxString *arg2 = 0 ;
12867 wxString *arg3 = 0 ;
12868 bool temp2 = false ;
12869 bool temp3 = 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_SetOption",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 = wxString_in_helper(obj2);
12887 if (arg3 == NULL) SWIG_fail;
12888 temp3 = true;
12889 }
12890 {
12891 PyThreadState* __tstate = wxPyBeginAllowThreads();
12892 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12893
12894 wxPyEndAllowThreads(__tstate);
12895 if (PyErr_Occurred()) SWIG_fail;
12896 }
12897 Py_INCREF(Py_None); resultobj = Py_None;
12898 {
12899 if (temp2)
12900 delete arg2;
12901 }
12902 {
12903 if (temp3)
12904 delete arg3;
12905 }
12906 return resultobj;
12907 fail:
12908 {
12909 if (temp2)
12910 delete arg2;
12911 }
12912 {
12913 if (temp3)
12914 delete arg3;
12915 }
12916 return NULL;
12917 }
12918
12919
12920 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12921 PyObject *resultobj;
12922 wxImage *arg1 = (wxImage *) 0 ;
12923 wxString *arg2 = 0 ;
12924 int arg3 ;
12925 bool temp2 = false ;
12926 PyObject * obj0 = 0 ;
12927 PyObject * obj1 = 0 ;
12928 PyObject * obj2 = 0 ;
12929 char *kwnames[] = {
12930 (char *) "self",(char *) "name",(char *) "value", NULL
12931 };
12932
12933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12935 if (SWIG_arg_fail(1)) SWIG_fail;
12936 {
12937 arg2 = wxString_in_helper(obj1);
12938 if (arg2 == NULL) SWIG_fail;
12939 temp2 = true;
12940 }
12941 {
12942 arg3 = (int)(SWIG_As_int(obj2));
12943 if (SWIG_arg_fail(3)) SWIG_fail;
12944 }
12945 {
12946 PyThreadState* __tstate = wxPyBeginAllowThreads();
12947 (arg1)->SetOption((wxString const &)*arg2,arg3);
12948
12949 wxPyEndAllowThreads(__tstate);
12950 if (PyErr_Occurred()) SWIG_fail;
12951 }
12952 Py_INCREF(Py_None); resultobj = Py_None;
12953 {
12954 if (temp2)
12955 delete arg2;
12956 }
12957 return resultobj;
12958 fail:
12959 {
12960 if (temp2)
12961 delete arg2;
12962 }
12963 return NULL;
12964 }
12965
12966
12967 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12968 PyObject *resultobj;
12969 wxImage *arg1 = (wxImage *) 0 ;
12970 wxString *arg2 = 0 ;
12971 wxString result;
12972 bool temp2 = false ;
12973 PyObject * obj0 = 0 ;
12974 PyObject * obj1 = 0 ;
12975 char *kwnames[] = {
12976 (char *) "self",(char *) "name", NULL
12977 };
12978
12979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12981 if (SWIG_arg_fail(1)) SWIG_fail;
12982 {
12983 arg2 = wxString_in_helper(obj1);
12984 if (arg2 == NULL) SWIG_fail;
12985 temp2 = true;
12986 }
12987 {
12988 PyThreadState* __tstate = wxPyBeginAllowThreads();
12989 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12990
12991 wxPyEndAllowThreads(__tstate);
12992 if (PyErr_Occurred()) SWIG_fail;
12993 }
12994 {
12995 #if wxUSE_UNICODE
12996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12997 #else
12998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12999 #endif
13000 }
13001 {
13002 if (temp2)
13003 delete arg2;
13004 }
13005 return resultobj;
13006 fail:
13007 {
13008 if (temp2)
13009 delete arg2;
13010 }
13011 return NULL;
13012 }
13013
13014
13015 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13016 PyObject *resultobj;
13017 wxImage *arg1 = (wxImage *) 0 ;
13018 wxString *arg2 = 0 ;
13019 int result;
13020 bool temp2 = false ;
13021 PyObject * obj0 = 0 ;
13022 PyObject * obj1 = 0 ;
13023 char *kwnames[] = {
13024 (char *) "self",(char *) "name", NULL
13025 };
13026
13027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13029 if (SWIG_arg_fail(1)) SWIG_fail;
13030 {
13031 arg2 = wxString_in_helper(obj1);
13032 if (arg2 == NULL) SWIG_fail;
13033 temp2 = true;
13034 }
13035 {
13036 PyThreadState* __tstate = wxPyBeginAllowThreads();
13037 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13038
13039 wxPyEndAllowThreads(__tstate);
13040 if (PyErr_Occurred()) SWIG_fail;
13041 }
13042 {
13043 resultobj = SWIG_From_int((int)(result));
13044 }
13045 {
13046 if (temp2)
13047 delete arg2;
13048 }
13049 return resultobj;
13050 fail:
13051 {
13052 if (temp2)
13053 delete arg2;
13054 }
13055 return NULL;
13056 }
13057
13058
13059 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13060 PyObject *resultobj;
13061 wxImage *arg1 = (wxImage *) 0 ;
13062 wxString *arg2 = 0 ;
13063 bool result;
13064 bool temp2 = false ;
13065 PyObject * obj0 = 0 ;
13066 PyObject * obj1 = 0 ;
13067 char *kwnames[] = {
13068 (char *) "self",(char *) "name", NULL
13069 };
13070
13071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13073 if (SWIG_arg_fail(1)) SWIG_fail;
13074 {
13075 arg2 = wxString_in_helper(obj1);
13076 if (arg2 == NULL) SWIG_fail;
13077 temp2 = true;
13078 }
13079 {
13080 PyThreadState* __tstate = wxPyBeginAllowThreads();
13081 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13082
13083 wxPyEndAllowThreads(__tstate);
13084 if (PyErr_Occurred()) SWIG_fail;
13085 }
13086 {
13087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13088 }
13089 {
13090 if (temp2)
13091 delete arg2;
13092 }
13093 return resultobj;
13094 fail:
13095 {
13096 if (temp2)
13097 delete arg2;
13098 }
13099 return NULL;
13100 }
13101
13102
13103 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13104 PyObject *resultobj;
13105 wxImage *arg1 = (wxImage *) 0 ;
13106 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13107 unsigned long result;
13108 PyObject * obj0 = 0 ;
13109 PyObject * obj1 = 0 ;
13110 char *kwnames[] = {
13111 (char *) "self",(char *) "stopafter", NULL
13112 };
13113
13114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13116 if (SWIG_arg_fail(1)) SWIG_fail;
13117 if (obj1) {
13118 {
13119 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13120 if (SWIG_arg_fail(2)) SWIG_fail;
13121 }
13122 }
13123 {
13124 PyThreadState* __tstate = wxPyBeginAllowThreads();
13125 result = (unsigned long)(arg1)->CountColours(arg2);
13126
13127 wxPyEndAllowThreads(__tstate);
13128 if (PyErr_Occurred()) SWIG_fail;
13129 }
13130 {
13131 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13132 }
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj;
13141 wxImage *arg1 = (wxImage *) 0 ;
13142 wxImageHistogram *arg2 = 0 ;
13143 unsigned long result;
13144 PyObject * obj0 = 0 ;
13145 PyObject * obj1 = 0 ;
13146 char *kwnames[] = {
13147 (char *) "self",(char *) "h", NULL
13148 };
13149
13150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13152 if (SWIG_arg_fail(1)) SWIG_fail;
13153 {
13154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13155 if (SWIG_arg_fail(2)) SWIG_fail;
13156 if (arg2 == NULL) {
13157 SWIG_null_ref("wxImageHistogram");
13158 }
13159 if (SWIG_arg_fail(2)) SWIG_fail;
13160 }
13161 {
13162 PyThreadState* __tstate = wxPyBeginAllowThreads();
13163 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13164
13165 wxPyEndAllowThreads(__tstate);
13166 if (PyErr_Occurred()) SWIG_fail;
13167 }
13168 {
13169 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13170 }
13171 return resultobj;
13172 fail:
13173 return NULL;
13174 }
13175
13176
13177 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13178 PyObject *resultobj;
13179 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13180 PyObject * obj0 = 0 ;
13181 char *kwnames[] = {
13182 (char *) "handler", NULL
13183 };
13184
13185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13187 if (SWIG_arg_fail(1)) SWIG_fail;
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 wxImage::AddHandler(arg1);
13191
13192 wxPyEndAllowThreads(__tstate);
13193 if (PyErr_Occurred()) SWIG_fail;
13194 }
13195 Py_INCREF(Py_None); resultobj = Py_None;
13196 return resultobj;
13197 fail:
13198 return NULL;
13199 }
13200
13201
13202 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13203 PyObject *resultobj;
13204 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13205 PyObject * obj0 = 0 ;
13206 char *kwnames[] = {
13207 (char *) "handler", NULL
13208 };
13209
13210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13212 if (SWIG_arg_fail(1)) SWIG_fail;
13213 {
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 wxImage::InsertHandler(arg1);
13216
13217 wxPyEndAllowThreads(__tstate);
13218 if (PyErr_Occurred()) SWIG_fail;
13219 }
13220 Py_INCREF(Py_None); resultobj = Py_None;
13221 return resultobj;
13222 fail:
13223 return NULL;
13224 }
13225
13226
13227 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13228 PyObject *resultobj;
13229 wxString *arg1 = 0 ;
13230 bool result;
13231 bool temp1 = false ;
13232 PyObject * obj0 = 0 ;
13233 char *kwnames[] = {
13234 (char *) "name", NULL
13235 };
13236
13237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13238 {
13239 arg1 = wxString_in_helper(obj0);
13240 if (arg1 == NULL) SWIG_fail;
13241 temp1 = true;
13242 }
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13246
13247 wxPyEndAllowThreads(__tstate);
13248 if (PyErr_Occurred()) SWIG_fail;
13249 }
13250 {
13251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13252 }
13253 {
13254 if (temp1)
13255 delete arg1;
13256 }
13257 return resultobj;
13258 fail:
13259 {
13260 if (temp1)
13261 delete arg1;
13262 }
13263 return NULL;
13264 }
13265
13266
13267 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13268 PyObject *resultobj;
13269 wxString result;
13270 char *kwnames[] = {
13271 NULL
13272 };
13273
13274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13275 {
13276 PyThreadState* __tstate = wxPyBeginAllowThreads();
13277 result = wxImage::GetImageExtWildcard();
13278
13279 wxPyEndAllowThreads(__tstate);
13280 if (PyErr_Occurred()) SWIG_fail;
13281 }
13282 {
13283 #if wxUSE_UNICODE
13284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13285 #else
13286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13287 #endif
13288 }
13289 return resultobj;
13290 fail:
13291 return NULL;
13292 }
13293
13294
13295 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13296 PyObject *resultobj;
13297 wxImage *arg1 = (wxImage *) 0 ;
13298 int arg2 = (int) -1 ;
13299 wxBitmap result;
13300 PyObject * obj0 = 0 ;
13301 PyObject * obj1 = 0 ;
13302 char *kwnames[] = {
13303 (char *) "self",(char *) "depth", NULL
13304 };
13305
13306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13308 if (SWIG_arg_fail(1)) SWIG_fail;
13309 if (obj1) {
13310 {
13311 arg2 = (int)(SWIG_As_int(obj1));
13312 if (SWIG_arg_fail(2)) SWIG_fail;
13313 }
13314 }
13315 {
13316 if (!wxPyCheckForApp()) SWIG_fail;
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 result = wxImage_ConvertToBitmap(arg1,arg2);
13319
13320 wxPyEndAllowThreads(__tstate);
13321 if (PyErr_Occurred()) SWIG_fail;
13322 }
13323 {
13324 wxBitmap * resultptr;
13325 resultptr = new wxBitmap((wxBitmap &)(result));
13326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13327 }
13328 return resultobj;
13329 fail:
13330 return NULL;
13331 }
13332
13333
13334 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13335 PyObject *resultobj;
13336 wxImage *arg1 = (wxImage *) 0 ;
13337 unsigned char arg2 ;
13338 unsigned char arg3 ;
13339 unsigned char arg4 ;
13340 wxBitmap result;
13341 PyObject * obj0 = 0 ;
13342 PyObject * obj1 = 0 ;
13343 PyObject * obj2 = 0 ;
13344 PyObject * obj3 = 0 ;
13345 char *kwnames[] = {
13346 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13347 };
13348
13349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13351 if (SWIG_arg_fail(1)) SWIG_fail;
13352 {
13353 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13354 if (SWIG_arg_fail(2)) SWIG_fail;
13355 }
13356 {
13357 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13358 if (SWIG_arg_fail(3)) SWIG_fail;
13359 }
13360 {
13361 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13362 if (SWIG_arg_fail(4)) SWIG_fail;
13363 }
13364 {
13365 if (!wxPyCheckForApp()) SWIG_fail;
13366 PyThreadState* __tstate = wxPyBeginAllowThreads();
13367 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13368
13369 wxPyEndAllowThreads(__tstate);
13370 if (PyErr_Occurred()) SWIG_fail;
13371 }
13372 {
13373 wxBitmap * resultptr;
13374 resultptr = new wxBitmap((wxBitmap &)(result));
13375 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13376 }
13377 return resultobj;
13378 fail:
13379 return NULL;
13380 }
13381
13382
13383 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13384 PyObject *obj;
13385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13386 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13387 Py_INCREF(obj);
13388 return Py_BuildValue((char *)"");
13389 }
13390 static int _wrap_NullImage_set(PyObject *) {
13391 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13392 return 1;
13393 }
13394
13395
13396 static PyObject *_wrap_NullImage_get(void) {
13397 PyObject *pyobj;
13398
13399 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13400 return pyobj;
13401 }
13402
13403
13404 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13405 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13406 return 1;
13407 }
13408
13409
13410 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13411 PyObject *pyobj;
13412
13413 {
13414 #if wxUSE_UNICODE
13415 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13416 #else
13417 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13418 #endif
13419 }
13420 return pyobj;
13421 }
13422
13423
13424 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13425 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13426 return 1;
13427 }
13428
13429
13430 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13431 PyObject *pyobj;
13432
13433 {
13434 #if wxUSE_UNICODE
13435 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13436 #else
13437 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13438 #endif
13439 }
13440 return pyobj;
13441 }
13442
13443
13444 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13445 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13446 return 1;
13447 }
13448
13449
13450 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13451 PyObject *pyobj;
13452
13453 {
13454 #if wxUSE_UNICODE
13455 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13456 #else
13457 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13458 #endif
13459 }
13460 return pyobj;
13461 }
13462
13463
13464 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13465 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13466 return 1;
13467 }
13468
13469
13470 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13471 PyObject *pyobj;
13472
13473 {
13474 #if wxUSE_UNICODE
13475 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13476 #else
13477 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13478 #endif
13479 }
13480 return pyobj;
13481 }
13482
13483
13484 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13485 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13486 return 1;
13487 }
13488
13489
13490 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13491 PyObject *pyobj;
13492
13493 {
13494 #if wxUSE_UNICODE
13495 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13496 #else
13497 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13498 #endif
13499 }
13500 return pyobj;
13501 }
13502
13503
13504 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13505 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13506 return 1;
13507 }
13508
13509
13510 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13511 PyObject *pyobj;
13512
13513 {
13514 #if wxUSE_UNICODE
13515 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13516 #else
13517 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13518 #endif
13519 }
13520 return pyobj;
13521 }
13522
13523
13524 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13525 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13526 return 1;
13527 }
13528
13529
13530 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13531 PyObject *pyobj;
13532
13533 {
13534 #if wxUSE_UNICODE
13535 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13536 #else
13537 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13538 #endif
13539 }
13540 return pyobj;
13541 }
13542
13543
13544 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13545 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13546 return 1;
13547 }
13548
13549
13550 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13551 PyObject *pyobj;
13552
13553 {
13554 #if wxUSE_UNICODE
13555 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13556 #else
13557 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13558 #endif
13559 }
13560 return pyobj;
13561 }
13562
13563
13564 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13565 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13566 return 1;
13567 }
13568
13569
13570 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13571 PyObject *pyobj;
13572
13573 {
13574 #if wxUSE_UNICODE
13575 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13576 #else
13577 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13578 #endif
13579 }
13580 return pyobj;
13581 }
13582
13583
13584 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13585 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13586 return 1;
13587 }
13588
13589
13590 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13591 PyObject *pyobj;
13592
13593 {
13594 #if wxUSE_UNICODE
13595 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13596 #else
13597 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13598 #endif
13599 }
13600 return pyobj;
13601 }
13602
13603
13604 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13605 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13606 return 1;
13607 }
13608
13609
13610 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13611 PyObject *pyobj;
13612
13613 {
13614 #if wxUSE_UNICODE
13615 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13616 #else
13617 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13618 #endif
13619 }
13620 return pyobj;
13621 }
13622
13623
13624 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13625 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13626 return 1;
13627 }
13628
13629
13630 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13631 PyObject *pyobj;
13632
13633 {
13634 #if wxUSE_UNICODE
13635 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13636 #else
13637 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13638 #endif
13639 }
13640 return pyobj;
13641 }
13642
13643
13644 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13645 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13646 return 1;
13647 }
13648
13649
13650 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13651 PyObject *pyobj;
13652
13653 {
13654 #if wxUSE_UNICODE
13655 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13656 #else
13657 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13658 #endif
13659 }
13660 return pyobj;
13661 }
13662
13663
13664 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
13665 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
13666 return 1;
13667 }
13668
13669
13670 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
13671 PyObject *pyobj;
13672
13673 {
13674 #if wxUSE_UNICODE
13675 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13676 #else
13677 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13678 #endif
13679 }
13680 return pyobj;
13681 }
13682
13683
13684 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
13685 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
13686 return 1;
13687 }
13688
13689
13690 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
13691 PyObject *pyobj;
13692
13693 {
13694 #if wxUSE_UNICODE
13695 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13696 #else
13697 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13698 #endif
13699 }
13700 return pyobj;
13701 }
13702
13703
13704 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13705 PyObject *resultobj;
13706 wxBMPHandler *result;
13707 char *kwnames[] = {
13708 NULL
13709 };
13710
13711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13712 {
13713 PyThreadState* __tstate = wxPyBeginAllowThreads();
13714 result = (wxBMPHandler *)new wxBMPHandler();
13715
13716 wxPyEndAllowThreads(__tstate);
13717 if (PyErr_Occurred()) SWIG_fail;
13718 }
13719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13720 return resultobj;
13721 fail:
13722 return NULL;
13723 }
13724
13725
13726 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13727 PyObject *obj;
13728 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13729 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13730 Py_INCREF(obj);
13731 return Py_BuildValue((char *)"");
13732 }
13733 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj;
13735 wxICOHandler *result;
13736 char *kwnames[] = {
13737 NULL
13738 };
13739
13740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13741 {
13742 PyThreadState* __tstate = wxPyBeginAllowThreads();
13743 result = (wxICOHandler *)new wxICOHandler();
13744
13745 wxPyEndAllowThreads(__tstate);
13746 if (PyErr_Occurred()) SWIG_fail;
13747 }
13748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13749 return resultobj;
13750 fail:
13751 return NULL;
13752 }
13753
13754
13755 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13756 PyObject *obj;
13757 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13758 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13759 Py_INCREF(obj);
13760 return Py_BuildValue((char *)"");
13761 }
13762 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13763 PyObject *resultobj;
13764 wxCURHandler *result;
13765 char *kwnames[] = {
13766 NULL
13767 };
13768
13769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13770 {
13771 PyThreadState* __tstate = wxPyBeginAllowThreads();
13772 result = (wxCURHandler *)new wxCURHandler();
13773
13774 wxPyEndAllowThreads(__tstate);
13775 if (PyErr_Occurred()) SWIG_fail;
13776 }
13777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13778 return resultobj;
13779 fail:
13780 return NULL;
13781 }
13782
13783
13784 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13785 PyObject *obj;
13786 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13787 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13788 Py_INCREF(obj);
13789 return Py_BuildValue((char *)"");
13790 }
13791 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13792 PyObject *resultobj;
13793 wxANIHandler *result;
13794 char *kwnames[] = {
13795 NULL
13796 };
13797
13798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13799 {
13800 PyThreadState* __tstate = wxPyBeginAllowThreads();
13801 result = (wxANIHandler *)new wxANIHandler();
13802
13803 wxPyEndAllowThreads(__tstate);
13804 if (PyErr_Occurred()) SWIG_fail;
13805 }
13806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13807 return resultobj;
13808 fail:
13809 return NULL;
13810 }
13811
13812
13813 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13814 PyObject *obj;
13815 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13816 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13817 Py_INCREF(obj);
13818 return Py_BuildValue((char *)"");
13819 }
13820 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13821 PyObject *resultobj;
13822 wxPNGHandler *result;
13823 char *kwnames[] = {
13824 NULL
13825 };
13826
13827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13828 {
13829 PyThreadState* __tstate = wxPyBeginAllowThreads();
13830 result = (wxPNGHandler *)new wxPNGHandler();
13831
13832 wxPyEndAllowThreads(__tstate);
13833 if (PyErr_Occurred()) SWIG_fail;
13834 }
13835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13836 return resultobj;
13837 fail:
13838 return NULL;
13839 }
13840
13841
13842 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13843 PyObject *obj;
13844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13845 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13846 Py_INCREF(obj);
13847 return Py_BuildValue((char *)"");
13848 }
13849 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13850 PyObject *resultobj;
13851 wxGIFHandler *result;
13852 char *kwnames[] = {
13853 NULL
13854 };
13855
13856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13857 {
13858 PyThreadState* __tstate = wxPyBeginAllowThreads();
13859 result = (wxGIFHandler *)new wxGIFHandler();
13860
13861 wxPyEndAllowThreads(__tstate);
13862 if (PyErr_Occurred()) SWIG_fail;
13863 }
13864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13865 return resultobj;
13866 fail:
13867 return NULL;
13868 }
13869
13870
13871 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13872 PyObject *obj;
13873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13874 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13875 Py_INCREF(obj);
13876 return Py_BuildValue((char *)"");
13877 }
13878 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13879 PyObject *resultobj;
13880 wxPCXHandler *result;
13881 char *kwnames[] = {
13882 NULL
13883 };
13884
13885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13886 {
13887 PyThreadState* __tstate = wxPyBeginAllowThreads();
13888 result = (wxPCXHandler *)new wxPCXHandler();
13889
13890 wxPyEndAllowThreads(__tstate);
13891 if (PyErr_Occurred()) SWIG_fail;
13892 }
13893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13894 return resultobj;
13895 fail:
13896 return NULL;
13897 }
13898
13899
13900 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13901 PyObject *obj;
13902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13903 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13904 Py_INCREF(obj);
13905 return Py_BuildValue((char *)"");
13906 }
13907 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13908 PyObject *resultobj;
13909 wxJPEGHandler *result;
13910 char *kwnames[] = {
13911 NULL
13912 };
13913
13914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13915 {
13916 PyThreadState* __tstate = wxPyBeginAllowThreads();
13917 result = (wxJPEGHandler *)new wxJPEGHandler();
13918
13919 wxPyEndAllowThreads(__tstate);
13920 if (PyErr_Occurred()) SWIG_fail;
13921 }
13922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13923 return resultobj;
13924 fail:
13925 return NULL;
13926 }
13927
13928
13929 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13930 PyObject *obj;
13931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13932 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13933 Py_INCREF(obj);
13934 return Py_BuildValue((char *)"");
13935 }
13936 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13937 PyObject *resultobj;
13938 wxPNMHandler *result;
13939 char *kwnames[] = {
13940 NULL
13941 };
13942
13943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13944 {
13945 PyThreadState* __tstate = wxPyBeginAllowThreads();
13946 result = (wxPNMHandler *)new wxPNMHandler();
13947
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13959 PyObject *obj;
13960 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13961 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13962 Py_INCREF(obj);
13963 return Py_BuildValue((char *)"");
13964 }
13965 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13966 PyObject *resultobj;
13967 wxXPMHandler *result;
13968 char *kwnames[] = {
13969 NULL
13970 };
13971
13972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 result = (wxXPMHandler *)new wxXPMHandler();
13976
13977 wxPyEndAllowThreads(__tstate);
13978 if (PyErr_Occurred()) SWIG_fail;
13979 }
13980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13981 return resultobj;
13982 fail:
13983 return NULL;
13984 }
13985
13986
13987 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13988 PyObject *obj;
13989 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13990 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13991 Py_INCREF(obj);
13992 return Py_BuildValue((char *)"");
13993 }
13994 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13995 PyObject *resultobj;
13996 wxTIFFHandler *result;
13997 char *kwnames[] = {
13998 NULL
13999 };
14000
14001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14002 {
14003 PyThreadState* __tstate = wxPyBeginAllowThreads();
14004 result = (wxTIFFHandler *)new wxTIFFHandler();
14005
14006 wxPyEndAllowThreads(__tstate);
14007 if (PyErr_Occurred()) SWIG_fail;
14008 }
14009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14010 return resultobj;
14011 fail:
14012 return NULL;
14013 }
14014
14015
14016 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14017 PyObject *obj;
14018 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14019 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14020 Py_INCREF(obj);
14021 return Py_BuildValue((char *)"");
14022 }
14023 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14024 PyObject *resultobj;
14025 wxImage *arg1 = 0 ;
14026 wxImage *arg2 = 0 ;
14027 int arg3 = (int) 236 ;
14028 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14029 bool result;
14030 PyObject * obj0 = 0 ;
14031 PyObject * obj1 = 0 ;
14032 PyObject * obj2 = 0 ;
14033 PyObject * obj3 = 0 ;
14034 char *kwnames[] = {
14035 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14036 };
14037
14038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14039 {
14040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14041 if (SWIG_arg_fail(1)) SWIG_fail;
14042 if (arg1 == NULL) {
14043 SWIG_null_ref("wxImage");
14044 }
14045 if (SWIG_arg_fail(1)) SWIG_fail;
14046 }
14047 {
14048 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14049 if (SWIG_arg_fail(2)) SWIG_fail;
14050 if (arg2 == NULL) {
14051 SWIG_null_ref("wxImage");
14052 }
14053 if (SWIG_arg_fail(2)) SWIG_fail;
14054 }
14055 if (obj2) {
14056 {
14057 arg3 = (int)(SWIG_As_int(obj2));
14058 if (SWIG_arg_fail(3)) SWIG_fail;
14059 }
14060 }
14061 if (obj3) {
14062 {
14063 arg4 = (int)(SWIG_As_int(obj3));
14064 if (SWIG_arg_fail(4)) SWIG_fail;
14065 }
14066 }
14067 {
14068 PyThreadState* __tstate = wxPyBeginAllowThreads();
14069 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14070
14071 wxPyEndAllowThreads(__tstate);
14072 if (PyErr_Occurred()) SWIG_fail;
14073 }
14074 {
14075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14076 }
14077 return resultobj;
14078 fail:
14079 return NULL;
14080 }
14081
14082
14083 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14084 PyObject *obj;
14085 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14086 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14087 Py_INCREF(obj);
14088 return Py_BuildValue((char *)"");
14089 }
14090 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14091 PyObject *resultobj;
14092 wxEvtHandler *result;
14093 char *kwnames[] = {
14094 NULL
14095 };
14096
14097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14098 {
14099 PyThreadState* __tstate = wxPyBeginAllowThreads();
14100 result = (wxEvtHandler *)new wxEvtHandler();
14101
14102 wxPyEndAllowThreads(__tstate);
14103 if (PyErr_Occurred()) SWIG_fail;
14104 }
14105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14106 return resultobj;
14107 fail:
14108 return NULL;
14109 }
14110
14111
14112 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14113 PyObject *resultobj;
14114 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14115 wxEvtHandler *result;
14116 PyObject * obj0 = 0 ;
14117 char *kwnames[] = {
14118 (char *) "self", NULL
14119 };
14120
14121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14123 if (SWIG_arg_fail(1)) SWIG_fail;
14124 {
14125 PyThreadState* __tstate = wxPyBeginAllowThreads();
14126 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14127
14128 wxPyEndAllowThreads(__tstate);
14129 if (PyErr_Occurred()) SWIG_fail;
14130 }
14131 {
14132 resultobj = wxPyMake_wxObject(result, 0);
14133 }
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14141 PyObject *resultobj;
14142 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14143 wxEvtHandler *result;
14144 PyObject * obj0 = 0 ;
14145 char *kwnames[] = {
14146 (char *) "self", NULL
14147 };
14148
14149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14151 if (SWIG_arg_fail(1)) SWIG_fail;
14152 {
14153 PyThreadState* __tstate = wxPyBeginAllowThreads();
14154 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14155
14156 wxPyEndAllowThreads(__tstate);
14157 if (PyErr_Occurred()) SWIG_fail;
14158 }
14159 {
14160 resultobj = wxPyMake_wxObject(result, 0);
14161 }
14162 return resultobj;
14163 fail:
14164 return NULL;
14165 }
14166
14167
14168 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14169 PyObject *resultobj;
14170 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14171 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14172 PyObject * obj0 = 0 ;
14173 PyObject * obj1 = 0 ;
14174 char *kwnames[] = {
14175 (char *) "self",(char *) "handler", NULL
14176 };
14177
14178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14180 if (SWIG_arg_fail(1)) SWIG_fail;
14181 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14182 if (SWIG_arg_fail(2)) SWIG_fail;
14183 {
14184 PyThreadState* __tstate = wxPyBeginAllowThreads();
14185 (arg1)->SetNextHandler(arg2);
14186
14187 wxPyEndAllowThreads(__tstate);
14188 if (PyErr_Occurred()) SWIG_fail;
14189 }
14190 Py_INCREF(Py_None); resultobj = Py_None;
14191 return resultobj;
14192 fail:
14193 return NULL;
14194 }
14195
14196
14197 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14198 PyObject *resultobj;
14199 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14200 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14201 PyObject * obj0 = 0 ;
14202 PyObject * obj1 = 0 ;
14203 char *kwnames[] = {
14204 (char *) "self",(char *) "handler", NULL
14205 };
14206
14207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14209 if (SWIG_arg_fail(1)) SWIG_fail;
14210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14211 if (SWIG_arg_fail(2)) SWIG_fail;
14212 {
14213 PyThreadState* __tstate = wxPyBeginAllowThreads();
14214 (arg1)->SetPreviousHandler(arg2);
14215
14216 wxPyEndAllowThreads(__tstate);
14217 if (PyErr_Occurred()) SWIG_fail;
14218 }
14219 Py_INCREF(Py_None); resultobj = Py_None;
14220 return resultobj;
14221 fail:
14222 return NULL;
14223 }
14224
14225
14226 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14227 PyObject *resultobj;
14228 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14229 bool result;
14230 PyObject * obj0 = 0 ;
14231 char *kwnames[] = {
14232 (char *) "self", NULL
14233 };
14234
14235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) 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 {
14239 PyThreadState* __tstate = wxPyBeginAllowThreads();
14240 result = (bool)(arg1)->GetEvtHandlerEnabled();
14241
14242 wxPyEndAllowThreads(__tstate);
14243 if (PyErr_Occurred()) SWIG_fail;
14244 }
14245 {
14246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14247 }
14248 return resultobj;
14249 fail:
14250 return NULL;
14251 }
14252
14253
14254 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj;
14256 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14257 bool arg2 ;
14258 PyObject * obj0 = 0 ;
14259 PyObject * obj1 = 0 ;
14260 char *kwnames[] = {
14261 (char *) "self",(char *) "enabled", NULL
14262 };
14263
14264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14266 if (SWIG_arg_fail(1)) SWIG_fail;
14267 {
14268 arg2 = (bool)(SWIG_As_bool(obj1));
14269 if (SWIG_arg_fail(2)) SWIG_fail;
14270 }
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 (arg1)->SetEvtHandlerEnabled(arg2);
14274
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 Py_INCREF(Py_None); resultobj = Py_None;
14279 return resultobj;
14280 fail:
14281 return NULL;
14282 }
14283
14284
14285 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14286 PyObject *resultobj;
14287 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14288 wxEvent *arg2 = 0 ;
14289 bool result;
14290 PyObject * obj0 = 0 ;
14291 PyObject * obj1 = 0 ;
14292 char *kwnames[] = {
14293 (char *) "self",(char *) "event", NULL
14294 };
14295
14296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14298 if (SWIG_arg_fail(1)) SWIG_fail;
14299 {
14300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14301 if (SWIG_arg_fail(2)) SWIG_fail;
14302 if (arg2 == NULL) {
14303 SWIG_null_ref("wxEvent");
14304 }
14305 if (SWIG_arg_fail(2)) SWIG_fail;
14306 }
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 result = (bool)(arg1)->ProcessEvent(*arg2);
14310
14311 wxPyEndAllowThreads(__tstate);
14312 if (PyErr_Occurred()) SWIG_fail;
14313 }
14314 {
14315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14316 }
14317 return resultobj;
14318 fail:
14319 return NULL;
14320 }
14321
14322
14323 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14324 PyObject *resultobj;
14325 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14326 wxEvent *arg2 = 0 ;
14327 PyObject * obj0 = 0 ;
14328 PyObject * obj1 = 0 ;
14329 char *kwnames[] = {
14330 (char *) "self",(char *) "event", NULL
14331 };
14332
14333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14335 if (SWIG_arg_fail(1)) SWIG_fail;
14336 {
14337 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14338 if (SWIG_arg_fail(2)) SWIG_fail;
14339 if (arg2 == NULL) {
14340 SWIG_null_ref("wxEvent");
14341 }
14342 if (SWIG_arg_fail(2)) SWIG_fail;
14343 }
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 (arg1)->AddPendingEvent(*arg2);
14347
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 Py_INCREF(Py_None); resultobj = Py_None;
14352 return resultobj;
14353 fail:
14354 return NULL;
14355 }
14356
14357
14358 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14359 PyObject *resultobj;
14360 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14361 PyObject * obj0 = 0 ;
14362 char *kwnames[] = {
14363 (char *) "self", NULL
14364 };
14365
14366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14368 if (SWIG_arg_fail(1)) SWIG_fail;
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 (arg1)->ProcessPendingEvents();
14372
14373 wxPyEndAllowThreads(__tstate);
14374 if (PyErr_Occurred()) SWIG_fail;
14375 }
14376 Py_INCREF(Py_None); resultobj = Py_None;
14377 return resultobj;
14378 fail:
14379 return NULL;
14380 }
14381
14382
14383 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14384 PyObject *resultobj;
14385 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14386 int arg2 ;
14387 int arg3 ;
14388 int arg4 ;
14389 PyObject *arg5 = (PyObject *) 0 ;
14390 PyObject * obj0 = 0 ;
14391 PyObject * obj1 = 0 ;
14392 PyObject * obj2 = 0 ;
14393 PyObject * obj3 = 0 ;
14394 PyObject * obj4 = 0 ;
14395 char *kwnames[] = {
14396 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14397 };
14398
14399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14401 if (SWIG_arg_fail(1)) SWIG_fail;
14402 {
14403 arg2 = (int)(SWIG_As_int(obj1));
14404 if (SWIG_arg_fail(2)) SWIG_fail;
14405 }
14406 {
14407 arg3 = (int)(SWIG_As_int(obj2));
14408 if (SWIG_arg_fail(3)) SWIG_fail;
14409 }
14410 {
14411 arg4 = (int)(SWIG_As_int(obj3));
14412 if (SWIG_arg_fail(4)) SWIG_fail;
14413 }
14414 arg5 = obj4;
14415 {
14416 PyThreadState* __tstate = wxPyBeginAllowThreads();
14417 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14418
14419 wxPyEndAllowThreads(__tstate);
14420 if (PyErr_Occurred()) SWIG_fail;
14421 }
14422 Py_INCREF(Py_None); resultobj = Py_None;
14423 return resultobj;
14424 fail:
14425 return NULL;
14426 }
14427
14428
14429 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14430 PyObject *resultobj;
14431 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14432 int arg2 ;
14433 int arg3 = (int) -1 ;
14434 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14435 bool result;
14436 PyObject * obj0 = 0 ;
14437 PyObject * obj1 = 0 ;
14438 PyObject * obj2 = 0 ;
14439 PyObject * obj3 = 0 ;
14440 char *kwnames[] = {
14441 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14442 };
14443
14444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14446 if (SWIG_arg_fail(1)) SWIG_fail;
14447 {
14448 arg2 = (int)(SWIG_As_int(obj1));
14449 if (SWIG_arg_fail(2)) SWIG_fail;
14450 }
14451 if (obj2) {
14452 {
14453 arg3 = (int)(SWIG_As_int(obj2));
14454 if (SWIG_arg_fail(3)) SWIG_fail;
14455 }
14456 }
14457 if (obj3) {
14458 {
14459 arg4 = (wxEventType)(SWIG_As_int(obj3));
14460 if (SWIG_arg_fail(4)) SWIG_fail;
14461 }
14462 }
14463 {
14464 PyThreadState* __tstate = wxPyBeginAllowThreads();
14465 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14466
14467 wxPyEndAllowThreads(__tstate);
14468 if (PyErr_Occurred()) SWIG_fail;
14469 }
14470 {
14471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14472 }
14473 return resultobj;
14474 fail:
14475 return NULL;
14476 }
14477
14478
14479 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14480 PyObject *resultobj;
14481 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14482 PyObject *arg2 = (PyObject *) 0 ;
14483 bool arg3 = (bool) true ;
14484 PyObject * obj0 = 0 ;
14485 PyObject * obj1 = 0 ;
14486 PyObject * obj2 = 0 ;
14487 char *kwnames[] = {
14488 (char *) "self",(char *) "_self",(char *) "incref", NULL
14489 };
14490
14491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14493 if (SWIG_arg_fail(1)) SWIG_fail;
14494 arg2 = obj1;
14495 if (obj2) {
14496 {
14497 arg3 = (bool)(SWIG_As_bool(obj2));
14498 if (SWIG_arg_fail(3)) SWIG_fail;
14499 }
14500 }
14501 {
14502 PyThreadState* __tstate = wxPyBeginAllowThreads();
14503 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14504
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 Py_INCREF(Py_None); resultobj = Py_None;
14509 return resultobj;
14510 fail:
14511 return NULL;
14512 }
14513
14514
14515 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14516 PyObject *obj;
14517 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14518 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14519 Py_INCREF(obj);
14520 return Py_BuildValue((char *)"");
14521 }
14522 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14523 PyObject *resultobj;
14524 wxEventType result;
14525 char *kwnames[] = {
14526 NULL
14527 };
14528
14529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14530 {
14531 PyThreadState* __tstate = wxPyBeginAllowThreads();
14532 result = (wxEventType)wxNewEventType();
14533
14534 wxPyEndAllowThreads(__tstate);
14535 if (PyErr_Occurred()) SWIG_fail;
14536 }
14537 {
14538 resultobj = SWIG_From_int((int)(result));
14539 }
14540 return resultobj;
14541 fail:
14542 return NULL;
14543 }
14544
14545
14546 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14547 PyObject *resultobj;
14548 wxEvent *arg1 = (wxEvent *) 0 ;
14549 PyObject * obj0 = 0 ;
14550 char *kwnames[] = {
14551 (char *) "self", NULL
14552 };
14553
14554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14556 if (SWIG_arg_fail(1)) SWIG_fail;
14557 {
14558 PyThreadState* __tstate = wxPyBeginAllowThreads();
14559 delete arg1;
14560
14561 wxPyEndAllowThreads(__tstate);
14562 if (PyErr_Occurred()) SWIG_fail;
14563 }
14564 Py_INCREF(Py_None); resultobj = Py_None;
14565 return resultobj;
14566 fail:
14567 return NULL;
14568 }
14569
14570
14571 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14572 PyObject *resultobj;
14573 wxEvent *arg1 = (wxEvent *) 0 ;
14574 wxEventType arg2 ;
14575 PyObject * obj0 = 0 ;
14576 PyObject * obj1 = 0 ;
14577 char *kwnames[] = {
14578 (char *) "self",(char *) "typ", NULL
14579 };
14580
14581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14583 if (SWIG_arg_fail(1)) SWIG_fail;
14584 {
14585 arg2 = (wxEventType)(SWIG_As_int(obj1));
14586 if (SWIG_arg_fail(2)) SWIG_fail;
14587 }
14588 {
14589 PyThreadState* __tstate = wxPyBeginAllowThreads();
14590 (arg1)->SetEventType(arg2);
14591
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 Py_INCREF(Py_None); resultobj = Py_None;
14596 return resultobj;
14597 fail:
14598 return NULL;
14599 }
14600
14601
14602 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14603 PyObject *resultobj;
14604 wxEvent *arg1 = (wxEvent *) 0 ;
14605 wxEventType result;
14606 PyObject * obj0 = 0 ;
14607 char *kwnames[] = {
14608 (char *) "self", NULL
14609 };
14610
14611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14613 if (SWIG_arg_fail(1)) SWIG_fail;
14614 {
14615 PyThreadState* __tstate = wxPyBeginAllowThreads();
14616 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14617
14618 wxPyEndAllowThreads(__tstate);
14619 if (PyErr_Occurred()) SWIG_fail;
14620 }
14621 {
14622 resultobj = SWIG_From_int((int)(result));
14623 }
14624 return resultobj;
14625 fail:
14626 return NULL;
14627 }
14628
14629
14630 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14631 PyObject *resultobj;
14632 wxEvent *arg1 = (wxEvent *) 0 ;
14633 wxObject *result;
14634 PyObject * obj0 = 0 ;
14635 char *kwnames[] = {
14636 (char *) "self", NULL
14637 };
14638
14639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14641 if (SWIG_arg_fail(1)) SWIG_fail;
14642 {
14643 PyThreadState* __tstate = wxPyBeginAllowThreads();
14644 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14645
14646 wxPyEndAllowThreads(__tstate);
14647 if (PyErr_Occurred()) SWIG_fail;
14648 }
14649 {
14650 resultobj = wxPyMake_wxObject(result, 0);
14651 }
14652 return resultobj;
14653 fail:
14654 return NULL;
14655 }
14656
14657
14658 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14659 PyObject *resultobj;
14660 wxEvent *arg1 = (wxEvent *) 0 ;
14661 wxObject *arg2 = (wxObject *) 0 ;
14662 PyObject * obj0 = 0 ;
14663 PyObject * obj1 = 0 ;
14664 char *kwnames[] = {
14665 (char *) "self",(char *) "obj", NULL
14666 };
14667
14668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14670 if (SWIG_arg_fail(1)) SWIG_fail;
14671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14672 if (SWIG_arg_fail(2)) SWIG_fail;
14673 {
14674 PyThreadState* __tstate = wxPyBeginAllowThreads();
14675 (arg1)->SetEventObject(arg2);
14676
14677 wxPyEndAllowThreads(__tstate);
14678 if (PyErr_Occurred()) SWIG_fail;
14679 }
14680 Py_INCREF(Py_None); resultobj = Py_None;
14681 return resultobj;
14682 fail:
14683 return NULL;
14684 }
14685
14686
14687 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14688 PyObject *resultobj;
14689 wxEvent *arg1 = (wxEvent *) 0 ;
14690 long result;
14691 PyObject * obj0 = 0 ;
14692 char *kwnames[] = {
14693 (char *) "self", NULL
14694 };
14695
14696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14698 if (SWIG_arg_fail(1)) SWIG_fail;
14699 {
14700 PyThreadState* __tstate = wxPyBeginAllowThreads();
14701 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14702
14703 wxPyEndAllowThreads(__tstate);
14704 if (PyErr_Occurred()) SWIG_fail;
14705 }
14706 {
14707 resultobj = SWIG_From_long((long)(result));
14708 }
14709 return resultobj;
14710 fail:
14711 return NULL;
14712 }
14713
14714
14715 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14716 PyObject *resultobj;
14717 wxEvent *arg1 = (wxEvent *) 0 ;
14718 long arg2 = (long) 0 ;
14719 PyObject * obj0 = 0 ;
14720 PyObject * obj1 = 0 ;
14721 char *kwnames[] = {
14722 (char *) "self",(char *) "ts", NULL
14723 };
14724
14725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14727 if (SWIG_arg_fail(1)) SWIG_fail;
14728 if (obj1) {
14729 {
14730 arg2 = (long)(SWIG_As_long(obj1));
14731 if (SWIG_arg_fail(2)) SWIG_fail;
14732 }
14733 }
14734 {
14735 PyThreadState* __tstate = wxPyBeginAllowThreads();
14736 (arg1)->SetTimestamp(arg2);
14737
14738 wxPyEndAllowThreads(__tstate);
14739 if (PyErr_Occurred()) SWIG_fail;
14740 }
14741 Py_INCREF(Py_None); resultobj = Py_None;
14742 return resultobj;
14743 fail:
14744 return NULL;
14745 }
14746
14747
14748 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14749 PyObject *resultobj;
14750 wxEvent *arg1 = (wxEvent *) 0 ;
14751 int result;
14752 PyObject * obj0 = 0 ;
14753 char *kwnames[] = {
14754 (char *) "self", NULL
14755 };
14756
14757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14759 if (SWIG_arg_fail(1)) SWIG_fail;
14760 {
14761 PyThreadState* __tstate = wxPyBeginAllowThreads();
14762 result = (int)((wxEvent const *)arg1)->GetId();
14763
14764 wxPyEndAllowThreads(__tstate);
14765 if (PyErr_Occurred()) SWIG_fail;
14766 }
14767 {
14768 resultobj = SWIG_From_int((int)(result));
14769 }
14770 return resultobj;
14771 fail:
14772 return NULL;
14773 }
14774
14775
14776 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14777 PyObject *resultobj;
14778 wxEvent *arg1 = (wxEvent *) 0 ;
14779 int arg2 ;
14780 PyObject * obj0 = 0 ;
14781 PyObject * obj1 = 0 ;
14782 char *kwnames[] = {
14783 (char *) "self",(char *) "Id", NULL
14784 };
14785
14786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14788 if (SWIG_arg_fail(1)) SWIG_fail;
14789 {
14790 arg2 = (int)(SWIG_As_int(obj1));
14791 if (SWIG_arg_fail(2)) SWIG_fail;
14792 }
14793 {
14794 PyThreadState* __tstate = wxPyBeginAllowThreads();
14795 (arg1)->SetId(arg2);
14796
14797 wxPyEndAllowThreads(__tstate);
14798 if (PyErr_Occurred()) SWIG_fail;
14799 }
14800 Py_INCREF(Py_None); resultobj = Py_None;
14801 return resultobj;
14802 fail:
14803 return NULL;
14804 }
14805
14806
14807 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14808 PyObject *resultobj;
14809 wxEvent *arg1 = (wxEvent *) 0 ;
14810 bool result;
14811 PyObject * obj0 = 0 ;
14812 char *kwnames[] = {
14813 (char *) "self", NULL
14814 };
14815
14816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14818 if (SWIG_arg_fail(1)) SWIG_fail;
14819 {
14820 PyThreadState* __tstate = wxPyBeginAllowThreads();
14821 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14822
14823 wxPyEndAllowThreads(__tstate);
14824 if (PyErr_Occurred()) SWIG_fail;
14825 }
14826 {
14827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14828 }
14829 return resultobj;
14830 fail:
14831 return NULL;
14832 }
14833
14834
14835 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14836 PyObject *resultobj;
14837 wxEvent *arg1 = (wxEvent *) 0 ;
14838 bool arg2 = (bool) true ;
14839 PyObject * obj0 = 0 ;
14840 PyObject * obj1 = 0 ;
14841 char *kwnames[] = {
14842 (char *) "self",(char *) "skip", NULL
14843 };
14844
14845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14847 if (SWIG_arg_fail(1)) SWIG_fail;
14848 if (obj1) {
14849 {
14850 arg2 = (bool)(SWIG_As_bool(obj1));
14851 if (SWIG_arg_fail(2)) SWIG_fail;
14852 }
14853 }
14854 {
14855 PyThreadState* __tstate = wxPyBeginAllowThreads();
14856 (arg1)->Skip(arg2);
14857
14858 wxPyEndAllowThreads(__tstate);
14859 if (PyErr_Occurred()) SWIG_fail;
14860 }
14861 Py_INCREF(Py_None); resultobj = Py_None;
14862 return resultobj;
14863 fail:
14864 return NULL;
14865 }
14866
14867
14868 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14869 PyObject *resultobj;
14870 wxEvent *arg1 = (wxEvent *) 0 ;
14871 bool result;
14872 PyObject * obj0 = 0 ;
14873 char *kwnames[] = {
14874 (char *) "self", NULL
14875 };
14876
14877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14879 if (SWIG_arg_fail(1)) SWIG_fail;
14880 {
14881 PyThreadState* __tstate = wxPyBeginAllowThreads();
14882 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14883
14884 wxPyEndAllowThreads(__tstate);
14885 if (PyErr_Occurred()) SWIG_fail;
14886 }
14887 {
14888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14889 }
14890 return resultobj;
14891 fail:
14892 return NULL;
14893 }
14894
14895
14896 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14897 PyObject *resultobj;
14898 wxEvent *arg1 = (wxEvent *) 0 ;
14899 bool result;
14900 PyObject * obj0 = 0 ;
14901 char *kwnames[] = {
14902 (char *) "self", NULL
14903 };
14904
14905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14907 if (SWIG_arg_fail(1)) SWIG_fail;
14908 {
14909 PyThreadState* __tstate = wxPyBeginAllowThreads();
14910 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14911
14912 wxPyEndAllowThreads(__tstate);
14913 if (PyErr_Occurred()) SWIG_fail;
14914 }
14915 {
14916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14917 }
14918 return resultobj;
14919 fail:
14920 return NULL;
14921 }
14922
14923
14924 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14925 PyObject *resultobj;
14926 wxEvent *arg1 = (wxEvent *) 0 ;
14927 int result;
14928 PyObject * obj0 = 0 ;
14929 char *kwnames[] = {
14930 (char *) "self", NULL
14931 };
14932
14933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14935 if (SWIG_arg_fail(1)) SWIG_fail;
14936 {
14937 PyThreadState* __tstate = wxPyBeginAllowThreads();
14938 result = (int)(arg1)->StopPropagation();
14939
14940 wxPyEndAllowThreads(__tstate);
14941 if (PyErr_Occurred()) SWIG_fail;
14942 }
14943 {
14944 resultobj = SWIG_From_int((int)(result));
14945 }
14946 return resultobj;
14947 fail:
14948 return NULL;
14949 }
14950
14951
14952 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14953 PyObject *resultobj;
14954 wxEvent *arg1 = (wxEvent *) 0 ;
14955 int arg2 ;
14956 PyObject * obj0 = 0 ;
14957 PyObject * obj1 = 0 ;
14958 char *kwnames[] = {
14959 (char *) "self",(char *) "propagationLevel", NULL
14960 };
14961
14962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14964 if (SWIG_arg_fail(1)) SWIG_fail;
14965 {
14966 arg2 = (int)(SWIG_As_int(obj1));
14967 if (SWIG_arg_fail(2)) SWIG_fail;
14968 }
14969 {
14970 PyThreadState* __tstate = wxPyBeginAllowThreads();
14971 (arg1)->ResumePropagation(arg2);
14972
14973 wxPyEndAllowThreads(__tstate);
14974 if (PyErr_Occurred()) SWIG_fail;
14975 }
14976 Py_INCREF(Py_None); resultobj = Py_None;
14977 return resultobj;
14978 fail:
14979 return NULL;
14980 }
14981
14982
14983 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14984 PyObject *resultobj;
14985 wxEvent *arg1 = (wxEvent *) 0 ;
14986 wxEvent *result;
14987 PyObject * obj0 = 0 ;
14988 char *kwnames[] = {
14989 (char *) "self", NULL
14990 };
14991
14992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14994 if (SWIG_arg_fail(1)) SWIG_fail;
14995 {
14996 PyThreadState* __tstate = wxPyBeginAllowThreads();
14997 result = (wxEvent *)(arg1)->Clone();
14998
14999 wxPyEndAllowThreads(__tstate);
15000 if (PyErr_Occurred()) SWIG_fail;
15001 }
15002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15003 return resultobj;
15004 fail:
15005 return NULL;
15006 }
15007
15008
15009 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15010 PyObject *obj;
15011 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15012 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15013 Py_INCREF(obj);
15014 return Py_BuildValue((char *)"");
15015 }
15016 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15017 PyObject *resultobj;
15018 wxEvent *arg1 = 0 ;
15019 wxPropagationDisabler *result;
15020 PyObject * obj0 = 0 ;
15021 char *kwnames[] = {
15022 (char *) "event", NULL
15023 };
15024
15025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15026 {
15027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15028 if (SWIG_arg_fail(1)) SWIG_fail;
15029 if (arg1 == NULL) {
15030 SWIG_null_ref("wxEvent");
15031 }
15032 if (SWIG_arg_fail(1)) SWIG_fail;
15033 }
15034 {
15035 PyThreadState* __tstate = wxPyBeginAllowThreads();
15036 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15037
15038 wxPyEndAllowThreads(__tstate);
15039 if (PyErr_Occurred()) SWIG_fail;
15040 }
15041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15042 return resultobj;
15043 fail:
15044 return NULL;
15045 }
15046
15047
15048 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15049 PyObject *resultobj;
15050 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15051 PyObject * obj0 = 0 ;
15052 char *kwnames[] = {
15053 (char *) "self", NULL
15054 };
15055
15056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15058 if (SWIG_arg_fail(1)) SWIG_fail;
15059 {
15060 PyThreadState* __tstate = wxPyBeginAllowThreads();
15061 delete arg1;
15062
15063 wxPyEndAllowThreads(__tstate);
15064 if (PyErr_Occurred()) SWIG_fail;
15065 }
15066 Py_INCREF(Py_None); resultobj = Py_None;
15067 return resultobj;
15068 fail:
15069 return NULL;
15070 }
15071
15072
15073 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15074 PyObject *obj;
15075 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15076 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15077 Py_INCREF(obj);
15078 return Py_BuildValue((char *)"");
15079 }
15080 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15081 PyObject *resultobj;
15082 wxEvent *arg1 = 0 ;
15083 wxPropagateOnce *result;
15084 PyObject * obj0 = 0 ;
15085 char *kwnames[] = {
15086 (char *) "event", NULL
15087 };
15088
15089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15090 {
15091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15092 if (SWIG_arg_fail(1)) SWIG_fail;
15093 if (arg1 == NULL) {
15094 SWIG_null_ref("wxEvent");
15095 }
15096 if (SWIG_arg_fail(1)) SWIG_fail;
15097 }
15098 {
15099 PyThreadState* __tstate = wxPyBeginAllowThreads();
15100 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15101
15102 wxPyEndAllowThreads(__tstate);
15103 if (PyErr_Occurred()) SWIG_fail;
15104 }
15105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15106 return resultobj;
15107 fail:
15108 return NULL;
15109 }
15110
15111
15112 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15113 PyObject *resultobj;
15114 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15115 PyObject * obj0 = 0 ;
15116 char *kwnames[] = {
15117 (char *) "self", NULL
15118 };
15119
15120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15122 if (SWIG_arg_fail(1)) SWIG_fail;
15123 {
15124 PyThreadState* __tstate = wxPyBeginAllowThreads();
15125 delete arg1;
15126
15127 wxPyEndAllowThreads(__tstate);
15128 if (PyErr_Occurred()) SWIG_fail;
15129 }
15130 Py_INCREF(Py_None); resultobj = Py_None;
15131 return resultobj;
15132 fail:
15133 return NULL;
15134 }
15135
15136
15137 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15138 PyObject *obj;
15139 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15140 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15141 Py_INCREF(obj);
15142 return Py_BuildValue((char *)"");
15143 }
15144 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15145 PyObject *resultobj;
15146 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15147 int arg2 = (int) 0 ;
15148 wxCommandEvent *result;
15149 PyObject * obj0 = 0 ;
15150 PyObject * obj1 = 0 ;
15151 char *kwnames[] = {
15152 (char *) "commandType",(char *) "winid", NULL
15153 };
15154
15155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15156 if (obj0) {
15157 {
15158 arg1 = (wxEventType)(SWIG_As_int(obj0));
15159 if (SWIG_arg_fail(1)) SWIG_fail;
15160 }
15161 }
15162 if (obj1) {
15163 {
15164 arg2 = (int)(SWIG_As_int(obj1));
15165 if (SWIG_arg_fail(2)) SWIG_fail;
15166 }
15167 }
15168 {
15169 PyThreadState* __tstate = wxPyBeginAllowThreads();
15170 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15171
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15176 return resultobj;
15177 fail:
15178 return NULL;
15179 }
15180
15181
15182 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15183 PyObject *resultobj;
15184 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15185 int result;
15186 PyObject * obj0 = 0 ;
15187 char *kwnames[] = {
15188 (char *) "self", NULL
15189 };
15190
15191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15193 if (SWIG_arg_fail(1)) SWIG_fail;
15194 {
15195 PyThreadState* __tstate = wxPyBeginAllowThreads();
15196 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15197
15198 wxPyEndAllowThreads(__tstate);
15199 if (PyErr_Occurred()) SWIG_fail;
15200 }
15201 {
15202 resultobj = SWIG_From_int((int)(result));
15203 }
15204 return resultobj;
15205 fail:
15206 return NULL;
15207 }
15208
15209
15210 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15211 PyObject *resultobj;
15212 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15213 wxString *arg2 = 0 ;
15214 bool temp2 = false ;
15215 PyObject * obj0 = 0 ;
15216 PyObject * obj1 = 0 ;
15217 char *kwnames[] = {
15218 (char *) "self",(char *) "s", NULL
15219 };
15220
15221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15223 if (SWIG_arg_fail(1)) SWIG_fail;
15224 {
15225 arg2 = wxString_in_helper(obj1);
15226 if (arg2 == NULL) SWIG_fail;
15227 temp2 = true;
15228 }
15229 {
15230 PyThreadState* __tstate = wxPyBeginAllowThreads();
15231 (arg1)->SetString((wxString const &)*arg2);
15232
15233 wxPyEndAllowThreads(__tstate);
15234 if (PyErr_Occurred()) SWIG_fail;
15235 }
15236 Py_INCREF(Py_None); resultobj = Py_None;
15237 {
15238 if (temp2)
15239 delete arg2;
15240 }
15241 return resultobj;
15242 fail:
15243 {
15244 if (temp2)
15245 delete arg2;
15246 }
15247 return NULL;
15248 }
15249
15250
15251 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15252 PyObject *resultobj;
15253 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15254 wxString result;
15255 PyObject * obj0 = 0 ;
15256 char *kwnames[] = {
15257 (char *) "self", NULL
15258 };
15259
15260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15262 if (SWIG_arg_fail(1)) SWIG_fail;
15263 {
15264 PyThreadState* __tstate = wxPyBeginAllowThreads();
15265 result = ((wxCommandEvent const *)arg1)->GetString();
15266
15267 wxPyEndAllowThreads(__tstate);
15268 if (PyErr_Occurred()) SWIG_fail;
15269 }
15270 {
15271 #if wxUSE_UNICODE
15272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15273 #else
15274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15275 #endif
15276 }
15277 return resultobj;
15278 fail:
15279 return NULL;
15280 }
15281
15282
15283 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15284 PyObject *resultobj;
15285 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15286 bool result;
15287 PyObject * obj0 = 0 ;
15288 char *kwnames[] = {
15289 (char *) "self", NULL
15290 };
15291
15292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15294 if (SWIG_arg_fail(1)) SWIG_fail;
15295 {
15296 PyThreadState* __tstate = wxPyBeginAllowThreads();
15297 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15298
15299 wxPyEndAllowThreads(__tstate);
15300 if (PyErr_Occurred()) SWIG_fail;
15301 }
15302 {
15303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15304 }
15305 return resultobj;
15306 fail:
15307 return NULL;
15308 }
15309
15310
15311 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15312 PyObject *resultobj;
15313 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15314 bool result;
15315 PyObject * obj0 = 0 ;
15316 char *kwnames[] = {
15317 (char *) "self", NULL
15318 };
15319
15320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15322 if (SWIG_arg_fail(1)) SWIG_fail;
15323 {
15324 PyThreadState* __tstate = wxPyBeginAllowThreads();
15325 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15326
15327 wxPyEndAllowThreads(__tstate);
15328 if (PyErr_Occurred()) SWIG_fail;
15329 }
15330 {
15331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15332 }
15333 return resultobj;
15334 fail:
15335 return NULL;
15336 }
15337
15338
15339 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15340 PyObject *resultobj;
15341 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15342 long arg2 ;
15343 PyObject * obj0 = 0 ;
15344 PyObject * obj1 = 0 ;
15345 char *kwnames[] = {
15346 (char *) "self",(char *) "extraLong", NULL
15347 };
15348
15349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15351 if (SWIG_arg_fail(1)) SWIG_fail;
15352 {
15353 arg2 = (long)(SWIG_As_long(obj1));
15354 if (SWIG_arg_fail(2)) SWIG_fail;
15355 }
15356 {
15357 PyThreadState* __tstate = wxPyBeginAllowThreads();
15358 (arg1)->SetExtraLong(arg2);
15359
15360 wxPyEndAllowThreads(__tstate);
15361 if (PyErr_Occurred()) SWIG_fail;
15362 }
15363 Py_INCREF(Py_None); resultobj = Py_None;
15364 return resultobj;
15365 fail:
15366 return NULL;
15367 }
15368
15369
15370 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15371 PyObject *resultobj;
15372 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15373 long result;
15374 PyObject * obj0 = 0 ;
15375 char *kwnames[] = {
15376 (char *) "self", NULL
15377 };
15378
15379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15381 if (SWIG_arg_fail(1)) SWIG_fail;
15382 {
15383 PyThreadState* __tstate = wxPyBeginAllowThreads();
15384 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15385
15386 wxPyEndAllowThreads(__tstate);
15387 if (PyErr_Occurred()) SWIG_fail;
15388 }
15389 {
15390 resultobj = SWIG_From_long((long)(result));
15391 }
15392 return resultobj;
15393 fail:
15394 return NULL;
15395 }
15396
15397
15398 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15399 PyObject *resultobj;
15400 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15401 int arg2 ;
15402 PyObject * obj0 = 0 ;
15403 PyObject * obj1 = 0 ;
15404 char *kwnames[] = {
15405 (char *) "self",(char *) "i", NULL
15406 };
15407
15408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15410 if (SWIG_arg_fail(1)) SWIG_fail;
15411 {
15412 arg2 = (int)(SWIG_As_int(obj1));
15413 if (SWIG_arg_fail(2)) SWIG_fail;
15414 }
15415 {
15416 PyThreadState* __tstate = wxPyBeginAllowThreads();
15417 (arg1)->SetInt(arg2);
15418
15419 wxPyEndAllowThreads(__tstate);
15420 if (PyErr_Occurred()) SWIG_fail;
15421 }
15422 Py_INCREF(Py_None); resultobj = Py_None;
15423 return resultobj;
15424 fail:
15425 return NULL;
15426 }
15427
15428
15429 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15430 PyObject *resultobj;
15431 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15432 long result;
15433 PyObject * obj0 = 0 ;
15434 char *kwnames[] = {
15435 (char *) "self", NULL
15436 };
15437
15438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15440 if (SWIG_arg_fail(1)) SWIG_fail;
15441 {
15442 PyThreadState* __tstate = wxPyBeginAllowThreads();
15443 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15444
15445 wxPyEndAllowThreads(__tstate);
15446 if (PyErr_Occurred()) SWIG_fail;
15447 }
15448 {
15449 resultobj = SWIG_From_long((long)(result));
15450 }
15451 return resultobj;
15452 fail:
15453 return NULL;
15454 }
15455
15456
15457 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15458 PyObject *resultobj;
15459 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15460 wxEvent *result;
15461 PyObject * obj0 = 0 ;
15462 char *kwnames[] = {
15463 (char *) "self", NULL
15464 };
15465
15466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15468 if (SWIG_arg_fail(1)) SWIG_fail;
15469 {
15470 PyThreadState* __tstate = wxPyBeginAllowThreads();
15471 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15472
15473 wxPyEndAllowThreads(__tstate);
15474 if (PyErr_Occurred()) SWIG_fail;
15475 }
15476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15477 return resultobj;
15478 fail:
15479 return NULL;
15480 }
15481
15482
15483 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15484 PyObject *obj;
15485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15486 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15487 Py_INCREF(obj);
15488 return Py_BuildValue((char *)"");
15489 }
15490 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15491 PyObject *resultobj;
15492 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15493 int arg2 = (int) 0 ;
15494 wxNotifyEvent *result;
15495 PyObject * obj0 = 0 ;
15496 PyObject * obj1 = 0 ;
15497 char *kwnames[] = {
15498 (char *) "commandType",(char *) "winid", NULL
15499 };
15500
15501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15502 if (obj0) {
15503 {
15504 arg1 = (wxEventType)(SWIG_As_int(obj0));
15505 if (SWIG_arg_fail(1)) SWIG_fail;
15506 }
15507 }
15508 if (obj1) {
15509 {
15510 arg2 = (int)(SWIG_As_int(obj1));
15511 if (SWIG_arg_fail(2)) SWIG_fail;
15512 }
15513 }
15514 {
15515 PyThreadState* __tstate = wxPyBeginAllowThreads();
15516 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15517
15518 wxPyEndAllowThreads(__tstate);
15519 if (PyErr_Occurred()) SWIG_fail;
15520 }
15521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15522 return resultobj;
15523 fail:
15524 return NULL;
15525 }
15526
15527
15528 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15529 PyObject *resultobj;
15530 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15531 PyObject * obj0 = 0 ;
15532 char *kwnames[] = {
15533 (char *) "self", NULL
15534 };
15535
15536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15538 if (SWIG_arg_fail(1)) SWIG_fail;
15539 {
15540 PyThreadState* __tstate = wxPyBeginAllowThreads();
15541 (arg1)->Veto();
15542
15543 wxPyEndAllowThreads(__tstate);
15544 if (PyErr_Occurred()) SWIG_fail;
15545 }
15546 Py_INCREF(Py_None); resultobj = Py_None;
15547 return resultobj;
15548 fail:
15549 return NULL;
15550 }
15551
15552
15553 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15554 PyObject *resultobj;
15555 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15556 PyObject * obj0 = 0 ;
15557 char *kwnames[] = {
15558 (char *) "self", NULL
15559 };
15560
15561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15563 if (SWIG_arg_fail(1)) SWIG_fail;
15564 {
15565 PyThreadState* __tstate = wxPyBeginAllowThreads();
15566 (arg1)->Allow();
15567
15568 wxPyEndAllowThreads(__tstate);
15569 if (PyErr_Occurred()) SWIG_fail;
15570 }
15571 Py_INCREF(Py_None); resultobj = Py_None;
15572 return resultobj;
15573 fail:
15574 return NULL;
15575 }
15576
15577
15578 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15579 PyObject *resultobj;
15580 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15581 bool result;
15582 PyObject * obj0 = 0 ;
15583 char *kwnames[] = {
15584 (char *) "self", NULL
15585 };
15586
15587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15589 if (SWIG_arg_fail(1)) SWIG_fail;
15590 {
15591 PyThreadState* __tstate = wxPyBeginAllowThreads();
15592 result = (bool)(arg1)->IsAllowed();
15593
15594 wxPyEndAllowThreads(__tstate);
15595 if (PyErr_Occurred()) SWIG_fail;
15596 }
15597 {
15598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15599 }
15600 return resultobj;
15601 fail:
15602 return NULL;
15603 }
15604
15605
15606 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15607 PyObject *obj;
15608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15609 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15610 Py_INCREF(obj);
15611 return Py_BuildValue((char *)"");
15612 }
15613 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15614 PyObject *resultobj;
15615 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15616 int arg2 = (int) 0 ;
15617 int arg3 = (int) 0 ;
15618 int arg4 = (int) 0 ;
15619 wxScrollEvent *result;
15620 PyObject * obj0 = 0 ;
15621 PyObject * obj1 = 0 ;
15622 PyObject * obj2 = 0 ;
15623 PyObject * obj3 = 0 ;
15624 char *kwnames[] = {
15625 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15626 };
15627
15628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15629 if (obj0) {
15630 {
15631 arg1 = (wxEventType)(SWIG_As_int(obj0));
15632 if (SWIG_arg_fail(1)) SWIG_fail;
15633 }
15634 }
15635 if (obj1) {
15636 {
15637 arg2 = (int)(SWIG_As_int(obj1));
15638 if (SWIG_arg_fail(2)) SWIG_fail;
15639 }
15640 }
15641 if (obj2) {
15642 {
15643 arg3 = (int)(SWIG_As_int(obj2));
15644 if (SWIG_arg_fail(3)) SWIG_fail;
15645 }
15646 }
15647 if (obj3) {
15648 {
15649 arg4 = (int)(SWIG_As_int(obj3));
15650 if (SWIG_arg_fail(4)) SWIG_fail;
15651 }
15652 }
15653 {
15654 PyThreadState* __tstate = wxPyBeginAllowThreads();
15655 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15656
15657 wxPyEndAllowThreads(__tstate);
15658 if (PyErr_Occurred()) SWIG_fail;
15659 }
15660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15661 return resultobj;
15662 fail:
15663 return NULL;
15664 }
15665
15666
15667 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15668 PyObject *resultobj;
15669 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15670 int result;
15671 PyObject * obj0 = 0 ;
15672 char *kwnames[] = {
15673 (char *) "self", NULL
15674 };
15675
15676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15678 if (SWIG_arg_fail(1)) SWIG_fail;
15679 {
15680 PyThreadState* __tstate = wxPyBeginAllowThreads();
15681 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15682
15683 wxPyEndAllowThreads(__tstate);
15684 if (PyErr_Occurred()) SWIG_fail;
15685 }
15686 {
15687 resultobj = SWIG_From_int((int)(result));
15688 }
15689 return resultobj;
15690 fail:
15691 return NULL;
15692 }
15693
15694
15695 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15696 PyObject *resultobj;
15697 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15698 int result;
15699 PyObject * obj0 = 0 ;
15700 char *kwnames[] = {
15701 (char *) "self", NULL
15702 };
15703
15704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15706 if (SWIG_arg_fail(1)) SWIG_fail;
15707 {
15708 PyThreadState* __tstate = wxPyBeginAllowThreads();
15709 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15710
15711 wxPyEndAllowThreads(__tstate);
15712 if (PyErr_Occurred()) SWIG_fail;
15713 }
15714 {
15715 resultobj = SWIG_From_int((int)(result));
15716 }
15717 return resultobj;
15718 fail:
15719 return NULL;
15720 }
15721
15722
15723 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15724 PyObject *resultobj;
15725 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15726 int arg2 ;
15727 PyObject * obj0 = 0 ;
15728 PyObject * obj1 = 0 ;
15729 char *kwnames[] = {
15730 (char *) "self",(char *) "orient", NULL
15731 };
15732
15733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15735 if (SWIG_arg_fail(1)) SWIG_fail;
15736 {
15737 arg2 = (int)(SWIG_As_int(obj1));
15738 if (SWIG_arg_fail(2)) SWIG_fail;
15739 }
15740 {
15741 PyThreadState* __tstate = wxPyBeginAllowThreads();
15742 (arg1)->SetOrientation(arg2);
15743
15744 wxPyEndAllowThreads(__tstate);
15745 if (PyErr_Occurred()) SWIG_fail;
15746 }
15747 Py_INCREF(Py_None); resultobj = Py_None;
15748 return resultobj;
15749 fail:
15750 return NULL;
15751 }
15752
15753
15754 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15755 PyObject *resultobj;
15756 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15757 int arg2 ;
15758 PyObject * obj0 = 0 ;
15759 PyObject * obj1 = 0 ;
15760 char *kwnames[] = {
15761 (char *) "self",(char *) "pos", NULL
15762 };
15763
15764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15766 if (SWIG_arg_fail(1)) SWIG_fail;
15767 {
15768 arg2 = (int)(SWIG_As_int(obj1));
15769 if (SWIG_arg_fail(2)) SWIG_fail;
15770 }
15771 {
15772 PyThreadState* __tstate = wxPyBeginAllowThreads();
15773 (arg1)->SetPosition(arg2);
15774
15775 wxPyEndAllowThreads(__tstate);
15776 if (PyErr_Occurred()) SWIG_fail;
15777 }
15778 Py_INCREF(Py_None); resultobj = Py_None;
15779 return resultobj;
15780 fail:
15781 return NULL;
15782 }
15783
15784
15785 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15786 PyObject *obj;
15787 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15788 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15789 Py_INCREF(obj);
15790 return Py_BuildValue((char *)"");
15791 }
15792 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15793 PyObject *resultobj;
15794 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15795 int arg2 = (int) 0 ;
15796 int arg3 = (int) 0 ;
15797 wxScrollWinEvent *result;
15798 PyObject * obj0 = 0 ;
15799 PyObject * obj1 = 0 ;
15800 PyObject * obj2 = 0 ;
15801 char *kwnames[] = {
15802 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15803 };
15804
15805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15806 if (obj0) {
15807 {
15808 arg1 = (wxEventType)(SWIG_As_int(obj0));
15809 if (SWIG_arg_fail(1)) SWIG_fail;
15810 }
15811 }
15812 if (obj1) {
15813 {
15814 arg2 = (int)(SWIG_As_int(obj1));
15815 if (SWIG_arg_fail(2)) SWIG_fail;
15816 }
15817 }
15818 if (obj2) {
15819 {
15820 arg3 = (int)(SWIG_As_int(obj2));
15821 if (SWIG_arg_fail(3)) SWIG_fail;
15822 }
15823 }
15824 {
15825 PyThreadState* __tstate = wxPyBeginAllowThreads();
15826 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15827
15828 wxPyEndAllowThreads(__tstate);
15829 if (PyErr_Occurred()) SWIG_fail;
15830 }
15831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15832 return resultobj;
15833 fail:
15834 return NULL;
15835 }
15836
15837
15838 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15839 PyObject *resultobj;
15840 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15841 int result;
15842 PyObject * obj0 = 0 ;
15843 char *kwnames[] = {
15844 (char *) "self", NULL
15845 };
15846
15847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15849 if (SWIG_arg_fail(1)) SWIG_fail;
15850 {
15851 PyThreadState* __tstate = wxPyBeginAllowThreads();
15852 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15853
15854 wxPyEndAllowThreads(__tstate);
15855 if (PyErr_Occurred()) SWIG_fail;
15856 }
15857 {
15858 resultobj = SWIG_From_int((int)(result));
15859 }
15860 return resultobj;
15861 fail:
15862 return NULL;
15863 }
15864
15865
15866 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15867 PyObject *resultobj;
15868 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15869 int result;
15870 PyObject * obj0 = 0 ;
15871 char *kwnames[] = {
15872 (char *) "self", NULL
15873 };
15874
15875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15877 if (SWIG_arg_fail(1)) SWIG_fail;
15878 {
15879 PyThreadState* __tstate = wxPyBeginAllowThreads();
15880 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15881
15882 wxPyEndAllowThreads(__tstate);
15883 if (PyErr_Occurred()) SWIG_fail;
15884 }
15885 {
15886 resultobj = SWIG_From_int((int)(result));
15887 }
15888 return resultobj;
15889 fail:
15890 return NULL;
15891 }
15892
15893
15894 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15895 PyObject *resultobj;
15896 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15897 int arg2 ;
15898 PyObject * obj0 = 0 ;
15899 PyObject * obj1 = 0 ;
15900 char *kwnames[] = {
15901 (char *) "self",(char *) "orient", NULL
15902 };
15903
15904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15906 if (SWIG_arg_fail(1)) SWIG_fail;
15907 {
15908 arg2 = (int)(SWIG_As_int(obj1));
15909 if (SWIG_arg_fail(2)) SWIG_fail;
15910 }
15911 {
15912 PyThreadState* __tstate = wxPyBeginAllowThreads();
15913 (arg1)->SetOrientation(arg2);
15914
15915 wxPyEndAllowThreads(__tstate);
15916 if (PyErr_Occurred()) SWIG_fail;
15917 }
15918 Py_INCREF(Py_None); resultobj = Py_None;
15919 return resultobj;
15920 fail:
15921 return NULL;
15922 }
15923
15924
15925 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15926 PyObject *resultobj;
15927 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15928 int arg2 ;
15929 PyObject * obj0 = 0 ;
15930 PyObject * obj1 = 0 ;
15931 char *kwnames[] = {
15932 (char *) "self",(char *) "pos", NULL
15933 };
15934
15935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15937 if (SWIG_arg_fail(1)) SWIG_fail;
15938 {
15939 arg2 = (int)(SWIG_As_int(obj1));
15940 if (SWIG_arg_fail(2)) SWIG_fail;
15941 }
15942 {
15943 PyThreadState* __tstate = wxPyBeginAllowThreads();
15944 (arg1)->SetPosition(arg2);
15945
15946 wxPyEndAllowThreads(__tstate);
15947 if (PyErr_Occurred()) SWIG_fail;
15948 }
15949 Py_INCREF(Py_None); resultobj = Py_None;
15950 return resultobj;
15951 fail:
15952 return NULL;
15953 }
15954
15955
15956 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15957 PyObject *obj;
15958 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15959 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15960 Py_INCREF(obj);
15961 return Py_BuildValue((char *)"");
15962 }
15963 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15964 PyObject *resultobj;
15965 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15966 wxMouseEvent *result;
15967 PyObject * obj0 = 0 ;
15968 char *kwnames[] = {
15969 (char *) "mouseType", NULL
15970 };
15971
15972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15973 if (obj0) {
15974 {
15975 arg1 = (wxEventType)(SWIG_As_int(obj0));
15976 if (SWIG_arg_fail(1)) SWIG_fail;
15977 }
15978 }
15979 {
15980 PyThreadState* __tstate = wxPyBeginAllowThreads();
15981 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15982
15983 wxPyEndAllowThreads(__tstate);
15984 if (PyErr_Occurred()) SWIG_fail;
15985 }
15986 {
15987 resultobj = wxPyMake_wxObject(result, 1);
15988 }
15989 return resultobj;
15990 fail:
15991 return NULL;
15992 }
15993
15994
15995 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15996 PyObject *resultobj;
15997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15998 bool result;
15999 PyObject * obj0 = 0 ;
16000 char *kwnames[] = {
16001 (char *) "self", NULL
16002 };
16003
16004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16006 if (SWIG_arg_fail(1)) SWIG_fail;
16007 {
16008 PyThreadState* __tstate = wxPyBeginAllowThreads();
16009 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16010
16011 wxPyEndAllowThreads(__tstate);
16012 if (PyErr_Occurred()) SWIG_fail;
16013 }
16014 {
16015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16016 }
16017 return resultobj;
16018 fail:
16019 return NULL;
16020 }
16021
16022
16023 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16024 PyObject *resultobj;
16025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16026 int arg2 = (int) wxMOUSE_BTN_ANY ;
16027 bool result;
16028 PyObject * obj0 = 0 ;
16029 PyObject * obj1 = 0 ;
16030 char *kwnames[] = {
16031 (char *) "self",(char *) "but", NULL
16032 };
16033
16034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16036 if (SWIG_arg_fail(1)) SWIG_fail;
16037 if (obj1) {
16038 {
16039 arg2 = (int)(SWIG_As_int(obj1));
16040 if (SWIG_arg_fail(2)) SWIG_fail;
16041 }
16042 }
16043 {
16044 PyThreadState* __tstate = wxPyBeginAllowThreads();
16045 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16046
16047 wxPyEndAllowThreads(__tstate);
16048 if (PyErr_Occurred()) SWIG_fail;
16049 }
16050 {
16051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16052 }
16053 return resultobj;
16054 fail:
16055 return NULL;
16056 }
16057
16058
16059 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16060 PyObject *resultobj;
16061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16062 int arg2 = (int) wxMOUSE_BTN_ANY ;
16063 bool result;
16064 PyObject * obj0 = 0 ;
16065 PyObject * obj1 = 0 ;
16066 char *kwnames[] = {
16067 (char *) "self",(char *) "but", NULL
16068 };
16069
16070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16072 if (SWIG_arg_fail(1)) SWIG_fail;
16073 if (obj1) {
16074 {
16075 arg2 = (int)(SWIG_As_int(obj1));
16076 if (SWIG_arg_fail(2)) SWIG_fail;
16077 }
16078 }
16079 {
16080 PyThreadState* __tstate = wxPyBeginAllowThreads();
16081 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16082
16083 wxPyEndAllowThreads(__tstate);
16084 if (PyErr_Occurred()) SWIG_fail;
16085 }
16086 {
16087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16088 }
16089 return resultobj;
16090 fail:
16091 return NULL;
16092 }
16093
16094
16095 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16096 PyObject *resultobj;
16097 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16098 int arg2 = (int) wxMOUSE_BTN_ANY ;
16099 bool result;
16100 PyObject * obj0 = 0 ;
16101 PyObject * obj1 = 0 ;
16102 char *kwnames[] = {
16103 (char *) "self",(char *) "but", NULL
16104 };
16105
16106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16108 if (SWIG_arg_fail(1)) SWIG_fail;
16109 if (obj1) {
16110 {
16111 arg2 = (int)(SWIG_As_int(obj1));
16112 if (SWIG_arg_fail(2)) SWIG_fail;
16113 }
16114 }
16115 {
16116 PyThreadState* __tstate = wxPyBeginAllowThreads();
16117 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16118
16119 wxPyEndAllowThreads(__tstate);
16120 if (PyErr_Occurred()) SWIG_fail;
16121 }
16122 {
16123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16124 }
16125 return resultobj;
16126 fail:
16127 return NULL;
16128 }
16129
16130
16131 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16132 PyObject *resultobj;
16133 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16134 int arg2 ;
16135 bool result;
16136 PyObject * obj0 = 0 ;
16137 PyObject * obj1 = 0 ;
16138 char *kwnames[] = {
16139 (char *) "self",(char *) "but", NULL
16140 };
16141
16142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16144 if (SWIG_arg_fail(1)) SWIG_fail;
16145 {
16146 arg2 = (int)(SWIG_As_int(obj1));
16147 if (SWIG_arg_fail(2)) SWIG_fail;
16148 }
16149 {
16150 PyThreadState* __tstate = wxPyBeginAllowThreads();
16151 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16152
16153 wxPyEndAllowThreads(__tstate);
16154 if (PyErr_Occurred()) SWIG_fail;
16155 }
16156 {
16157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16158 }
16159 return resultobj;
16160 fail:
16161 return NULL;
16162 }
16163
16164
16165 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16166 PyObject *resultobj;
16167 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16168 int arg2 ;
16169 bool result;
16170 PyObject * obj0 = 0 ;
16171 PyObject * obj1 = 0 ;
16172 char *kwnames[] = {
16173 (char *) "self",(char *) "but", NULL
16174 };
16175
16176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
16181 if (SWIG_arg_fail(2)) SWIG_fail;
16182 }
16183 {
16184 PyThreadState* __tstate = wxPyBeginAllowThreads();
16185 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16186
16187 wxPyEndAllowThreads(__tstate);
16188 if (PyErr_Occurred()) SWIG_fail;
16189 }
16190 {
16191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16192 }
16193 return resultobj;
16194 fail:
16195 return NULL;
16196 }
16197
16198
16199 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16200 PyObject *resultobj;
16201 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16202 int result;
16203 PyObject * obj0 = 0 ;
16204 char *kwnames[] = {
16205 (char *) "self", NULL
16206 };
16207
16208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16210 if (SWIG_arg_fail(1)) SWIG_fail;
16211 {
16212 PyThreadState* __tstate = wxPyBeginAllowThreads();
16213 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16214
16215 wxPyEndAllowThreads(__tstate);
16216 if (PyErr_Occurred()) SWIG_fail;
16217 }
16218 {
16219 resultobj = SWIG_From_int((int)(result));
16220 }
16221 return resultobj;
16222 fail:
16223 return NULL;
16224 }
16225
16226
16227 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16228 PyObject *resultobj;
16229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16230 bool result;
16231 PyObject * obj0 = 0 ;
16232 char *kwnames[] = {
16233 (char *) "self", NULL
16234 };
16235
16236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16238 if (SWIG_arg_fail(1)) SWIG_fail;
16239 {
16240 PyThreadState* __tstate = wxPyBeginAllowThreads();
16241 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16242
16243 wxPyEndAllowThreads(__tstate);
16244 if (PyErr_Occurred()) SWIG_fail;
16245 }
16246 {
16247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16248 }
16249 return resultobj;
16250 fail:
16251 return NULL;
16252 }
16253
16254
16255 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16256 PyObject *resultobj;
16257 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16258 bool result;
16259 PyObject * obj0 = 0 ;
16260 char *kwnames[] = {
16261 (char *) "self", NULL
16262 };
16263
16264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16266 if (SWIG_arg_fail(1)) SWIG_fail;
16267 {
16268 PyThreadState* __tstate = wxPyBeginAllowThreads();
16269 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16270
16271 wxPyEndAllowThreads(__tstate);
16272 if (PyErr_Occurred()) SWIG_fail;
16273 }
16274 {
16275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16276 }
16277 return resultobj;
16278 fail:
16279 return NULL;
16280 }
16281
16282
16283 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16284 PyObject *resultobj;
16285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16286 bool result;
16287 PyObject * obj0 = 0 ;
16288 char *kwnames[] = {
16289 (char *) "self", NULL
16290 };
16291
16292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16294 if (SWIG_arg_fail(1)) SWIG_fail;
16295 {
16296 PyThreadState* __tstate = wxPyBeginAllowThreads();
16297 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16298
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 {
16303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16304 }
16305 return resultobj;
16306 fail:
16307 return NULL;
16308 }
16309
16310
16311 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16312 PyObject *resultobj;
16313 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16314 bool result;
16315 PyObject * obj0 = 0 ;
16316 char *kwnames[] = {
16317 (char *) "self", NULL
16318 };
16319
16320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16322 if (SWIG_arg_fail(1)) SWIG_fail;
16323 {
16324 PyThreadState* __tstate = wxPyBeginAllowThreads();
16325 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16326
16327 wxPyEndAllowThreads(__tstate);
16328 if (PyErr_Occurred()) SWIG_fail;
16329 }
16330 {
16331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16332 }
16333 return resultobj;
16334 fail:
16335 return NULL;
16336 }
16337
16338
16339 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16340 PyObject *resultobj;
16341 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16342 bool result;
16343 PyObject * obj0 = 0 ;
16344 char *kwnames[] = {
16345 (char *) "self", NULL
16346 };
16347
16348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16350 if (SWIG_arg_fail(1)) SWIG_fail;
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16354
16355 wxPyEndAllowThreads(__tstate);
16356 if (PyErr_Occurred()) SWIG_fail;
16357 }
16358 {
16359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16360 }
16361 return resultobj;
16362 fail:
16363 return NULL;
16364 }
16365
16366
16367 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16368 PyObject *resultobj;
16369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16370 bool result;
16371 PyObject * obj0 = 0 ;
16372 char *kwnames[] = {
16373 (char *) "self", NULL
16374 };
16375
16376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16378 if (SWIG_arg_fail(1)) SWIG_fail;
16379 {
16380 PyThreadState* __tstate = wxPyBeginAllowThreads();
16381 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16382
16383 wxPyEndAllowThreads(__tstate);
16384 if (PyErr_Occurred()) SWIG_fail;
16385 }
16386 {
16387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16388 }
16389 return resultobj;
16390 fail:
16391 return NULL;
16392 }
16393
16394
16395 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16396 PyObject *resultobj;
16397 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16398 bool result;
16399 PyObject * obj0 = 0 ;
16400 char *kwnames[] = {
16401 (char *) "self", NULL
16402 };
16403
16404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16406 if (SWIG_arg_fail(1)) SWIG_fail;
16407 {
16408 PyThreadState* __tstate = wxPyBeginAllowThreads();
16409 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16410
16411 wxPyEndAllowThreads(__tstate);
16412 if (PyErr_Occurred()) SWIG_fail;
16413 }
16414 {
16415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16416 }
16417 return resultobj;
16418 fail:
16419 return NULL;
16420 }
16421
16422
16423 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16424 PyObject *resultobj;
16425 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16426 bool result;
16427 PyObject * obj0 = 0 ;
16428 char *kwnames[] = {
16429 (char *) "self", NULL
16430 };
16431
16432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16434 if (SWIG_arg_fail(1)) SWIG_fail;
16435 {
16436 PyThreadState* __tstate = wxPyBeginAllowThreads();
16437 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16438
16439 wxPyEndAllowThreads(__tstate);
16440 if (PyErr_Occurred()) SWIG_fail;
16441 }
16442 {
16443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16444 }
16445 return resultobj;
16446 fail:
16447 return NULL;
16448 }
16449
16450
16451 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj;
16453 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16454 bool result;
16455 PyObject * obj0 = 0 ;
16456 char *kwnames[] = {
16457 (char *) "self", NULL
16458 };
16459
16460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16462 if (SWIG_arg_fail(1)) SWIG_fail;
16463 {
16464 PyThreadState* __tstate = wxPyBeginAllowThreads();
16465 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16466
16467 wxPyEndAllowThreads(__tstate);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 }
16470 {
16471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16472 }
16473 return resultobj;
16474 fail:
16475 return NULL;
16476 }
16477
16478
16479 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16480 PyObject *resultobj;
16481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16482 bool result;
16483 PyObject * obj0 = 0 ;
16484 char *kwnames[] = {
16485 (char *) "self", NULL
16486 };
16487
16488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16490 if (SWIG_arg_fail(1)) SWIG_fail;
16491 {
16492 PyThreadState* __tstate = wxPyBeginAllowThreads();
16493 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16494
16495 wxPyEndAllowThreads(__tstate);
16496 if (PyErr_Occurred()) SWIG_fail;
16497 }
16498 {
16499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16500 }
16501 return resultobj;
16502 fail:
16503 return NULL;
16504 }
16505
16506
16507 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16508 PyObject *resultobj;
16509 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16510 bool result;
16511 PyObject * obj0 = 0 ;
16512 char *kwnames[] = {
16513 (char *) "self", NULL
16514 };
16515
16516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16518 if (SWIG_arg_fail(1)) SWIG_fail;
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16522
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 {
16527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16528 }
16529 return resultobj;
16530 fail:
16531 return NULL;
16532 }
16533
16534
16535 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj;
16537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16538 bool result;
16539 PyObject * obj0 = 0 ;
16540 char *kwnames[] = {
16541 (char *) "self", NULL
16542 };
16543
16544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16546 if (SWIG_arg_fail(1)) SWIG_fail;
16547 {
16548 PyThreadState* __tstate = wxPyBeginAllowThreads();
16549 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16550
16551 wxPyEndAllowThreads(__tstate);
16552 if (PyErr_Occurred()) SWIG_fail;
16553 }
16554 {
16555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16556 }
16557 return resultobj;
16558 fail:
16559 return NULL;
16560 }
16561
16562
16563 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16564 PyObject *resultobj;
16565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16566 bool result;
16567 PyObject * obj0 = 0 ;
16568 char *kwnames[] = {
16569 (char *) "self", NULL
16570 };
16571
16572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16574 if (SWIG_arg_fail(1)) SWIG_fail;
16575 {
16576 PyThreadState* __tstate = wxPyBeginAllowThreads();
16577 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16578
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 {
16583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16584 }
16585 return resultobj;
16586 fail:
16587 return NULL;
16588 }
16589
16590
16591 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj;
16593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16594 bool result;
16595 PyObject * obj0 = 0 ;
16596 char *kwnames[] = {
16597 (char *) "self", NULL
16598 };
16599
16600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16602 if (SWIG_arg_fail(1)) SWIG_fail;
16603 {
16604 PyThreadState* __tstate = wxPyBeginAllowThreads();
16605 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16606
16607 wxPyEndAllowThreads(__tstate);
16608 if (PyErr_Occurred()) SWIG_fail;
16609 }
16610 {
16611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16612 }
16613 return resultobj;
16614 fail:
16615 return NULL;
16616 }
16617
16618
16619 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16620 PyObject *resultobj;
16621 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16622 bool result;
16623 PyObject * obj0 = 0 ;
16624 char *kwnames[] = {
16625 (char *) "self", NULL
16626 };
16627
16628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16630 if (SWIG_arg_fail(1)) SWIG_fail;
16631 {
16632 PyThreadState* __tstate = wxPyBeginAllowThreads();
16633 result = (bool)(arg1)->LeftIsDown();
16634
16635 wxPyEndAllowThreads(__tstate);
16636 if (PyErr_Occurred()) SWIG_fail;
16637 }
16638 {
16639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16640 }
16641 return resultobj;
16642 fail:
16643 return NULL;
16644 }
16645
16646
16647 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16648 PyObject *resultobj;
16649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16650 bool result;
16651 PyObject * obj0 = 0 ;
16652 char *kwnames[] = {
16653 (char *) "self", NULL
16654 };
16655
16656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16658 if (SWIG_arg_fail(1)) SWIG_fail;
16659 {
16660 PyThreadState* __tstate = wxPyBeginAllowThreads();
16661 result = (bool)(arg1)->MiddleIsDown();
16662
16663 wxPyEndAllowThreads(__tstate);
16664 if (PyErr_Occurred()) SWIG_fail;
16665 }
16666 {
16667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16668 }
16669 return resultobj;
16670 fail:
16671 return NULL;
16672 }
16673
16674
16675 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16676 PyObject *resultobj;
16677 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16678 bool result;
16679 PyObject * obj0 = 0 ;
16680 char *kwnames[] = {
16681 (char *) "self", NULL
16682 };
16683
16684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16686 if (SWIG_arg_fail(1)) SWIG_fail;
16687 {
16688 PyThreadState* __tstate = wxPyBeginAllowThreads();
16689 result = (bool)(arg1)->RightIsDown();
16690
16691 wxPyEndAllowThreads(__tstate);
16692 if (PyErr_Occurred()) SWIG_fail;
16693 }
16694 {
16695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16696 }
16697 return resultobj;
16698 fail:
16699 return NULL;
16700 }
16701
16702
16703 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16704 PyObject *resultobj;
16705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16706 bool result;
16707 PyObject * obj0 = 0 ;
16708 char *kwnames[] = {
16709 (char *) "self", NULL
16710 };
16711
16712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16714 if (SWIG_arg_fail(1)) SWIG_fail;
16715 {
16716 PyThreadState* __tstate = wxPyBeginAllowThreads();
16717 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16718
16719 wxPyEndAllowThreads(__tstate);
16720 if (PyErr_Occurred()) SWIG_fail;
16721 }
16722 {
16723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16724 }
16725 return resultobj;
16726 fail:
16727 return NULL;
16728 }
16729
16730
16731 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16732 PyObject *resultobj;
16733 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16734 bool result;
16735 PyObject * obj0 = 0 ;
16736 char *kwnames[] = {
16737 (char *) "self", NULL
16738 };
16739
16740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16742 if (SWIG_arg_fail(1)) SWIG_fail;
16743 {
16744 PyThreadState* __tstate = wxPyBeginAllowThreads();
16745 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16746
16747 wxPyEndAllowThreads(__tstate);
16748 if (PyErr_Occurred()) SWIG_fail;
16749 }
16750 {
16751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16752 }
16753 return resultobj;
16754 fail:
16755 return NULL;
16756 }
16757
16758
16759 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16760 PyObject *resultobj;
16761 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16762 bool result;
16763 PyObject * obj0 = 0 ;
16764 char *kwnames[] = {
16765 (char *) "self", NULL
16766 };
16767
16768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16770 if (SWIG_arg_fail(1)) SWIG_fail;
16771 {
16772 PyThreadState* __tstate = wxPyBeginAllowThreads();
16773 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16774
16775 wxPyEndAllowThreads(__tstate);
16776 if (PyErr_Occurred()) SWIG_fail;
16777 }
16778 {
16779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16780 }
16781 return resultobj;
16782 fail:
16783 return NULL;
16784 }
16785
16786
16787 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16788 PyObject *resultobj;
16789 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16790 bool result;
16791 PyObject * obj0 = 0 ;
16792 char *kwnames[] = {
16793 (char *) "self", NULL
16794 };
16795
16796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16798 if (SWIG_arg_fail(1)) SWIG_fail;
16799 {
16800 PyThreadState* __tstate = wxPyBeginAllowThreads();
16801 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16802
16803 wxPyEndAllowThreads(__tstate);
16804 if (PyErr_Occurred()) SWIG_fail;
16805 }
16806 {
16807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16808 }
16809 return resultobj;
16810 fail:
16811 return NULL;
16812 }
16813
16814
16815 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16816 PyObject *resultobj;
16817 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16818 wxPoint result;
16819 PyObject * obj0 = 0 ;
16820 char *kwnames[] = {
16821 (char *) "self", NULL
16822 };
16823
16824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16826 if (SWIG_arg_fail(1)) SWIG_fail;
16827 {
16828 PyThreadState* __tstate = wxPyBeginAllowThreads();
16829 result = (arg1)->GetPosition();
16830
16831 wxPyEndAllowThreads(__tstate);
16832 if (PyErr_Occurred()) SWIG_fail;
16833 }
16834 {
16835 wxPoint * resultptr;
16836 resultptr = new wxPoint((wxPoint &)(result));
16837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16838 }
16839 return resultobj;
16840 fail:
16841 return NULL;
16842 }
16843
16844
16845 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16846 PyObject *resultobj;
16847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16848 long *arg2 = (long *) 0 ;
16849 long *arg3 = (long *) 0 ;
16850 long temp2 ;
16851 int res2 = 0 ;
16852 long temp3 ;
16853 int res3 = 0 ;
16854 PyObject * obj0 = 0 ;
16855 char *kwnames[] = {
16856 (char *) "self", NULL
16857 };
16858
16859 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16860 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16863 if (SWIG_arg_fail(1)) SWIG_fail;
16864 {
16865 PyThreadState* __tstate = wxPyBeginAllowThreads();
16866 (arg1)->GetPosition(arg2,arg3);
16867
16868 wxPyEndAllowThreads(__tstate);
16869 if (PyErr_Occurred()) SWIG_fail;
16870 }
16871 Py_INCREF(Py_None); resultobj = Py_None;
16872 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16873 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16874 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16875 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16876 return resultobj;
16877 fail:
16878 return NULL;
16879 }
16880
16881
16882 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16883 PyObject *resultobj;
16884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16885 wxDC *arg2 = 0 ;
16886 wxPoint result;
16887 PyObject * obj0 = 0 ;
16888 PyObject * obj1 = 0 ;
16889 char *kwnames[] = {
16890 (char *) "self",(char *) "dc", NULL
16891 };
16892
16893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16898 if (SWIG_arg_fail(2)) SWIG_fail;
16899 if (arg2 == NULL) {
16900 SWIG_null_ref("wxDC");
16901 }
16902 if (SWIG_arg_fail(2)) SWIG_fail;
16903 }
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16907
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 {
16912 wxPoint * resultptr;
16913 resultptr = new wxPoint((wxPoint &)(result));
16914 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16915 }
16916 return resultobj;
16917 fail:
16918 return NULL;
16919 }
16920
16921
16922 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16923 PyObject *resultobj;
16924 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16925 int result;
16926 PyObject * obj0 = 0 ;
16927 char *kwnames[] = {
16928 (char *) "self", NULL
16929 };
16930
16931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16933 if (SWIG_arg_fail(1)) SWIG_fail;
16934 {
16935 PyThreadState* __tstate = wxPyBeginAllowThreads();
16936 result = (int)((wxMouseEvent const *)arg1)->GetX();
16937
16938 wxPyEndAllowThreads(__tstate);
16939 if (PyErr_Occurred()) SWIG_fail;
16940 }
16941 {
16942 resultobj = SWIG_From_int((int)(result));
16943 }
16944 return resultobj;
16945 fail:
16946 return NULL;
16947 }
16948
16949
16950 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16951 PyObject *resultobj;
16952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16953 int result;
16954 PyObject * obj0 = 0 ;
16955 char *kwnames[] = {
16956 (char *) "self", NULL
16957 };
16958
16959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16961 if (SWIG_arg_fail(1)) SWIG_fail;
16962 {
16963 PyThreadState* __tstate = wxPyBeginAllowThreads();
16964 result = (int)((wxMouseEvent const *)arg1)->GetY();
16965
16966 wxPyEndAllowThreads(__tstate);
16967 if (PyErr_Occurred()) SWIG_fail;
16968 }
16969 {
16970 resultobj = SWIG_From_int((int)(result));
16971 }
16972 return resultobj;
16973 fail:
16974 return NULL;
16975 }
16976
16977
16978 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16979 PyObject *resultobj;
16980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16981 int result;
16982 PyObject * obj0 = 0 ;
16983 char *kwnames[] = {
16984 (char *) "self", NULL
16985 };
16986
16987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16989 if (SWIG_arg_fail(1)) SWIG_fail;
16990 {
16991 PyThreadState* __tstate = wxPyBeginAllowThreads();
16992 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16993
16994 wxPyEndAllowThreads(__tstate);
16995 if (PyErr_Occurred()) SWIG_fail;
16996 }
16997 {
16998 resultobj = SWIG_From_int((int)(result));
16999 }
17000 return resultobj;
17001 fail:
17002 return NULL;
17003 }
17004
17005
17006 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17007 PyObject *resultobj;
17008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17009 int result;
17010 PyObject * obj0 = 0 ;
17011 char *kwnames[] = {
17012 (char *) "self", NULL
17013 };
17014
17015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17017 if (SWIG_arg_fail(1)) SWIG_fail;
17018 {
17019 PyThreadState* __tstate = wxPyBeginAllowThreads();
17020 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17021
17022 wxPyEndAllowThreads(__tstate);
17023 if (PyErr_Occurred()) SWIG_fail;
17024 }
17025 {
17026 resultobj = SWIG_From_int((int)(result));
17027 }
17028 return resultobj;
17029 fail:
17030 return NULL;
17031 }
17032
17033
17034 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17035 PyObject *resultobj;
17036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17037 int result;
17038 PyObject * obj0 = 0 ;
17039 char *kwnames[] = {
17040 (char *) "self", NULL
17041 };
17042
17043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17045 if (SWIG_arg_fail(1)) SWIG_fail;
17046 {
17047 PyThreadState* __tstate = wxPyBeginAllowThreads();
17048 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17049
17050 wxPyEndAllowThreads(__tstate);
17051 if (PyErr_Occurred()) SWIG_fail;
17052 }
17053 {
17054 resultobj = SWIG_From_int((int)(result));
17055 }
17056 return resultobj;
17057 fail:
17058 return NULL;
17059 }
17060
17061
17062 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17063 PyObject *resultobj;
17064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17065 bool result;
17066 PyObject * obj0 = 0 ;
17067 char *kwnames[] = {
17068 (char *) "self", NULL
17069 };
17070
17071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17073 if (SWIG_arg_fail(1)) SWIG_fail;
17074 {
17075 PyThreadState* __tstate = wxPyBeginAllowThreads();
17076 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17077
17078 wxPyEndAllowThreads(__tstate);
17079 if (PyErr_Occurred()) SWIG_fail;
17080 }
17081 {
17082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17083 }
17084 return resultobj;
17085 fail:
17086 return NULL;
17087 }
17088
17089
17090 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17091 PyObject *resultobj;
17092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17093 int arg2 ;
17094 PyObject * obj0 = 0 ;
17095 PyObject * obj1 = 0 ;
17096 char *kwnames[] = {
17097 (char *) "self",(char *) "m_x", NULL
17098 };
17099
17100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17102 if (SWIG_arg_fail(1)) SWIG_fail;
17103 {
17104 arg2 = (int)(SWIG_As_int(obj1));
17105 if (SWIG_arg_fail(2)) SWIG_fail;
17106 }
17107 if (arg1) (arg1)->m_x = arg2;
17108
17109 Py_INCREF(Py_None); resultobj = Py_None;
17110 return resultobj;
17111 fail:
17112 return NULL;
17113 }
17114
17115
17116 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17117 PyObject *resultobj;
17118 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17119 int result;
17120 PyObject * obj0 = 0 ;
17121 char *kwnames[] = {
17122 (char *) "self", NULL
17123 };
17124
17125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17127 if (SWIG_arg_fail(1)) SWIG_fail;
17128 result = (int) ((arg1)->m_x);
17129
17130 {
17131 resultobj = SWIG_From_int((int)(result));
17132 }
17133 return resultobj;
17134 fail:
17135 return NULL;
17136 }
17137
17138
17139 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17140 PyObject *resultobj;
17141 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17142 int arg2 ;
17143 PyObject * obj0 = 0 ;
17144 PyObject * obj1 = 0 ;
17145 char *kwnames[] = {
17146 (char *) "self",(char *) "m_y", NULL
17147 };
17148
17149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17151 if (SWIG_arg_fail(1)) SWIG_fail;
17152 {
17153 arg2 = (int)(SWIG_As_int(obj1));
17154 if (SWIG_arg_fail(2)) SWIG_fail;
17155 }
17156 if (arg1) (arg1)->m_y = arg2;
17157
17158 Py_INCREF(Py_None); resultobj = Py_None;
17159 return resultobj;
17160 fail:
17161 return NULL;
17162 }
17163
17164
17165 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17166 PyObject *resultobj;
17167 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17168 int result;
17169 PyObject * obj0 = 0 ;
17170 char *kwnames[] = {
17171 (char *) "self", NULL
17172 };
17173
17174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17176 if (SWIG_arg_fail(1)) SWIG_fail;
17177 result = (int) ((arg1)->m_y);
17178
17179 {
17180 resultobj = SWIG_From_int((int)(result));
17181 }
17182 return resultobj;
17183 fail:
17184 return NULL;
17185 }
17186
17187
17188 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17189 PyObject *resultobj;
17190 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17191 bool arg2 ;
17192 PyObject * obj0 = 0 ;
17193 PyObject * obj1 = 0 ;
17194 char *kwnames[] = {
17195 (char *) "self",(char *) "m_leftDown", NULL
17196 };
17197
17198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17200 if (SWIG_arg_fail(1)) SWIG_fail;
17201 {
17202 arg2 = (bool)(SWIG_As_bool(obj1));
17203 if (SWIG_arg_fail(2)) SWIG_fail;
17204 }
17205 if (arg1) (arg1)->m_leftDown = arg2;
17206
17207 Py_INCREF(Py_None); resultobj = Py_None;
17208 return resultobj;
17209 fail:
17210 return NULL;
17211 }
17212
17213
17214 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17215 PyObject *resultobj;
17216 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17217 bool result;
17218 PyObject * obj0 = 0 ;
17219 char *kwnames[] = {
17220 (char *) "self", NULL
17221 };
17222
17223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17225 if (SWIG_arg_fail(1)) SWIG_fail;
17226 result = (bool) ((arg1)->m_leftDown);
17227
17228 {
17229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17230 }
17231 return resultobj;
17232 fail:
17233 return NULL;
17234 }
17235
17236
17237 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17238 PyObject *resultobj;
17239 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17240 bool arg2 ;
17241 PyObject * obj0 = 0 ;
17242 PyObject * obj1 = 0 ;
17243 char *kwnames[] = {
17244 (char *) "self",(char *) "m_middleDown", NULL
17245 };
17246
17247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17249 if (SWIG_arg_fail(1)) SWIG_fail;
17250 {
17251 arg2 = (bool)(SWIG_As_bool(obj1));
17252 if (SWIG_arg_fail(2)) SWIG_fail;
17253 }
17254 if (arg1) (arg1)->m_middleDown = arg2;
17255
17256 Py_INCREF(Py_None); resultobj = Py_None;
17257 return resultobj;
17258 fail:
17259 return NULL;
17260 }
17261
17262
17263 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17264 PyObject *resultobj;
17265 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17266 bool result;
17267 PyObject * obj0 = 0 ;
17268 char *kwnames[] = {
17269 (char *) "self", NULL
17270 };
17271
17272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17274 if (SWIG_arg_fail(1)) SWIG_fail;
17275 result = (bool) ((arg1)->m_middleDown);
17276
17277 {
17278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17279 }
17280 return resultobj;
17281 fail:
17282 return NULL;
17283 }
17284
17285
17286 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17287 PyObject *resultobj;
17288 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17289 bool arg2 ;
17290 PyObject * obj0 = 0 ;
17291 PyObject * obj1 = 0 ;
17292 char *kwnames[] = {
17293 (char *) "self",(char *) "m_rightDown", NULL
17294 };
17295
17296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17298 if (SWIG_arg_fail(1)) SWIG_fail;
17299 {
17300 arg2 = (bool)(SWIG_As_bool(obj1));
17301 if (SWIG_arg_fail(2)) SWIG_fail;
17302 }
17303 if (arg1) (arg1)->m_rightDown = arg2;
17304
17305 Py_INCREF(Py_None); resultobj = Py_None;
17306 return resultobj;
17307 fail:
17308 return NULL;
17309 }
17310
17311
17312 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17313 PyObject *resultobj;
17314 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17315 bool result;
17316 PyObject * obj0 = 0 ;
17317 char *kwnames[] = {
17318 (char *) "self", NULL
17319 };
17320
17321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17323 if (SWIG_arg_fail(1)) SWIG_fail;
17324 result = (bool) ((arg1)->m_rightDown);
17325
17326 {
17327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17328 }
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17336 PyObject *resultobj;
17337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17338 bool arg2 ;
17339 PyObject * obj0 = 0 ;
17340 PyObject * obj1 = 0 ;
17341 char *kwnames[] = {
17342 (char *) "self",(char *) "m_controlDown", NULL
17343 };
17344
17345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17347 if (SWIG_arg_fail(1)) SWIG_fail;
17348 {
17349 arg2 = (bool)(SWIG_As_bool(obj1));
17350 if (SWIG_arg_fail(2)) SWIG_fail;
17351 }
17352 if (arg1) (arg1)->m_controlDown = arg2;
17353
17354 Py_INCREF(Py_None); resultobj = Py_None;
17355 return resultobj;
17356 fail:
17357 return NULL;
17358 }
17359
17360
17361 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17362 PyObject *resultobj;
17363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17364 bool result;
17365 PyObject * obj0 = 0 ;
17366 char *kwnames[] = {
17367 (char *) "self", NULL
17368 };
17369
17370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17372 if (SWIG_arg_fail(1)) SWIG_fail;
17373 result = (bool) ((arg1)->m_controlDown);
17374
17375 {
17376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17377 }
17378 return resultobj;
17379 fail:
17380 return NULL;
17381 }
17382
17383
17384 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17385 PyObject *resultobj;
17386 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17387 bool arg2 ;
17388 PyObject * obj0 = 0 ;
17389 PyObject * obj1 = 0 ;
17390 char *kwnames[] = {
17391 (char *) "self",(char *) "m_shiftDown", NULL
17392 };
17393
17394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17396 if (SWIG_arg_fail(1)) SWIG_fail;
17397 {
17398 arg2 = (bool)(SWIG_As_bool(obj1));
17399 if (SWIG_arg_fail(2)) SWIG_fail;
17400 }
17401 if (arg1) (arg1)->m_shiftDown = arg2;
17402
17403 Py_INCREF(Py_None); resultobj = Py_None;
17404 return resultobj;
17405 fail:
17406 return NULL;
17407 }
17408
17409
17410 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17411 PyObject *resultobj;
17412 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17413 bool result;
17414 PyObject * obj0 = 0 ;
17415 char *kwnames[] = {
17416 (char *) "self", NULL
17417 };
17418
17419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17421 if (SWIG_arg_fail(1)) SWIG_fail;
17422 result = (bool) ((arg1)->m_shiftDown);
17423
17424 {
17425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17426 }
17427 return resultobj;
17428 fail:
17429 return NULL;
17430 }
17431
17432
17433 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17434 PyObject *resultobj;
17435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17436 bool arg2 ;
17437 PyObject * obj0 = 0 ;
17438 PyObject * obj1 = 0 ;
17439 char *kwnames[] = {
17440 (char *) "self",(char *) "m_altDown", NULL
17441 };
17442
17443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17445 if (SWIG_arg_fail(1)) SWIG_fail;
17446 {
17447 arg2 = (bool)(SWIG_As_bool(obj1));
17448 if (SWIG_arg_fail(2)) SWIG_fail;
17449 }
17450 if (arg1) (arg1)->m_altDown = arg2;
17451
17452 Py_INCREF(Py_None); resultobj = Py_None;
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17460 PyObject *resultobj;
17461 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17462 bool result;
17463 PyObject * obj0 = 0 ;
17464 char *kwnames[] = {
17465 (char *) "self", NULL
17466 };
17467
17468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17470 if (SWIG_arg_fail(1)) SWIG_fail;
17471 result = (bool) ((arg1)->m_altDown);
17472
17473 {
17474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17475 }
17476 return resultobj;
17477 fail:
17478 return NULL;
17479 }
17480
17481
17482 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17483 PyObject *resultobj;
17484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17485 bool arg2 ;
17486 PyObject * obj0 = 0 ;
17487 PyObject * obj1 = 0 ;
17488 char *kwnames[] = {
17489 (char *) "self",(char *) "m_metaDown", NULL
17490 };
17491
17492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17494 if (SWIG_arg_fail(1)) SWIG_fail;
17495 {
17496 arg2 = (bool)(SWIG_As_bool(obj1));
17497 if (SWIG_arg_fail(2)) SWIG_fail;
17498 }
17499 if (arg1) (arg1)->m_metaDown = arg2;
17500
17501 Py_INCREF(Py_None); resultobj = Py_None;
17502 return resultobj;
17503 fail:
17504 return NULL;
17505 }
17506
17507
17508 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17509 PyObject *resultobj;
17510 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17511 bool result;
17512 PyObject * obj0 = 0 ;
17513 char *kwnames[] = {
17514 (char *) "self", NULL
17515 };
17516
17517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17519 if (SWIG_arg_fail(1)) SWIG_fail;
17520 result = (bool) ((arg1)->m_metaDown);
17521
17522 {
17523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17524 }
17525 return resultobj;
17526 fail:
17527 return NULL;
17528 }
17529
17530
17531 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17532 PyObject *resultobj;
17533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17534 int arg2 ;
17535 PyObject * obj0 = 0 ;
17536 PyObject * obj1 = 0 ;
17537 char *kwnames[] = {
17538 (char *) "self",(char *) "m_wheelRotation", NULL
17539 };
17540
17541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17543 if (SWIG_arg_fail(1)) SWIG_fail;
17544 {
17545 arg2 = (int)(SWIG_As_int(obj1));
17546 if (SWIG_arg_fail(2)) SWIG_fail;
17547 }
17548 if (arg1) (arg1)->m_wheelRotation = arg2;
17549
17550 Py_INCREF(Py_None); resultobj = Py_None;
17551 return resultobj;
17552 fail:
17553 return NULL;
17554 }
17555
17556
17557 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17558 PyObject *resultobj;
17559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17560 int result;
17561 PyObject * obj0 = 0 ;
17562 char *kwnames[] = {
17563 (char *) "self", NULL
17564 };
17565
17566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17568 if (SWIG_arg_fail(1)) SWIG_fail;
17569 result = (int) ((arg1)->m_wheelRotation);
17570
17571 {
17572 resultobj = SWIG_From_int((int)(result));
17573 }
17574 return resultobj;
17575 fail:
17576 return NULL;
17577 }
17578
17579
17580 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17581 PyObject *resultobj;
17582 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17583 int arg2 ;
17584 PyObject * obj0 = 0 ;
17585 PyObject * obj1 = 0 ;
17586 char *kwnames[] = {
17587 (char *) "self",(char *) "m_wheelDelta", NULL
17588 };
17589
17590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17592 if (SWIG_arg_fail(1)) SWIG_fail;
17593 {
17594 arg2 = (int)(SWIG_As_int(obj1));
17595 if (SWIG_arg_fail(2)) SWIG_fail;
17596 }
17597 if (arg1) (arg1)->m_wheelDelta = arg2;
17598
17599 Py_INCREF(Py_None); resultobj = Py_None;
17600 return resultobj;
17601 fail:
17602 return NULL;
17603 }
17604
17605
17606 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17607 PyObject *resultobj;
17608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17609 int result;
17610 PyObject * obj0 = 0 ;
17611 char *kwnames[] = {
17612 (char *) "self", NULL
17613 };
17614
17615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17617 if (SWIG_arg_fail(1)) SWIG_fail;
17618 result = (int) ((arg1)->m_wheelDelta);
17619
17620 {
17621 resultobj = SWIG_From_int((int)(result));
17622 }
17623 return resultobj;
17624 fail:
17625 return NULL;
17626 }
17627
17628
17629 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17630 PyObject *resultobj;
17631 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17632 int arg2 ;
17633 PyObject * obj0 = 0 ;
17634 PyObject * obj1 = 0 ;
17635 char *kwnames[] = {
17636 (char *) "self",(char *) "m_linesPerAction", NULL
17637 };
17638
17639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17641 if (SWIG_arg_fail(1)) SWIG_fail;
17642 {
17643 arg2 = (int)(SWIG_As_int(obj1));
17644 if (SWIG_arg_fail(2)) SWIG_fail;
17645 }
17646 if (arg1) (arg1)->m_linesPerAction = arg2;
17647
17648 Py_INCREF(Py_None); resultobj = Py_None;
17649 return resultobj;
17650 fail:
17651 return NULL;
17652 }
17653
17654
17655 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17656 PyObject *resultobj;
17657 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17658 int result;
17659 PyObject * obj0 = 0 ;
17660 char *kwnames[] = {
17661 (char *) "self", NULL
17662 };
17663
17664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17666 if (SWIG_arg_fail(1)) SWIG_fail;
17667 result = (int) ((arg1)->m_linesPerAction);
17668
17669 {
17670 resultobj = SWIG_From_int((int)(result));
17671 }
17672 return resultobj;
17673 fail:
17674 return NULL;
17675 }
17676
17677
17678 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17679 PyObject *obj;
17680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17681 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17682 Py_INCREF(obj);
17683 return Py_BuildValue((char *)"");
17684 }
17685 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj;
17687 int arg1 = (int) 0 ;
17688 int arg2 = (int) 0 ;
17689 wxSetCursorEvent *result;
17690 PyObject * obj0 = 0 ;
17691 PyObject * obj1 = 0 ;
17692 char *kwnames[] = {
17693 (char *) "x",(char *) "y", NULL
17694 };
17695
17696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17697 if (obj0) {
17698 {
17699 arg1 = (int)(SWIG_As_int(obj0));
17700 if (SWIG_arg_fail(1)) SWIG_fail;
17701 }
17702 }
17703 if (obj1) {
17704 {
17705 arg2 = (int)(SWIG_As_int(obj1));
17706 if (SWIG_arg_fail(2)) SWIG_fail;
17707 }
17708 }
17709 {
17710 PyThreadState* __tstate = wxPyBeginAllowThreads();
17711 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17712
17713 wxPyEndAllowThreads(__tstate);
17714 if (PyErr_Occurred()) SWIG_fail;
17715 }
17716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17717 return resultobj;
17718 fail:
17719 return NULL;
17720 }
17721
17722
17723 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17724 PyObject *resultobj;
17725 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17726 int result;
17727 PyObject * obj0 = 0 ;
17728 char *kwnames[] = {
17729 (char *) "self", NULL
17730 };
17731
17732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17734 if (SWIG_arg_fail(1)) SWIG_fail;
17735 {
17736 PyThreadState* __tstate = wxPyBeginAllowThreads();
17737 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17738
17739 wxPyEndAllowThreads(__tstate);
17740 if (PyErr_Occurred()) SWIG_fail;
17741 }
17742 {
17743 resultobj = SWIG_From_int((int)(result));
17744 }
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj;
17753 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17754 int result;
17755 PyObject * obj0 = 0 ;
17756 char *kwnames[] = {
17757 (char *) "self", NULL
17758 };
17759
17760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17762 if (SWIG_arg_fail(1)) SWIG_fail;
17763 {
17764 PyThreadState* __tstate = wxPyBeginAllowThreads();
17765 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17766
17767 wxPyEndAllowThreads(__tstate);
17768 if (PyErr_Occurred()) SWIG_fail;
17769 }
17770 {
17771 resultobj = SWIG_From_int((int)(result));
17772 }
17773 return resultobj;
17774 fail:
17775 return NULL;
17776 }
17777
17778
17779 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17780 PyObject *resultobj;
17781 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17782 wxCursor *arg2 = 0 ;
17783 PyObject * obj0 = 0 ;
17784 PyObject * obj1 = 0 ;
17785 char *kwnames[] = {
17786 (char *) "self",(char *) "cursor", NULL
17787 };
17788
17789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17791 if (SWIG_arg_fail(1)) SWIG_fail;
17792 {
17793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17794 if (SWIG_arg_fail(2)) SWIG_fail;
17795 if (arg2 == NULL) {
17796 SWIG_null_ref("wxCursor");
17797 }
17798 if (SWIG_arg_fail(2)) SWIG_fail;
17799 }
17800 {
17801 PyThreadState* __tstate = wxPyBeginAllowThreads();
17802 (arg1)->SetCursor((wxCursor const &)*arg2);
17803
17804 wxPyEndAllowThreads(__tstate);
17805 if (PyErr_Occurred()) SWIG_fail;
17806 }
17807 Py_INCREF(Py_None); resultobj = Py_None;
17808 return resultobj;
17809 fail:
17810 return NULL;
17811 }
17812
17813
17814 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17815 PyObject *resultobj;
17816 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17817 wxCursor *result;
17818 PyObject * obj0 = 0 ;
17819 char *kwnames[] = {
17820 (char *) "self", NULL
17821 };
17822
17823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17825 if (SWIG_arg_fail(1)) SWIG_fail;
17826 {
17827 PyThreadState* __tstate = wxPyBeginAllowThreads();
17828 {
17829 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17830 result = (wxCursor *) &_result_ref;
17831 }
17832
17833 wxPyEndAllowThreads(__tstate);
17834 if (PyErr_Occurred()) SWIG_fail;
17835 }
17836 {
17837 wxCursor* resultptr = new wxCursor(*result);
17838 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17839 }
17840 return resultobj;
17841 fail:
17842 return NULL;
17843 }
17844
17845
17846 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17847 PyObject *resultobj;
17848 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17849 bool result;
17850 PyObject * obj0 = 0 ;
17851 char *kwnames[] = {
17852 (char *) "self", NULL
17853 };
17854
17855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17857 if (SWIG_arg_fail(1)) SWIG_fail;
17858 {
17859 PyThreadState* __tstate = wxPyBeginAllowThreads();
17860 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17861
17862 wxPyEndAllowThreads(__tstate);
17863 if (PyErr_Occurred()) SWIG_fail;
17864 }
17865 {
17866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17867 }
17868 return resultobj;
17869 fail:
17870 return NULL;
17871 }
17872
17873
17874 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17875 PyObject *obj;
17876 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17877 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17878 Py_INCREF(obj);
17879 return Py_BuildValue((char *)"");
17880 }
17881 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17882 PyObject *resultobj;
17883 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17884 wxKeyEvent *result;
17885 PyObject * obj0 = 0 ;
17886 char *kwnames[] = {
17887 (char *) "keyType", NULL
17888 };
17889
17890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17891 if (obj0) {
17892 {
17893 arg1 = (wxEventType)(SWIG_As_int(obj0));
17894 if (SWIG_arg_fail(1)) SWIG_fail;
17895 }
17896 }
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17900
17901 wxPyEndAllowThreads(__tstate);
17902 if (PyErr_Occurred()) SWIG_fail;
17903 }
17904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17905 return resultobj;
17906 fail:
17907 return NULL;
17908 }
17909
17910
17911 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17912 PyObject *resultobj;
17913 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17914 bool result;
17915 PyObject * obj0 = 0 ;
17916 char *kwnames[] = {
17917 (char *) "self", NULL
17918 };
17919
17920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17922 if (SWIG_arg_fail(1)) SWIG_fail;
17923 {
17924 PyThreadState* __tstate = wxPyBeginAllowThreads();
17925 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17926
17927 wxPyEndAllowThreads(__tstate);
17928 if (PyErr_Occurred()) SWIG_fail;
17929 }
17930 {
17931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17932 }
17933 return resultobj;
17934 fail:
17935 return NULL;
17936 }
17937
17938
17939 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17940 PyObject *resultobj;
17941 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17942 bool result;
17943 PyObject * obj0 = 0 ;
17944 char *kwnames[] = {
17945 (char *) "self", NULL
17946 };
17947
17948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17950 if (SWIG_arg_fail(1)) SWIG_fail;
17951 {
17952 PyThreadState* __tstate = wxPyBeginAllowThreads();
17953 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17954
17955 wxPyEndAllowThreads(__tstate);
17956 if (PyErr_Occurred()) SWIG_fail;
17957 }
17958 {
17959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17960 }
17961 return resultobj;
17962 fail:
17963 return NULL;
17964 }
17965
17966
17967 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17968 PyObject *resultobj;
17969 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17970 bool result;
17971 PyObject * obj0 = 0 ;
17972 char *kwnames[] = {
17973 (char *) "self", NULL
17974 };
17975
17976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17978 if (SWIG_arg_fail(1)) SWIG_fail;
17979 {
17980 PyThreadState* __tstate = wxPyBeginAllowThreads();
17981 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17982
17983 wxPyEndAllowThreads(__tstate);
17984 if (PyErr_Occurred()) SWIG_fail;
17985 }
17986 {
17987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17988 }
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17996 PyObject *resultobj;
17997 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17998 bool result;
17999 PyObject * obj0 = 0 ;
18000 char *kwnames[] = {
18001 (char *) "self", NULL
18002 };
18003
18004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18006 if (SWIG_arg_fail(1)) SWIG_fail;
18007 {
18008 PyThreadState* __tstate = wxPyBeginAllowThreads();
18009 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18010
18011 wxPyEndAllowThreads(__tstate);
18012 if (PyErr_Occurred()) SWIG_fail;
18013 }
18014 {
18015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18016 }
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18024 PyObject *resultobj;
18025 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18026 bool result;
18027 PyObject * obj0 = 0 ;
18028 char *kwnames[] = {
18029 (char *) "self", NULL
18030 };
18031
18032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18034 if (SWIG_arg_fail(1)) SWIG_fail;
18035 {
18036 PyThreadState* __tstate = wxPyBeginAllowThreads();
18037 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18038
18039 wxPyEndAllowThreads(__tstate);
18040 if (PyErr_Occurred()) SWIG_fail;
18041 }
18042 {
18043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18044 }
18045 return resultobj;
18046 fail:
18047 return NULL;
18048 }
18049
18050
18051 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18052 PyObject *resultobj;
18053 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18054 bool result;
18055 PyObject * obj0 = 0 ;
18056 char *kwnames[] = {
18057 (char *) "self", NULL
18058 };
18059
18060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18062 if (SWIG_arg_fail(1)) SWIG_fail;
18063 {
18064 PyThreadState* __tstate = wxPyBeginAllowThreads();
18065 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18066
18067 wxPyEndAllowThreads(__tstate);
18068 if (PyErr_Occurred()) SWIG_fail;
18069 }
18070 {
18071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18072 }
18073 return resultobj;
18074 fail:
18075 return NULL;
18076 }
18077
18078
18079 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18080 PyObject *resultobj;
18081 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18082 int result;
18083 PyObject * obj0 = 0 ;
18084 char *kwnames[] = {
18085 (char *) "self", NULL
18086 };
18087
18088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18090 if (SWIG_arg_fail(1)) SWIG_fail;
18091 {
18092 PyThreadState* __tstate = wxPyBeginAllowThreads();
18093 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18094
18095 wxPyEndAllowThreads(__tstate);
18096 if (PyErr_Occurred()) SWIG_fail;
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_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18108 PyObject *resultobj;
18109 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18110 int result;
18111 PyObject * obj0 = 0 ;
18112 char *kwnames[] = {
18113 (char *) "self", NULL
18114 };
18115
18116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18118 if (SWIG_arg_fail(1)) SWIG_fail;
18119 {
18120 PyThreadState* __tstate = wxPyBeginAllowThreads();
18121 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18122
18123 wxPyEndAllowThreads(__tstate);
18124 if (PyErr_Occurred()) SWIG_fail;
18125 }
18126 {
18127 resultobj = SWIG_From_int((int)(result));
18128 }
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18136 PyObject *resultobj;
18137 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18138 unsigned int result;
18139 PyObject * obj0 = 0 ;
18140 char *kwnames[] = {
18141 (char *) "self", NULL
18142 };
18143
18144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18146 if (SWIG_arg_fail(1)) SWIG_fail;
18147 {
18148 PyThreadState* __tstate = wxPyBeginAllowThreads();
18149 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18150
18151 wxPyEndAllowThreads(__tstate);
18152 if (PyErr_Occurred()) SWIG_fail;
18153 }
18154 {
18155 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18156 }
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18164 PyObject *resultobj;
18165 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18166 unsigned int result;
18167 PyObject * obj0 = 0 ;
18168 char *kwnames[] = {
18169 (char *) "self", NULL
18170 };
18171
18172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18174 if (SWIG_arg_fail(1)) SWIG_fail;
18175 {
18176 PyThreadState* __tstate = wxPyBeginAllowThreads();
18177 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18178
18179 wxPyEndAllowThreads(__tstate);
18180 if (PyErr_Occurred()) SWIG_fail;
18181 }
18182 {
18183 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18184 }
18185 return resultobj;
18186 fail:
18187 return NULL;
18188 }
18189
18190
18191 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18192 PyObject *resultobj;
18193 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18194 wxPoint result;
18195 PyObject * obj0 = 0 ;
18196 char *kwnames[] = {
18197 (char *) "self", NULL
18198 };
18199
18200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18202 if (SWIG_arg_fail(1)) SWIG_fail;
18203 {
18204 PyThreadState* __tstate = wxPyBeginAllowThreads();
18205 result = (arg1)->GetPosition();
18206
18207 wxPyEndAllowThreads(__tstate);
18208 if (PyErr_Occurred()) SWIG_fail;
18209 }
18210 {
18211 wxPoint * resultptr;
18212 resultptr = new wxPoint((wxPoint &)(result));
18213 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18214 }
18215 return resultobj;
18216 fail:
18217 return NULL;
18218 }
18219
18220
18221 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18222 PyObject *resultobj;
18223 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18224 long *arg2 = (long *) 0 ;
18225 long *arg3 = (long *) 0 ;
18226 long temp2 ;
18227 int res2 = 0 ;
18228 long temp3 ;
18229 int res3 = 0 ;
18230 PyObject * obj0 = 0 ;
18231 char *kwnames[] = {
18232 (char *) "self", NULL
18233 };
18234
18235 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18236 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18239 if (SWIG_arg_fail(1)) SWIG_fail;
18240 {
18241 PyThreadState* __tstate = wxPyBeginAllowThreads();
18242 (arg1)->GetPosition(arg2,arg3);
18243
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 Py_INCREF(Py_None); resultobj = Py_None;
18248 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18249 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18250 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18251 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18252 return resultobj;
18253 fail:
18254 return NULL;
18255 }
18256
18257
18258 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18259 PyObject *resultobj;
18260 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18261 int result;
18262 PyObject * obj0 = 0 ;
18263 char *kwnames[] = {
18264 (char *) "self", NULL
18265 };
18266
18267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18269 if (SWIG_arg_fail(1)) SWIG_fail;
18270 {
18271 PyThreadState* __tstate = wxPyBeginAllowThreads();
18272 result = (int)((wxKeyEvent const *)arg1)->GetX();
18273
18274 wxPyEndAllowThreads(__tstate);
18275 if (PyErr_Occurred()) SWIG_fail;
18276 }
18277 {
18278 resultobj = SWIG_From_int((int)(result));
18279 }
18280 return resultobj;
18281 fail:
18282 return NULL;
18283 }
18284
18285
18286 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18287 PyObject *resultobj;
18288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18289 int result;
18290 PyObject * obj0 = 0 ;
18291 char *kwnames[] = {
18292 (char *) "self", NULL
18293 };
18294
18295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18297 if (SWIG_arg_fail(1)) SWIG_fail;
18298 {
18299 PyThreadState* __tstate = wxPyBeginAllowThreads();
18300 result = (int)((wxKeyEvent const *)arg1)->GetY();
18301
18302 wxPyEndAllowThreads(__tstate);
18303 if (PyErr_Occurred()) SWIG_fail;
18304 }
18305 {
18306 resultobj = SWIG_From_int((int)(result));
18307 }
18308 return resultobj;
18309 fail:
18310 return NULL;
18311 }
18312
18313
18314 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18315 PyObject *resultobj;
18316 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18317 int arg2 ;
18318 PyObject * obj0 = 0 ;
18319 PyObject * obj1 = 0 ;
18320 char *kwnames[] = {
18321 (char *) "self",(char *) "m_x", NULL
18322 };
18323
18324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18326 if (SWIG_arg_fail(1)) SWIG_fail;
18327 {
18328 arg2 = (int)(SWIG_As_int(obj1));
18329 if (SWIG_arg_fail(2)) SWIG_fail;
18330 }
18331 if (arg1) (arg1)->m_x = arg2;
18332
18333 Py_INCREF(Py_None); resultobj = Py_None;
18334 return resultobj;
18335 fail:
18336 return NULL;
18337 }
18338
18339
18340 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18341 PyObject *resultobj;
18342 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18343 int result;
18344 PyObject * obj0 = 0 ;
18345 char *kwnames[] = {
18346 (char *) "self", NULL
18347 };
18348
18349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18351 if (SWIG_arg_fail(1)) SWIG_fail;
18352 result = (int) ((arg1)->m_x);
18353
18354 {
18355 resultobj = SWIG_From_int((int)(result));
18356 }
18357 return resultobj;
18358 fail:
18359 return NULL;
18360 }
18361
18362
18363 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18364 PyObject *resultobj;
18365 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18366 int arg2 ;
18367 PyObject * obj0 = 0 ;
18368 PyObject * obj1 = 0 ;
18369 char *kwnames[] = {
18370 (char *) "self",(char *) "m_y", NULL
18371 };
18372
18373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18375 if (SWIG_arg_fail(1)) SWIG_fail;
18376 {
18377 arg2 = (int)(SWIG_As_int(obj1));
18378 if (SWIG_arg_fail(2)) SWIG_fail;
18379 }
18380 if (arg1) (arg1)->m_y = arg2;
18381
18382 Py_INCREF(Py_None); resultobj = Py_None;
18383 return resultobj;
18384 fail:
18385 return NULL;
18386 }
18387
18388
18389 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18390 PyObject *resultobj;
18391 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18392 int result;
18393 PyObject * obj0 = 0 ;
18394 char *kwnames[] = {
18395 (char *) "self", NULL
18396 };
18397
18398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18400 if (SWIG_arg_fail(1)) SWIG_fail;
18401 result = (int) ((arg1)->m_y);
18402
18403 {
18404 resultobj = SWIG_From_int((int)(result));
18405 }
18406 return resultobj;
18407 fail:
18408 return NULL;
18409 }
18410
18411
18412 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18413 PyObject *resultobj;
18414 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18415 long arg2 ;
18416 PyObject * obj0 = 0 ;
18417 PyObject * obj1 = 0 ;
18418 char *kwnames[] = {
18419 (char *) "self",(char *) "m_keyCode", NULL
18420 };
18421
18422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18424 if (SWIG_arg_fail(1)) SWIG_fail;
18425 {
18426 arg2 = (long)(SWIG_As_long(obj1));
18427 if (SWIG_arg_fail(2)) SWIG_fail;
18428 }
18429 if (arg1) (arg1)->m_keyCode = arg2;
18430
18431 Py_INCREF(Py_None); resultobj = Py_None;
18432 return resultobj;
18433 fail:
18434 return NULL;
18435 }
18436
18437
18438 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18439 PyObject *resultobj;
18440 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18441 long result;
18442 PyObject * obj0 = 0 ;
18443 char *kwnames[] = {
18444 (char *) "self", NULL
18445 };
18446
18447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18449 if (SWIG_arg_fail(1)) SWIG_fail;
18450 result = (long) ((arg1)->m_keyCode);
18451
18452 {
18453 resultobj = SWIG_From_long((long)(result));
18454 }
18455 return resultobj;
18456 fail:
18457 return NULL;
18458 }
18459
18460
18461 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18462 PyObject *resultobj;
18463 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18464 bool arg2 ;
18465 PyObject * obj0 = 0 ;
18466 PyObject * obj1 = 0 ;
18467 char *kwnames[] = {
18468 (char *) "self",(char *) "m_controlDown", NULL
18469 };
18470
18471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18473 if (SWIG_arg_fail(1)) SWIG_fail;
18474 {
18475 arg2 = (bool)(SWIG_As_bool(obj1));
18476 if (SWIG_arg_fail(2)) SWIG_fail;
18477 }
18478 if (arg1) (arg1)->m_controlDown = arg2;
18479
18480 Py_INCREF(Py_None); resultobj = Py_None;
18481 return resultobj;
18482 fail:
18483 return NULL;
18484 }
18485
18486
18487 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18488 PyObject *resultobj;
18489 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18490 bool result;
18491 PyObject * obj0 = 0 ;
18492 char *kwnames[] = {
18493 (char *) "self", NULL
18494 };
18495
18496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18498 if (SWIG_arg_fail(1)) SWIG_fail;
18499 result = (bool) ((arg1)->m_controlDown);
18500
18501 {
18502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18503 }
18504 return resultobj;
18505 fail:
18506 return NULL;
18507 }
18508
18509
18510 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18511 PyObject *resultobj;
18512 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18513 bool arg2 ;
18514 PyObject * obj0 = 0 ;
18515 PyObject * obj1 = 0 ;
18516 char *kwnames[] = {
18517 (char *) "self",(char *) "m_shiftDown", NULL
18518 };
18519
18520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18522 if (SWIG_arg_fail(1)) SWIG_fail;
18523 {
18524 arg2 = (bool)(SWIG_As_bool(obj1));
18525 if (SWIG_arg_fail(2)) SWIG_fail;
18526 }
18527 if (arg1) (arg1)->m_shiftDown = arg2;
18528
18529 Py_INCREF(Py_None); resultobj = Py_None;
18530 return resultobj;
18531 fail:
18532 return NULL;
18533 }
18534
18535
18536 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18537 PyObject *resultobj;
18538 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18539 bool result;
18540 PyObject * obj0 = 0 ;
18541 char *kwnames[] = {
18542 (char *) "self", NULL
18543 };
18544
18545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18547 if (SWIG_arg_fail(1)) SWIG_fail;
18548 result = (bool) ((arg1)->m_shiftDown);
18549
18550 {
18551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18552 }
18553 return resultobj;
18554 fail:
18555 return NULL;
18556 }
18557
18558
18559 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18560 PyObject *resultobj;
18561 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18562 bool arg2 ;
18563 PyObject * obj0 = 0 ;
18564 PyObject * obj1 = 0 ;
18565 char *kwnames[] = {
18566 (char *) "self",(char *) "m_altDown", NULL
18567 };
18568
18569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18571 if (SWIG_arg_fail(1)) SWIG_fail;
18572 {
18573 arg2 = (bool)(SWIG_As_bool(obj1));
18574 if (SWIG_arg_fail(2)) SWIG_fail;
18575 }
18576 if (arg1) (arg1)->m_altDown = arg2;
18577
18578 Py_INCREF(Py_None); resultobj = Py_None;
18579 return resultobj;
18580 fail:
18581 return NULL;
18582 }
18583
18584
18585 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18586 PyObject *resultobj;
18587 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18588 bool result;
18589 PyObject * obj0 = 0 ;
18590 char *kwnames[] = {
18591 (char *) "self", NULL
18592 };
18593
18594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18596 if (SWIG_arg_fail(1)) SWIG_fail;
18597 result = (bool) ((arg1)->m_altDown);
18598
18599 {
18600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18601 }
18602 return resultobj;
18603 fail:
18604 return NULL;
18605 }
18606
18607
18608 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18609 PyObject *resultobj;
18610 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18611 bool arg2 ;
18612 PyObject * obj0 = 0 ;
18613 PyObject * obj1 = 0 ;
18614 char *kwnames[] = {
18615 (char *) "self",(char *) "m_metaDown", NULL
18616 };
18617
18618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18620 if (SWIG_arg_fail(1)) SWIG_fail;
18621 {
18622 arg2 = (bool)(SWIG_As_bool(obj1));
18623 if (SWIG_arg_fail(2)) SWIG_fail;
18624 }
18625 if (arg1) (arg1)->m_metaDown = arg2;
18626
18627 Py_INCREF(Py_None); resultobj = Py_None;
18628 return resultobj;
18629 fail:
18630 return NULL;
18631 }
18632
18633
18634 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18635 PyObject *resultobj;
18636 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18637 bool result;
18638 PyObject * obj0 = 0 ;
18639 char *kwnames[] = {
18640 (char *) "self", NULL
18641 };
18642
18643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18645 if (SWIG_arg_fail(1)) SWIG_fail;
18646 result = (bool) ((arg1)->m_metaDown);
18647
18648 {
18649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18650 }
18651 return resultobj;
18652 fail:
18653 return NULL;
18654 }
18655
18656
18657 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18658 PyObject *resultobj;
18659 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18660 bool arg2 ;
18661 PyObject * obj0 = 0 ;
18662 PyObject * obj1 = 0 ;
18663 char *kwnames[] = {
18664 (char *) "self",(char *) "m_scanCode", NULL
18665 };
18666
18667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18669 if (SWIG_arg_fail(1)) SWIG_fail;
18670 {
18671 arg2 = (bool)(SWIG_As_bool(obj1));
18672 if (SWIG_arg_fail(2)) SWIG_fail;
18673 }
18674 if (arg1) (arg1)->m_scanCode = arg2;
18675
18676 Py_INCREF(Py_None); resultobj = Py_None;
18677 return resultobj;
18678 fail:
18679 return NULL;
18680 }
18681
18682
18683 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18684 PyObject *resultobj;
18685 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18686 bool result;
18687 PyObject * obj0 = 0 ;
18688 char *kwnames[] = {
18689 (char *) "self", NULL
18690 };
18691
18692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18694 if (SWIG_arg_fail(1)) SWIG_fail;
18695 result = (bool) ((arg1)->m_scanCode);
18696
18697 {
18698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18699 }
18700 return resultobj;
18701 fail:
18702 return NULL;
18703 }
18704
18705
18706 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18707 PyObject *resultobj;
18708 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18709 unsigned int arg2 ;
18710 PyObject * obj0 = 0 ;
18711 PyObject * obj1 = 0 ;
18712 char *kwnames[] = {
18713 (char *) "self",(char *) "m_rawCode", NULL
18714 };
18715
18716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18718 if (SWIG_arg_fail(1)) SWIG_fail;
18719 {
18720 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18721 if (SWIG_arg_fail(2)) SWIG_fail;
18722 }
18723 if (arg1) (arg1)->m_rawCode = arg2;
18724
18725 Py_INCREF(Py_None); resultobj = Py_None;
18726 return resultobj;
18727 fail:
18728 return NULL;
18729 }
18730
18731
18732 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18733 PyObject *resultobj;
18734 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18735 unsigned int result;
18736 PyObject * obj0 = 0 ;
18737 char *kwnames[] = {
18738 (char *) "self", NULL
18739 };
18740
18741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18743 if (SWIG_arg_fail(1)) SWIG_fail;
18744 result = (unsigned int) ((arg1)->m_rawCode);
18745
18746 {
18747 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18748 }
18749 return resultobj;
18750 fail:
18751 return NULL;
18752 }
18753
18754
18755 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18756 PyObject *resultobj;
18757 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18758 unsigned int arg2 ;
18759 PyObject * obj0 = 0 ;
18760 PyObject * obj1 = 0 ;
18761 char *kwnames[] = {
18762 (char *) "self",(char *) "m_rawFlags", NULL
18763 };
18764
18765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18767 if (SWIG_arg_fail(1)) SWIG_fail;
18768 {
18769 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18770 if (SWIG_arg_fail(2)) SWIG_fail;
18771 }
18772 if (arg1) (arg1)->m_rawFlags = arg2;
18773
18774 Py_INCREF(Py_None); resultobj = Py_None;
18775 return resultobj;
18776 fail:
18777 return NULL;
18778 }
18779
18780
18781 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18782 PyObject *resultobj;
18783 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18784 unsigned int result;
18785 PyObject * obj0 = 0 ;
18786 char *kwnames[] = {
18787 (char *) "self", NULL
18788 };
18789
18790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18792 if (SWIG_arg_fail(1)) SWIG_fail;
18793 result = (unsigned int) ((arg1)->m_rawFlags);
18794
18795 {
18796 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18797 }
18798 return resultobj;
18799 fail:
18800 return NULL;
18801 }
18802
18803
18804 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18805 PyObject *obj;
18806 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18807 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18808 Py_INCREF(obj);
18809 return Py_BuildValue((char *)"");
18810 }
18811 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18812 PyObject *resultobj;
18813 wxSize const &arg1_defvalue = wxDefaultSize ;
18814 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18815 int arg2 = (int) 0 ;
18816 wxSizeEvent *result;
18817 wxSize temp1 ;
18818 PyObject * obj0 = 0 ;
18819 PyObject * obj1 = 0 ;
18820 char *kwnames[] = {
18821 (char *) "sz",(char *) "winid", NULL
18822 };
18823
18824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18825 if (obj0) {
18826 {
18827 arg1 = &temp1;
18828 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18829 }
18830 }
18831 if (obj1) {
18832 {
18833 arg2 = (int)(SWIG_As_int(obj1));
18834 if (SWIG_arg_fail(2)) SWIG_fail;
18835 }
18836 }
18837 {
18838 PyThreadState* __tstate = wxPyBeginAllowThreads();
18839 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18840
18841 wxPyEndAllowThreads(__tstate);
18842 if (PyErr_Occurred()) SWIG_fail;
18843 }
18844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18845 return resultobj;
18846 fail:
18847 return NULL;
18848 }
18849
18850
18851 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18852 PyObject *resultobj;
18853 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18854 wxSize result;
18855 PyObject * obj0 = 0 ;
18856 char *kwnames[] = {
18857 (char *) "self", NULL
18858 };
18859
18860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18862 if (SWIG_arg_fail(1)) SWIG_fail;
18863 {
18864 PyThreadState* __tstate = wxPyBeginAllowThreads();
18865 result = ((wxSizeEvent const *)arg1)->GetSize();
18866
18867 wxPyEndAllowThreads(__tstate);
18868 if (PyErr_Occurred()) SWIG_fail;
18869 }
18870 {
18871 wxSize * resultptr;
18872 resultptr = new wxSize((wxSize &)(result));
18873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18874 }
18875 return resultobj;
18876 fail:
18877 return NULL;
18878 }
18879
18880
18881 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18882 PyObject *resultobj;
18883 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18884 wxRect result;
18885 PyObject * obj0 = 0 ;
18886 char *kwnames[] = {
18887 (char *) "self", NULL
18888 };
18889
18890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18892 if (SWIG_arg_fail(1)) SWIG_fail;
18893 {
18894 PyThreadState* __tstate = wxPyBeginAllowThreads();
18895 result = ((wxSizeEvent const *)arg1)->GetRect();
18896
18897 wxPyEndAllowThreads(__tstate);
18898 if (PyErr_Occurred()) SWIG_fail;
18899 }
18900 {
18901 wxRect * resultptr;
18902 resultptr = new wxRect((wxRect &)(result));
18903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18904 }
18905 return resultobj;
18906 fail:
18907 return NULL;
18908 }
18909
18910
18911 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18912 PyObject *resultobj;
18913 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18914 wxRect arg2 ;
18915 PyObject * obj0 = 0 ;
18916 PyObject * obj1 = 0 ;
18917 char *kwnames[] = {
18918 (char *) "self",(char *) "rect", NULL
18919 };
18920
18921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18923 if (SWIG_arg_fail(1)) SWIG_fail;
18924 {
18925 wxRect * argp;
18926 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18927 if (SWIG_arg_fail(2)) SWIG_fail;
18928 if (argp == NULL) {
18929 SWIG_null_ref("wxRect");
18930 }
18931 if (SWIG_arg_fail(2)) SWIG_fail;
18932 arg2 = *argp;
18933 }
18934 {
18935 PyThreadState* __tstate = wxPyBeginAllowThreads();
18936 (arg1)->SetRect(arg2);
18937
18938 wxPyEndAllowThreads(__tstate);
18939 if (PyErr_Occurred()) SWIG_fail;
18940 }
18941 Py_INCREF(Py_None); resultobj = Py_None;
18942 return resultobj;
18943 fail:
18944 return NULL;
18945 }
18946
18947
18948 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18949 PyObject *resultobj;
18950 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18951 wxSize arg2 ;
18952 PyObject * obj0 = 0 ;
18953 PyObject * obj1 = 0 ;
18954 char *kwnames[] = {
18955 (char *) "self",(char *) "size", NULL
18956 };
18957
18958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18960 if (SWIG_arg_fail(1)) SWIG_fail;
18961 {
18962 wxSize * argp;
18963 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18964 if (SWIG_arg_fail(2)) SWIG_fail;
18965 if (argp == NULL) {
18966 SWIG_null_ref("wxSize");
18967 }
18968 if (SWIG_arg_fail(2)) SWIG_fail;
18969 arg2 = *argp;
18970 }
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 wxSizeEvent_SetSize(arg1,arg2);
18974
18975 wxPyEndAllowThreads(__tstate);
18976 if (PyErr_Occurred()) SWIG_fail;
18977 }
18978 Py_INCREF(Py_None); resultobj = Py_None;
18979 return resultobj;
18980 fail:
18981 return NULL;
18982 }
18983
18984
18985 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18986 PyObject *resultobj;
18987 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18988 wxSize *arg2 = (wxSize *) 0 ;
18989 PyObject * obj0 = 0 ;
18990 PyObject * obj1 = 0 ;
18991 char *kwnames[] = {
18992 (char *) "self",(char *) "m_size", NULL
18993 };
18994
18995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18997 if (SWIG_arg_fail(1)) SWIG_fail;
18998 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18999 if (SWIG_arg_fail(2)) SWIG_fail;
19000 if (arg1) (arg1)->m_size = *arg2;
19001
19002 Py_INCREF(Py_None); resultobj = Py_None;
19003 return resultobj;
19004 fail:
19005 return NULL;
19006 }
19007
19008
19009 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19010 PyObject *resultobj;
19011 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19012 wxSize *result;
19013 PyObject * obj0 = 0 ;
19014 char *kwnames[] = {
19015 (char *) "self", NULL
19016 };
19017
19018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19020 if (SWIG_arg_fail(1)) SWIG_fail;
19021 result = (wxSize *)& ((arg1)->m_size);
19022
19023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19024 return resultobj;
19025 fail:
19026 return NULL;
19027 }
19028
19029
19030 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19031 PyObject *resultobj;
19032 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19033 wxRect *arg2 = (wxRect *) 0 ;
19034 PyObject * obj0 = 0 ;
19035 PyObject * obj1 = 0 ;
19036 char *kwnames[] = {
19037 (char *) "self",(char *) "m_rect", NULL
19038 };
19039
19040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19042 if (SWIG_arg_fail(1)) SWIG_fail;
19043 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19044 if (SWIG_arg_fail(2)) SWIG_fail;
19045 if (arg1) (arg1)->m_rect = *arg2;
19046
19047 Py_INCREF(Py_None); resultobj = Py_None;
19048 return resultobj;
19049 fail:
19050 return NULL;
19051 }
19052
19053
19054 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19055 PyObject *resultobj;
19056 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19057 wxRect *result;
19058 PyObject * obj0 = 0 ;
19059 char *kwnames[] = {
19060 (char *) "self", NULL
19061 };
19062
19063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19065 if (SWIG_arg_fail(1)) SWIG_fail;
19066 result = (wxRect *)& ((arg1)->m_rect);
19067
19068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19069 return resultobj;
19070 fail:
19071 return NULL;
19072 }
19073
19074
19075 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19076 PyObject *obj;
19077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19078 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19079 Py_INCREF(obj);
19080 return Py_BuildValue((char *)"");
19081 }
19082 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19083 PyObject *resultobj;
19084 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19085 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19086 int arg2 = (int) 0 ;
19087 wxMoveEvent *result;
19088 wxPoint temp1 ;
19089 PyObject * obj0 = 0 ;
19090 PyObject * obj1 = 0 ;
19091 char *kwnames[] = {
19092 (char *) "pos",(char *) "winid", NULL
19093 };
19094
19095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19096 if (obj0) {
19097 {
19098 arg1 = &temp1;
19099 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19100 }
19101 }
19102 if (obj1) {
19103 {
19104 arg2 = (int)(SWIG_As_int(obj1));
19105 if (SWIG_arg_fail(2)) SWIG_fail;
19106 }
19107 }
19108 {
19109 PyThreadState* __tstate = wxPyBeginAllowThreads();
19110 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19111
19112 wxPyEndAllowThreads(__tstate);
19113 if (PyErr_Occurred()) SWIG_fail;
19114 }
19115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19116 return resultobj;
19117 fail:
19118 return NULL;
19119 }
19120
19121
19122 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19123 PyObject *resultobj;
19124 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19125 wxPoint result;
19126 PyObject * obj0 = 0 ;
19127 char *kwnames[] = {
19128 (char *) "self", NULL
19129 };
19130
19131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19133 if (SWIG_arg_fail(1)) SWIG_fail;
19134 {
19135 PyThreadState* __tstate = wxPyBeginAllowThreads();
19136 result = ((wxMoveEvent const *)arg1)->GetPosition();
19137
19138 wxPyEndAllowThreads(__tstate);
19139 if (PyErr_Occurred()) SWIG_fail;
19140 }
19141 {
19142 wxPoint * resultptr;
19143 resultptr = new wxPoint((wxPoint &)(result));
19144 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19145 }
19146 return resultobj;
19147 fail:
19148 return NULL;
19149 }
19150
19151
19152 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19153 PyObject *resultobj;
19154 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19155 wxRect result;
19156 PyObject * obj0 = 0 ;
19157 char *kwnames[] = {
19158 (char *) "self", NULL
19159 };
19160
19161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19163 if (SWIG_arg_fail(1)) SWIG_fail;
19164 {
19165 PyThreadState* __tstate = wxPyBeginAllowThreads();
19166 result = ((wxMoveEvent const *)arg1)->GetRect();
19167
19168 wxPyEndAllowThreads(__tstate);
19169 if (PyErr_Occurred()) SWIG_fail;
19170 }
19171 {
19172 wxRect * resultptr;
19173 resultptr = new wxRect((wxRect &)(result));
19174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19175 }
19176 return resultobj;
19177 fail:
19178 return NULL;
19179 }
19180
19181
19182 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19183 PyObject *resultobj;
19184 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19185 wxRect *arg2 = 0 ;
19186 wxRect temp2 ;
19187 PyObject * obj0 = 0 ;
19188 PyObject * obj1 = 0 ;
19189 char *kwnames[] = {
19190 (char *) "self",(char *) "rect", NULL
19191 };
19192
19193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19195 if (SWIG_arg_fail(1)) SWIG_fail;
19196 {
19197 arg2 = &temp2;
19198 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19199 }
19200 {
19201 PyThreadState* __tstate = wxPyBeginAllowThreads();
19202 (arg1)->SetRect((wxRect const &)*arg2);
19203
19204 wxPyEndAllowThreads(__tstate);
19205 if (PyErr_Occurred()) SWIG_fail;
19206 }
19207 Py_INCREF(Py_None); resultobj = Py_None;
19208 return resultobj;
19209 fail:
19210 return NULL;
19211 }
19212
19213
19214 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19215 PyObject *resultobj;
19216 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19217 wxPoint *arg2 = 0 ;
19218 wxPoint temp2 ;
19219 PyObject * obj0 = 0 ;
19220 PyObject * obj1 = 0 ;
19221 char *kwnames[] = {
19222 (char *) "self",(char *) "pos", NULL
19223 };
19224
19225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19227 if (SWIG_arg_fail(1)) SWIG_fail;
19228 {
19229 arg2 = &temp2;
19230 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19231 }
19232 {
19233 PyThreadState* __tstate = wxPyBeginAllowThreads();
19234 (arg1)->SetPosition((wxPoint const &)*arg2);
19235
19236 wxPyEndAllowThreads(__tstate);
19237 if (PyErr_Occurred()) SWIG_fail;
19238 }
19239 Py_INCREF(Py_None); resultobj = Py_None;
19240 return resultobj;
19241 fail:
19242 return NULL;
19243 }
19244
19245
19246 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19247 PyObject *obj;
19248 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19249 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19250 Py_INCREF(obj);
19251 return Py_BuildValue((char *)"");
19252 }
19253 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19254 PyObject *resultobj;
19255 int arg1 = (int) 0 ;
19256 wxPaintEvent *result;
19257 PyObject * obj0 = 0 ;
19258 char *kwnames[] = {
19259 (char *) "Id", NULL
19260 };
19261
19262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19263 if (obj0) {
19264 {
19265 arg1 = (int)(SWIG_As_int(obj0));
19266 if (SWIG_arg_fail(1)) SWIG_fail;
19267 }
19268 }
19269 {
19270 PyThreadState* __tstate = wxPyBeginAllowThreads();
19271 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19272
19273 wxPyEndAllowThreads(__tstate);
19274 if (PyErr_Occurred()) SWIG_fail;
19275 }
19276 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19277 return resultobj;
19278 fail:
19279 return NULL;
19280 }
19281
19282
19283 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19284 PyObject *obj;
19285 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19286 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19287 Py_INCREF(obj);
19288 return Py_BuildValue((char *)"");
19289 }
19290 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19291 PyObject *resultobj;
19292 int arg1 = (int) 0 ;
19293 wxNcPaintEvent *result;
19294 PyObject * obj0 = 0 ;
19295 char *kwnames[] = {
19296 (char *) "winid", NULL
19297 };
19298
19299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19300 if (obj0) {
19301 {
19302 arg1 = (int)(SWIG_As_int(obj0));
19303 if (SWIG_arg_fail(1)) SWIG_fail;
19304 }
19305 }
19306 {
19307 PyThreadState* __tstate = wxPyBeginAllowThreads();
19308 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19309
19310 wxPyEndAllowThreads(__tstate);
19311 if (PyErr_Occurred()) SWIG_fail;
19312 }
19313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19314 return resultobj;
19315 fail:
19316 return NULL;
19317 }
19318
19319
19320 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19321 PyObject *obj;
19322 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19323 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19324 Py_INCREF(obj);
19325 return Py_BuildValue((char *)"");
19326 }
19327 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19328 PyObject *resultobj;
19329 int arg1 = (int) 0 ;
19330 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19331 wxEraseEvent *result;
19332 PyObject * obj0 = 0 ;
19333 PyObject * obj1 = 0 ;
19334 char *kwnames[] = {
19335 (char *) "Id",(char *) "dc", NULL
19336 };
19337
19338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19339 if (obj0) {
19340 {
19341 arg1 = (int)(SWIG_As_int(obj0));
19342 if (SWIG_arg_fail(1)) SWIG_fail;
19343 }
19344 }
19345 if (obj1) {
19346 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19347 if (SWIG_arg_fail(2)) SWIG_fail;
19348 }
19349 {
19350 PyThreadState* __tstate = wxPyBeginAllowThreads();
19351 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19352
19353 wxPyEndAllowThreads(__tstate);
19354 if (PyErr_Occurred()) SWIG_fail;
19355 }
19356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19357 return resultobj;
19358 fail:
19359 return NULL;
19360 }
19361
19362
19363 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19364 PyObject *resultobj;
19365 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19366 wxDC *result;
19367 PyObject * obj0 = 0 ;
19368 char *kwnames[] = {
19369 (char *) "self", NULL
19370 };
19371
19372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19374 if (SWIG_arg_fail(1)) SWIG_fail;
19375 {
19376 PyThreadState* __tstate = wxPyBeginAllowThreads();
19377 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19378
19379 wxPyEndAllowThreads(__tstate);
19380 if (PyErr_Occurred()) SWIG_fail;
19381 }
19382 {
19383 resultobj = wxPyMake_wxObject(result, 0);
19384 }
19385 return resultobj;
19386 fail:
19387 return NULL;
19388 }
19389
19390
19391 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19392 PyObject *obj;
19393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19394 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19395 Py_INCREF(obj);
19396 return Py_BuildValue((char *)"");
19397 }
19398 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19399 PyObject *resultobj;
19400 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19401 int arg2 = (int) 0 ;
19402 wxFocusEvent *result;
19403 PyObject * obj0 = 0 ;
19404 PyObject * obj1 = 0 ;
19405 char *kwnames[] = {
19406 (char *) "type",(char *) "winid", NULL
19407 };
19408
19409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19410 if (obj0) {
19411 {
19412 arg1 = (wxEventType)(SWIG_As_int(obj0));
19413 if (SWIG_arg_fail(1)) SWIG_fail;
19414 }
19415 }
19416 if (obj1) {
19417 {
19418 arg2 = (int)(SWIG_As_int(obj1));
19419 if (SWIG_arg_fail(2)) SWIG_fail;
19420 }
19421 }
19422 {
19423 PyThreadState* __tstate = wxPyBeginAllowThreads();
19424 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19425
19426 wxPyEndAllowThreads(__tstate);
19427 if (PyErr_Occurred()) SWIG_fail;
19428 }
19429 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19430 return resultobj;
19431 fail:
19432 return NULL;
19433 }
19434
19435
19436 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19437 PyObject *resultobj;
19438 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19439 wxWindow *result;
19440 PyObject * obj0 = 0 ;
19441 char *kwnames[] = {
19442 (char *) "self", NULL
19443 };
19444
19445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19447 if (SWIG_arg_fail(1)) SWIG_fail;
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19451
19452 wxPyEndAllowThreads(__tstate);
19453 if (PyErr_Occurred()) SWIG_fail;
19454 }
19455 {
19456 resultobj = wxPyMake_wxObject(result, 0);
19457 }
19458 return resultobj;
19459 fail:
19460 return NULL;
19461 }
19462
19463
19464 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19465 PyObject *resultobj;
19466 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19467 wxWindow *arg2 = (wxWindow *) 0 ;
19468 PyObject * obj0 = 0 ;
19469 PyObject * obj1 = 0 ;
19470 char *kwnames[] = {
19471 (char *) "self",(char *) "win", NULL
19472 };
19473
19474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19476 if (SWIG_arg_fail(1)) SWIG_fail;
19477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19478 if (SWIG_arg_fail(2)) SWIG_fail;
19479 {
19480 PyThreadState* __tstate = wxPyBeginAllowThreads();
19481 (arg1)->SetWindow(arg2);
19482
19483 wxPyEndAllowThreads(__tstate);
19484 if (PyErr_Occurred()) SWIG_fail;
19485 }
19486 Py_INCREF(Py_None); resultobj = Py_None;
19487 return resultobj;
19488 fail:
19489 return NULL;
19490 }
19491
19492
19493 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19494 PyObject *obj;
19495 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19496 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19497 Py_INCREF(obj);
19498 return Py_BuildValue((char *)"");
19499 }
19500 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19501 PyObject *resultobj;
19502 wxWindow *arg1 = (wxWindow *) NULL ;
19503 wxChildFocusEvent *result;
19504 PyObject * obj0 = 0 ;
19505 char *kwnames[] = {
19506 (char *) "win", NULL
19507 };
19508
19509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19510 if (obj0) {
19511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19512 if (SWIG_arg_fail(1)) SWIG_fail;
19513 }
19514 {
19515 PyThreadState* __tstate = wxPyBeginAllowThreads();
19516 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19517
19518 wxPyEndAllowThreads(__tstate);
19519 if (PyErr_Occurred()) SWIG_fail;
19520 }
19521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19522 return resultobj;
19523 fail:
19524 return NULL;
19525 }
19526
19527
19528 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19529 PyObject *resultobj;
19530 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19531 wxWindow *result;
19532 PyObject * obj0 = 0 ;
19533 char *kwnames[] = {
19534 (char *) "self", NULL
19535 };
19536
19537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19539 if (SWIG_arg_fail(1)) SWIG_fail;
19540 {
19541 PyThreadState* __tstate = wxPyBeginAllowThreads();
19542 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19543
19544 wxPyEndAllowThreads(__tstate);
19545 if (PyErr_Occurred()) SWIG_fail;
19546 }
19547 {
19548 resultobj = wxPyMake_wxObject(result, 0);
19549 }
19550 return resultobj;
19551 fail:
19552 return NULL;
19553 }
19554
19555
19556 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19557 PyObject *obj;
19558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19559 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19560 Py_INCREF(obj);
19561 return Py_BuildValue((char *)"");
19562 }
19563 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19564 PyObject *resultobj;
19565 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19566 bool arg2 = (bool) true ;
19567 int arg3 = (int) 0 ;
19568 wxActivateEvent *result;
19569 PyObject * obj0 = 0 ;
19570 PyObject * obj1 = 0 ;
19571 PyObject * obj2 = 0 ;
19572 char *kwnames[] = {
19573 (char *) "type",(char *) "active",(char *) "Id", NULL
19574 };
19575
19576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19577 if (obj0) {
19578 {
19579 arg1 = (wxEventType)(SWIG_As_int(obj0));
19580 if (SWIG_arg_fail(1)) SWIG_fail;
19581 }
19582 }
19583 if (obj1) {
19584 {
19585 arg2 = (bool)(SWIG_As_bool(obj1));
19586 if (SWIG_arg_fail(2)) SWIG_fail;
19587 }
19588 }
19589 if (obj2) {
19590 {
19591 arg3 = (int)(SWIG_As_int(obj2));
19592 if (SWIG_arg_fail(3)) SWIG_fail;
19593 }
19594 }
19595 {
19596 PyThreadState* __tstate = wxPyBeginAllowThreads();
19597 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19598
19599 wxPyEndAllowThreads(__tstate);
19600 if (PyErr_Occurred()) SWIG_fail;
19601 }
19602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19603 return resultobj;
19604 fail:
19605 return NULL;
19606 }
19607
19608
19609 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19610 PyObject *resultobj;
19611 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19612 bool result;
19613 PyObject * obj0 = 0 ;
19614 char *kwnames[] = {
19615 (char *) "self", NULL
19616 };
19617
19618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19620 if (SWIG_arg_fail(1)) SWIG_fail;
19621 {
19622 PyThreadState* __tstate = wxPyBeginAllowThreads();
19623 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19624
19625 wxPyEndAllowThreads(__tstate);
19626 if (PyErr_Occurred()) SWIG_fail;
19627 }
19628 {
19629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19630 }
19631 return resultobj;
19632 fail:
19633 return NULL;
19634 }
19635
19636
19637 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19638 PyObject *obj;
19639 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19640 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19641 Py_INCREF(obj);
19642 return Py_BuildValue((char *)"");
19643 }
19644 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19645 PyObject *resultobj;
19646 int arg1 = (int) 0 ;
19647 wxInitDialogEvent *result;
19648 PyObject * obj0 = 0 ;
19649 char *kwnames[] = {
19650 (char *) "Id", NULL
19651 };
19652
19653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19654 if (obj0) {
19655 {
19656 arg1 = (int)(SWIG_As_int(obj0));
19657 if (SWIG_arg_fail(1)) SWIG_fail;
19658 }
19659 }
19660 {
19661 PyThreadState* __tstate = wxPyBeginAllowThreads();
19662 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19663
19664 wxPyEndAllowThreads(__tstate);
19665 if (PyErr_Occurred()) SWIG_fail;
19666 }
19667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19668 return resultobj;
19669 fail:
19670 return NULL;
19671 }
19672
19673
19674 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19675 PyObject *obj;
19676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19677 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19678 Py_INCREF(obj);
19679 return Py_BuildValue((char *)"");
19680 }
19681 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19682 PyObject *resultobj;
19683 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19684 int arg2 = (int) 0 ;
19685 wxMenu *arg3 = (wxMenu *) NULL ;
19686 wxMenuEvent *result;
19687 PyObject * obj0 = 0 ;
19688 PyObject * obj1 = 0 ;
19689 PyObject * obj2 = 0 ;
19690 char *kwnames[] = {
19691 (char *) "type",(char *) "winid",(char *) "menu", NULL
19692 };
19693
19694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19695 if (obj0) {
19696 {
19697 arg1 = (wxEventType)(SWIG_As_int(obj0));
19698 if (SWIG_arg_fail(1)) SWIG_fail;
19699 }
19700 }
19701 if (obj1) {
19702 {
19703 arg2 = (int)(SWIG_As_int(obj1));
19704 if (SWIG_arg_fail(2)) SWIG_fail;
19705 }
19706 }
19707 if (obj2) {
19708 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19709 if (SWIG_arg_fail(3)) SWIG_fail;
19710 }
19711 {
19712 PyThreadState* __tstate = wxPyBeginAllowThreads();
19713 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19714
19715 wxPyEndAllowThreads(__tstate);
19716 if (PyErr_Occurred()) SWIG_fail;
19717 }
19718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19719 return resultobj;
19720 fail:
19721 return NULL;
19722 }
19723
19724
19725 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19726 PyObject *resultobj;
19727 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19728 int result;
19729 PyObject * obj0 = 0 ;
19730 char *kwnames[] = {
19731 (char *) "self", NULL
19732 };
19733
19734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19736 if (SWIG_arg_fail(1)) SWIG_fail;
19737 {
19738 PyThreadState* __tstate = wxPyBeginAllowThreads();
19739 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19740
19741 wxPyEndAllowThreads(__tstate);
19742 if (PyErr_Occurred()) SWIG_fail;
19743 }
19744 {
19745 resultobj = SWIG_From_int((int)(result));
19746 }
19747 return resultobj;
19748 fail:
19749 return NULL;
19750 }
19751
19752
19753 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19754 PyObject *resultobj;
19755 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19756 bool result;
19757 PyObject * obj0 = 0 ;
19758 char *kwnames[] = {
19759 (char *) "self", NULL
19760 };
19761
19762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19764 if (SWIG_arg_fail(1)) SWIG_fail;
19765 {
19766 PyThreadState* __tstate = wxPyBeginAllowThreads();
19767 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19768
19769 wxPyEndAllowThreads(__tstate);
19770 if (PyErr_Occurred()) SWIG_fail;
19771 }
19772 {
19773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19774 }
19775 return resultobj;
19776 fail:
19777 return NULL;
19778 }
19779
19780
19781 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19782 PyObject *resultobj;
19783 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19784 wxMenu *result;
19785 PyObject * obj0 = 0 ;
19786 char *kwnames[] = {
19787 (char *) "self", NULL
19788 };
19789
19790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19792 if (SWIG_arg_fail(1)) SWIG_fail;
19793 {
19794 PyThreadState* __tstate = wxPyBeginAllowThreads();
19795 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19796
19797 wxPyEndAllowThreads(__tstate);
19798 if (PyErr_Occurred()) SWIG_fail;
19799 }
19800 {
19801 resultobj = wxPyMake_wxObject(result, 0);
19802 }
19803 return resultobj;
19804 fail:
19805 return NULL;
19806 }
19807
19808
19809 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19810 PyObject *obj;
19811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19812 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19813 Py_INCREF(obj);
19814 return Py_BuildValue((char *)"");
19815 }
19816 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19817 PyObject *resultobj;
19818 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19819 int arg2 = (int) 0 ;
19820 wxCloseEvent *result;
19821 PyObject * obj0 = 0 ;
19822 PyObject * obj1 = 0 ;
19823 char *kwnames[] = {
19824 (char *) "type",(char *) "winid", NULL
19825 };
19826
19827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19828 if (obj0) {
19829 {
19830 arg1 = (wxEventType)(SWIG_As_int(obj0));
19831 if (SWIG_arg_fail(1)) SWIG_fail;
19832 }
19833 }
19834 if (obj1) {
19835 {
19836 arg2 = (int)(SWIG_As_int(obj1));
19837 if (SWIG_arg_fail(2)) SWIG_fail;
19838 }
19839 }
19840 {
19841 PyThreadState* __tstate = wxPyBeginAllowThreads();
19842 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19843
19844 wxPyEndAllowThreads(__tstate);
19845 if (PyErr_Occurred()) SWIG_fail;
19846 }
19847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19848 return resultobj;
19849 fail:
19850 return NULL;
19851 }
19852
19853
19854 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19855 PyObject *resultobj;
19856 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19857 bool arg2 ;
19858 PyObject * obj0 = 0 ;
19859 PyObject * obj1 = 0 ;
19860 char *kwnames[] = {
19861 (char *) "self",(char *) "logOff", NULL
19862 };
19863
19864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19866 if (SWIG_arg_fail(1)) SWIG_fail;
19867 {
19868 arg2 = (bool)(SWIG_As_bool(obj1));
19869 if (SWIG_arg_fail(2)) SWIG_fail;
19870 }
19871 {
19872 PyThreadState* __tstate = wxPyBeginAllowThreads();
19873 (arg1)->SetLoggingOff(arg2);
19874
19875 wxPyEndAllowThreads(__tstate);
19876 if (PyErr_Occurred()) SWIG_fail;
19877 }
19878 Py_INCREF(Py_None); resultobj = Py_None;
19879 return resultobj;
19880 fail:
19881 return NULL;
19882 }
19883
19884
19885 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19886 PyObject *resultobj;
19887 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19888 bool result;
19889 PyObject * obj0 = 0 ;
19890 char *kwnames[] = {
19891 (char *) "self", NULL
19892 };
19893
19894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19896 if (SWIG_arg_fail(1)) SWIG_fail;
19897 {
19898 PyThreadState* __tstate = wxPyBeginAllowThreads();
19899 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19900
19901 wxPyEndAllowThreads(__tstate);
19902 if (PyErr_Occurred()) SWIG_fail;
19903 }
19904 {
19905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19906 }
19907 return resultobj;
19908 fail:
19909 return NULL;
19910 }
19911
19912
19913 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19914 PyObject *resultobj;
19915 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19916 bool arg2 = (bool) true ;
19917 PyObject * obj0 = 0 ;
19918 PyObject * obj1 = 0 ;
19919 char *kwnames[] = {
19920 (char *) "self",(char *) "veto", NULL
19921 };
19922
19923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19925 if (SWIG_arg_fail(1)) SWIG_fail;
19926 if (obj1) {
19927 {
19928 arg2 = (bool)(SWIG_As_bool(obj1));
19929 if (SWIG_arg_fail(2)) SWIG_fail;
19930 }
19931 }
19932 {
19933 PyThreadState* __tstate = wxPyBeginAllowThreads();
19934 (arg1)->Veto(arg2);
19935
19936 wxPyEndAllowThreads(__tstate);
19937 if (PyErr_Occurred()) SWIG_fail;
19938 }
19939 Py_INCREF(Py_None); resultobj = Py_None;
19940 return resultobj;
19941 fail:
19942 return NULL;
19943 }
19944
19945
19946 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19947 PyObject *resultobj;
19948 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19949 bool arg2 ;
19950 PyObject * obj0 = 0 ;
19951 PyObject * obj1 = 0 ;
19952 char *kwnames[] = {
19953 (char *) "self",(char *) "canVeto", NULL
19954 };
19955
19956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19958 if (SWIG_arg_fail(1)) SWIG_fail;
19959 {
19960 arg2 = (bool)(SWIG_As_bool(obj1));
19961 if (SWIG_arg_fail(2)) SWIG_fail;
19962 }
19963 {
19964 PyThreadState* __tstate = wxPyBeginAllowThreads();
19965 (arg1)->SetCanVeto(arg2);
19966
19967 wxPyEndAllowThreads(__tstate);
19968 if (PyErr_Occurred()) SWIG_fail;
19969 }
19970 Py_INCREF(Py_None); resultobj = Py_None;
19971 return resultobj;
19972 fail:
19973 return NULL;
19974 }
19975
19976
19977 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19978 PyObject *resultobj;
19979 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19980 bool result;
19981 PyObject * obj0 = 0 ;
19982 char *kwnames[] = {
19983 (char *) "self", NULL
19984 };
19985
19986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19988 if (SWIG_arg_fail(1)) SWIG_fail;
19989 {
19990 PyThreadState* __tstate = wxPyBeginAllowThreads();
19991 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19992
19993 wxPyEndAllowThreads(__tstate);
19994 if (PyErr_Occurred()) SWIG_fail;
19995 }
19996 {
19997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19998 }
19999 return resultobj;
20000 fail:
20001 return NULL;
20002 }
20003
20004
20005 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20006 PyObject *resultobj;
20007 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20008 bool result;
20009 PyObject * obj0 = 0 ;
20010 char *kwnames[] = {
20011 (char *) "self", NULL
20012 };
20013
20014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20016 if (SWIG_arg_fail(1)) SWIG_fail;
20017 {
20018 PyThreadState* __tstate = wxPyBeginAllowThreads();
20019 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20020
20021 wxPyEndAllowThreads(__tstate);
20022 if (PyErr_Occurred()) SWIG_fail;
20023 }
20024 {
20025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20026 }
20027 return resultobj;
20028 fail:
20029 return NULL;
20030 }
20031
20032
20033 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20034 PyObject *obj;
20035 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20036 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20037 Py_INCREF(obj);
20038 return Py_BuildValue((char *)"");
20039 }
20040 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20041 PyObject *resultobj;
20042 int arg1 = (int) 0 ;
20043 bool arg2 = (bool) false ;
20044 wxShowEvent *result;
20045 PyObject * obj0 = 0 ;
20046 PyObject * obj1 = 0 ;
20047 char *kwnames[] = {
20048 (char *) "winid",(char *) "show", NULL
20049 };
20050
20051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20052 if (obj0) {
20053 {
20054 arg1 = (int)(SWIG_As_int(obj0));
20055 if (SWIG_arg_fail(1)) SWIG_fail;
20056 }
20057 }
20058 if (obj1) {
20059 {
20060 arg2 = (bool)(SWIG_As_bool(obj1));
20061 if (SWIG_arg_fail(2)) SWIG_fail;
20062 }
20063 }
20064 {
20065 PyThreadState* __tstate = wxPyBeginAllowThreads();
20066 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20067
20068 wxPyEndAllowThreads(__tstate);
20069 if (PyErr_Occurred()) SWIG_fail;
20070 }
20071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20072 return resultobj;
20073 fail:
20074 return NULL;
20075 }
20076
20077
20078 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20079 PyObject *resultobj;
20080 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20081 bool arg2 ;
20082 PyObject * obj0 = 0 ;
20083 PyObject * obj1 = 0 ;
20084 char *kwnames[] = {
20085 (char *) "self",(char *) "show", NULL
20086 };
20087
20088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20090 if (SWIG_arg_fail(1)) SWIG_fail;
20091 {
20092 arg2 = (bool)(SWIG_As_bool(obj1));
20093 if (SWIG_arg_fail(2)) SWIG_fail;
20094 }
20095 {
20096 PyThreadState* __tstate = wxPyBeginAllowThreads();
20097 (arg1)->SetShow(arg2);
20098
20099 wxPyEndAllowThreads(__tstate);
20100 if (PyErr_Occurred()) SWIG_fail;
20101 }
20102 Py_INCREF(Py_None); resultobj = Py_None;
20103 return resultobj;
20104 fail:
20105 return NULL;
20106 }
20107
20108
20109 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20110 PyObject *resultobj;
20111 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20112 bool result;
20113 PyObject * obj0 = 0 ;
20114 char *kwnames[] = {
20115 (char *) "self", NULL
20116 };
20117
20118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20120 if (SWIG_arg_fail(1)) SWIG_fail;
20121 {
20122 PyThreadState* __tstate = wxPyBeginAllowThreads();
20123 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20124
20125 wxPyEndAllowThreads(__tstate);
20126 if (PyErr_Occurred()) SWIG_fail;
20127 }
20128 {
20129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20130 }
20131 return resultobj;
20132 fail:
20133 return NULL;
20134 }
20135
20136
20137 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20138 PyObject *obj;
20139 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20140 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20141 Py_INCREF(obj);
20142 return Py_BuildValue((char *)"");
20143 }
20144 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20145 PyObject *resultobj;
20146 int arg1 = (int) 0 ;
20147 bool arg2 = (bool) true ;
20148 wxIconizeEvent *result;
20149 PyObject * obj0 = 0 ;
20150 PyObject * obj1 = 0 ;
20151 char *kwnames[] = {
20152 (char *) "id",(char *) "iconized", NULL
20153 };
20154
20155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20156 if (obj0) {
20157 {
20158 arg1 = (int)(SWIG_As_int(obj0));
20159 if (SWIG_arg_fail(1)) SWIG_fail;
20160 }
20161 }
20162 if (obj1) {
20163 {
20164 arg2 = (bool)(SWIG_As_bool(obj1));
20165 if (SWIG_arg_fail(2)) SWIG_fail;
20166 }
20167 }
20168 {
20169 PyThreadState* __tstate = wxPyBeginAllowThreads();
20170 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20171
20172 wxPyEndAllowThreads(__tstate);
20173 if (PyErr_Occurred()) SWIG_fail;
20174 }
20175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20183 PyObject *resultobj;
20184 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20185 bool result;
20186 PyObject * obj0 = 0 ;
20187 char *kwnames[] = {
20188 (char *) "self", NULL
20189 };
20190
20191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20193 if (SWIG_arg_fail(1)) SWIG_fail;
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 result = (bool)(arg1)->Iconized();
20197
20198 wxPyEndAllowThreads(__tstate);
20199 if (PyErr_Occurred()) SWIG_fail;
20200 }
20201 {
20202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20203 }
20204 return resultobj;
20205 fail:
20206 return NULL;
20207 }
20208
20209
20210 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20211 PyObject *obj;
20212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20213 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20214 Py_INCREF(obj);
20215 return Py_BuildValue((char *)"");
20216 }
20217 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20218 PyObject *resultobj;
20219 int arg1 = (int) 0 ;
20220 wxMaximizeEvent *result;
20221 PyObject * obj0 = 0 ;
20222 char *kwnames[] = {
20223 (char *) "id", NULL
20224 };
20225
20226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20227 if (obj0) {
20228 {
20229 arg1 = (int)(SWIG_As_int(obj0));
20230 if (SWIG_arg_fail(1)) SWIG_fail;
20231 }
20232 }
20233 {
20234 PyThreadState* __tstate = wxPyBeginAllowThreads();
20235 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20236
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20248 PyObject *obj;
20249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20250 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20251 Py_INCREF(obj);
20252 return Py_BuildValue((char *)"");
20253 }
20254 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20255 PyObject *resultobj;
20256 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20257 wxPoint result;
20258 PyObject * obj0 = 0 ;
20259 char *kwnames[] = {
20260 (char *) "self", NULL
20261 };
20262
20263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20265 if (SWIG_arg_fail(1)) SWIG_fail;
20266 {
20267 PyThreadState* __tstate = wxPyBeginAllowThreads();
20268 result = (arg1)->GetPosition();
20269
20270 wxPyEndAllowThreads(__tstate);
20271 if (PyErr_Occurred()) SWIG_fail;
20272 }
20273 {
20274 wxPoint * resultptr;
20275 resultptr = new wxPoint((wxPoint &)(result));
20276 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20277 }
20278 return resultobj;
20279 fail:
20280 return NULL;
20281 }
20282
20283
20284 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20285 PyObject *resultobj;
20286 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20287 int result;
20288 PyObject * obj0 = 0 ;
20289 char *kwnames[] = {
20290 (char *) "self", NULL
20291 };
20292
20293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20295 if (SWIG_arg_fail(1)) SWIG_fail;
20296 {
20297 PyThreadState* __tstate = wxPyBeginAllowThreads();
20298 result = (int)(arg1)->GetNumberOfFiles();
20299
20300 wxPyEndAllowThreads(__tstate);
20301 if (PyErr_Occurred()) SWIG_fail;
20302 }
20303 {
20304 resultobj = SWIG_From_int((int)(result));
20305 }
20306 return resultobj;
20307 fail:
20308 return NULL;
20309 }
20310
20311
20312 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20313 PyObject *resultobj;
20314 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20315 PyObject *result;
20316 PyObject * obj0 = 0 ;
20317 char *kwnames[] = {
20318 (char *) "self", NULL
20319 };
20320
20321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20323 if (SWIG_arg_fail(1)) SWIG_fail;
20324 {
20325 PyThreadState* __tstate = wxPyBeginAllowThreads();
20326 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20327
20328 wxPyEndAllowThreads(__tstate);
20329 if (PyErr_Occurred()) SWIG_fail;
20330 }
20331 resultobj = result;
20332 return resultobj;
20333 fail:
20334 return NULL;
20335 }
20336
20337
20338 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20339 PyObject *obj;
20340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20341 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20342 Py_INCREF(obj);
20343 return Py_BuildValue((char *)"");
20344 }
20345 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20346 PyObject *resultobj;
20347 int arg1 = (int) 0 ;
20348 wxUpdateUIEvent *result;
20349 PyObject * obj0 = 0 ;
20350 char *kwnames[] = {
20351 (char *) "commandId", NULL
20352 };
20353
20354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20355 if (obj0) {
20356 {
20357 arg1 = (int)(SWIG_As_int(obj0));
20358 if (SWIG_arg_fail(1)) SWIG_fail;
20359 }
20360 }
20361 {
20362 PyThreadState* __tstate = wxPyBeginAllowThreads();
20363 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20364
20365 wxPyEndAllowThreads(__tstate);
20366 if (PyErr_Occurred()) SWIG_fail;
20367 }
20368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20369 return resultobj;
20370 fail:
20371 return NULL;
20372 }
20373
20374
20375 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20376 PyObject *resultobj;
20377 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20378 bool result;
20379 PyObject * obj0 = 0 ;
20380 char *kwnames[] = {
20381 (char *) "self", NULL
20382 };
20383
20384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20386 if (SWIG_arg_fail(1)) SWIG_fail;
20387 {
20388 PyThreadState* __tstate = wxPyBeginAllowThreads();
20389 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20390
20391 wxPyEndAllowThreads(__tstate);
20392 if (PyErr_Occurred()) SWIG_fail;
20393 }
20394 {
20395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20396 }
20397 return resultobj;
20398 fail:
20399 return NULL;
20400 }
20401
20402
20403 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20404 PyObject *resultobj;
20405 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20406 bool result;
20407 PyObject * obj0 = 0 ;
20408 char *kwnames[] = {
20409 (char *) "self", NULL
20410 };
20411
20412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20414 if (SWIG_arg_fail(1)) SWIG_fail;
20415 {
20416 PyThreadState* __tstate = wxPyBeginAllowThreads();
20417 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20418
20419 wxPyEndAllowThreads(__tstate);
20420 if (PyErr_Occurred()) SWIG_fail;
20421 }
20422 {
20423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20424 }
20425 return resultobj;
20426 fail:
20427 return NULL;
20428 }
20429
20430
20431 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20432 PyObject *resultobj;
20433 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20434 wxString result;
20435 PyObject * obj0 = 0 ;
20436 char *kwnames[] = {
20437 (char *) "self", NULL
20438 };
20439
20440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20442 if (SWIG_arg_fail(1)) SWIG_fail;
20443 {
20444 PyThreadState* __tstate = wxPyBeginAllowThreads();
20445 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20446
20447 wxPyEndAllowThreads(__tstate);
20448 if (PyErr_Occurred()) SWIG_fail;
20449 }
20450 {
20451 #if wxUSE_UNICODE
20452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20453 #else
20454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20455 #endif
20456 }
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20464 PyObject *resultobj;
20465 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20466 bool result;
20467 PyObject * obj0 = 0 ;
20468 char *kwnames[] = {
20469 (char *) "self", NULL
20470 };
20471
20472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20474 if (SWIG_arg_fail(1)) SWIG_fail;
20475 {
20476 PyThreadState* __tstate = wxPyBeginAllowThreads();
20477 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20478
20479 wxPyEndAllowThreads(__tstate);
20480 if (PyErr_Occurred()) SWIG_fail;
20481 }
20482 {
20483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20484 }
20485 return resultobj;
20486 fail:
20487 return NULL;
20488 }
20489
20490
20491 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20492 PyObject *resultobj;
20493 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20494 bool result;
20495 PyObject * obj0 = 0 ;
20496 char *kwnames[] = {
20497 (char *) "self", NULL
20498 };
20499
20500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20502 if (SWIG_arg_fail(1)) SWIG_fail;
20503 {
20504 PyThreadState* __tstate = wxPyBeginAllowThreads();
20505 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20506
20507 wxPyEndAllowThreads(__tstate);
20508 if (PyErr_Occurred()) SWIG_fail;
20509 }
20510 {
20511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20512 }
20513 return resultobj;
20514 fail:
20515 return NULL;
20516 }
20517
20518
20519 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20520 PyObject *resultobj;
20521 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20522 bool result;
20523 PyObject * obj0 = 0 ;
20524 char *kwnames[] = {
20525 (char *) "self", NULL
20526 };
20527
20528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20530 if (SWIG_arg_fail(1)) SWIG_fail;
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20534
20535 wxPyEndAllowThreads(__tstate);
20536 if (PyErr_Occurred()) SWIG_fail;
20537 }
20538 {
20539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20540 }
20541 return resultobj;
20542 fail:
20543 return NULL;
20544 }
20545
20546
20547 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20548 PyObject *resultobj;
20549 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20550 bool arg2 ;
20551 PyObject * obj0 = 0 ;
20552 PyObject * obj1 = 0 ;
20553 char *kwnames[] = {
20554 (char *) "self",(char *) "check", NULL
20555 };
20556
20557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20559 if (SWIG_arg_fail(1)) SWIG_fail;
20560 {
20561 arg2 = (bool)(SWIG_As_bool(obj1));
20562 if (SWIG_arg_fail(2)) SWIG_fail;
20563 }
20564 {
20565 PyThreadState* __tstate = wxPyBeginAllowThreads();
20566 (arg1)->Check(arg2);
20567
20568 wxPyEndAllowThreads(__tstate);
20569 if (PyErr_Occurred()) SWIG_fail;
20570 }
20571 Py_INCREF(Py_None); resultobj = Py_None;
20572 return resultobj;
20573 fail:
20574 return NULL;
20575 }
20576
20577
20578 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20579 PyObject *resultobj;
20580 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20581 bool arg2 ;
20582 PyObject * obj0 = 0 ;
20583 PyObject * obj1 = 0 ;
20584 char *kwnames[] = {
20585 (char *) "self",(char *) "enable", NULL
20586 };
20587
20588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20590 if (SWIG_arg_fail(1)) SWIG_fail;
20591 {
20592 arg2 = (bool)(SWIG_As_bool(obj1));
20593 if (SWIG_arg_fail(2)) SWIG_fail;
20594 }
20595 {
20596 PyThreadState* __tstate = wxPyBeginAllowThreads();
20597 (arg1)->Enable(arg2);
20598
20599 wxPyEndAllowThreads(__tstate);
20600 if (PyErr_Occurred()) SWIG_fail;
20601 }
20602 Py_INCREF(Py_None); resultobj = Py_None;
20603 return resultobj;
20604 fail:
20605 return NULL;
20606 }
20607
20608
20609 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20610 PyObject *resultobj;
20611 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20612 wxString *arg2 = 0 ;
20613 bool temp2 = false ;
20614 PyObject * obj0 = 0 ;
20615 PyObject * obj1 = 0 ;
20616 char *kwnames[] = {
20617 (char *) "self",(char *) "text", NULL
20618 };
20619
20620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20622 if (SWIG_arg_fail(1)) SWIG_fail;
20623 {
20624 arg2 = wxString_in_helper(obj1);
20625 if (arg2 == NULL) SWIG_fail;
20626 temp2 = true;
20627 }
20628 {
20629 PyThreadState* __tstate = wxPyBeginAllowThreads();
20630 (arg1)->SetText((wxString const &)*arg2);
20631
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 Py_INCREF(Py_None); resultobj = Py_None;
20636 {
20637 if (temp2)
20638 delete arg2;
20639 }
20640 return resultobj;
20641 fail:
20642 {
20643 if (temp2)
20644 delete arg2;
20645 }
20646 return NULL;
20647 }
20648
20649
20650 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20651 PyObject *resultobj;
20652 long arg1 ;
20653 PyObject * obj0 = 0 ;
20654 char *kwnames[] = {
20655 (char *) "updateInterval", NULL
20656 };
20657
20658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20659 {
20660 arg1 = (long)(SWIG_As_long(obj0));
20661 if (SWIG_arg_fail(1)) SWIG_fail;
20662 }
20663 {
20664 PyThreadState* __tstate = wxPyBeginAllowThreads();
20665 wxUpdateUIEvent::SetUpdateInterval(arg1);
20666
20667 wxPyEndAllowThreads(__tstate);
20668 if (PyErr_Occurred()) SWIG_fail;
20669 }
20670 Py_INCREF(Py_None); resultobj = Py_None;
20671 return resultobj;
20672 fail:
20673 return NULL;
20674 }
20675
20676
20677 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20678 PyObject *resultobj;
20679 long result;
20680 char *kwnames[] = {
20681 NULL
20682 };
20683
20684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20685 {
20686 PyThreadState* __tstate = wxPyBeginAllowThreads();
20687 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20688
20689 wxPyEndAllowThreads(__tstate);
20690 if (PyErr_Occurred()) SWIG_fail;
20691 }
20692 {
20693 resultobj = SWIG_From_long((long)(result));
20694 }
20695 return resultobj;
20696 fail:
20697 return NULL;
20698 }
20699
20700
20701 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20702 PyObject *resultobj;
20703 wxWindow *arg1 = (wxWindow *) 0 ;
20704 bool result;
20705 PyObject * obj0 = 0 ;
20706 char *kwnames[] = {
20707 (char *) "win", NULL
20708 };
20709
20710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20712 if (SWIG_arg_fail(1)) SWIG_fail;
20713 {
20714 PyThreadState* __tstate = wxPyBeginAllowThreads();
20715 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20716
20717 wxPyEndAllowThreads(__tstate);
20718 if (PyErr_Occurred()) SWIG_fail;
20719 }
20720 {
20721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20722 }
20723 return resultobj;
20724 fail:
20725 return NULL;
20726 }
20727
20728
20729 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20730 PyObject *resultobj;
20731 char *kwnames[] = {
20732 NULL
20733 };
20734
20735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20736 {
20737 PyThreadState* __tstate = wxPyBeginAllowThreads();
20738 wxUpdateUIEvent::ResetUpdateTime();
20739
20740 wxPyEndAllowThreads(__tstate);
20741 if (PyErr_Occurred()) SWIG_fail;
20742 }
20743 Py_INCREF(Py_None); resultobj = Py_None;
20744 return resultobj;
20745 fail:
20746 return NULL;
20747 }
20748
20749
20750 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20751 PyObject *resultobj;
20752 wxUpdateUIMode arg1 ;
20753 PyObject * obj0 = 0 ;
20754 char *kwnames[] = {
20755 (char *) "mode", NULL
20756 };
20757
20758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20759 {
20760 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20761 if (SWIG_arg_fail(1)) SWIG_fail;
20762 }
20763 {
20764 PyThreadState* __tstate = wxPyBeginAllowThreads();
20765 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20766
20767 wxPyEndAllowThreads(__tstate);
20768 if (PyErr_Occurred()) SWIG_fail;
20769 }
20770 Py_INCREF(Py_None); resultobj = Py_None;
20771 return resultobj;
20772 fail:
20773 return NULL;
20774 }
20775
20776
20777 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20778 PyObject *resultobj;
20779 wxUpdateUIMode result;
20780 char *kwnames[] = {
20781 NULL
20782 };
20783
20784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20785 {
20786 PyThreadState* __tstate = wxPyBeginAllowThreads();
20787 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20788
20789 wxPyEndAllowThreads(__tstate);
20790 if (PyErr_Occurred()) SWIG_fail;
20791 }
20792 resultobj = SWIG_From_int((result));
20793 return resultobj;
20794 fail:
20795 return NULL;
20796 }
20797
20798
20799 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20800 PyObject *obj;
20801 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20802 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20803 Py_INCREF(obj);
20804 return Py_BuildValue((char *)"");
20805 }
20806 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20807 PyObject *resultobj;
20808 wxSysColourChangedEvent *result;
20809 char *kwnames[] = {
20810 NULL
20811 };
20812
20813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20814 {
20815 PyThreadState* __tstate = wxPyBeginAllowThreads();
20816 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20817
20818 wxPyEndAllowThreads(__tstate);
20819 if (PyErr_Occurred()) SWIG_fail;
20820 }
20821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20822 return resultobj;
20823 fail:
20824 return NULL;
20825 }
20826
20827
20828 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20829 PyObject *obj;
20830 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20831 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20832 Py_INCREF(obj);
20833 return Py_BuildValue((char *)"");
20834 }
20835 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20836 PyObject *resultobj;
20837 int arg1 = (int) 0 ;
20838 wxWindow *arg2 = (wxWindow *) NULL ;
20839 wxMouseCaptureChangedEvent *result;
20840 PyObject * obj0 = 0 ;
20841 PyObject * obj1 = 0 ;
20842 char *kwnames[] = {
20843 (char *) "winid",(char *) "gainedCapture", NULL
20844 };
20845
20846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20847 if (obj0) {
20848 {
20849 arg1 = (int)(SWIG_As_int(obj0));
20850 if (SWIG_arg_fail(1)) SWIG_fail;
20851 }
20852 }
20853 if (obj1) {
20854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20855 if (SWIG_arg_fail(2)) SWIG_fail;
20856 }
20857 {
20858 PyThreadState* __tstate = wxPyBeginAllowThreads();
20859 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20860
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20865 return resultobj;
20866 fail:
20867 return NULL;
20868 }
20869
20870
20871 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20872 PyObject *resultobj;
20873 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20874 wxWindow *result;
20875 PyObject * obj0 = 0 ;
20876 char *kwnames[] = {
20877 (char *) "self", NULL
20878 };
20879
20880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20882 if (SWIG_arg_fail(1)) SWIG_fail;
20883 {
20884 PyThreadState* __tstate = wxPyBeginAllowThreads();
20885 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20886
20887 wxPyEndAllowThreads(__tstate);
20888 if (PyErr_Occurred()) SWIG_fail;
20889 }
20890 {
20891 resultobj = wxPyMake_wxObject(result, 0);
20892 }
20893 return resultobj;
20894 fail:
20895 return NULL;
20896 }
20897
20898
20899 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20900 PyObject *obj;
20901 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20902 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20903 Py_INCREF(obj);
20904 return Py_BuildValue((char *)"");
20905 }
20906 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20907 PyObject *resultobj;
20908 wxDisplayChangedEvent *result;
20909 char *kwnames[] = {
20910 NULL
20911 };
20912
20913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20914 {
20915 PyThreadState* __tstate = wxPyBeginAllowThreads();
20916 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20917
20918 wxPyEndAllowThreads(__tstate);
20919 if (PyErr_Occurred()) SWIG_fail;
20920 }
20921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20922 return resultobj;
20923 fail:
20924 return NULL;
20925 }
20926
20927
20928 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20929 PyObject *obj;
20930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20931 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20932 Py_INCREF(obj);
20933 return Py_BuildValue((char *)"");
20934 }
20935 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20936 PyObject *resultobj;
20937 int arg1 = (int) 0 ;
20938 wxPaletteChangedEvent *result;
20939 PyObject * obj0 = 0 ;
20940 char *kwnames[] = {
20941 (char *) "id", NULL
20942 };
20943
20944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20945 if (obj0) {
20946 {
20947 arg1 = (int)(SWIG_As_int(obj0));
20948 if (SWIG_arg_fail(1)) SWIG_fail;
20949 }
20950 }
20951 {
20952 PyThreadState* __tstate = wxPyBeginAllowThreads();
20953 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20954
20955 wxPyEndAllowThreads(__tstate);
20956 if (PyErr_Occurred()) SWIG_fail;
20957 }
20958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20959 return resultobj;
20960 fail:
20961 return NULL;
20962 }
20963
20964
20965 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20966 PyObject *resultobj;
20967 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20968 wxWindow *arg2 = (wxWindow *) 0 ;
20969 PyObject * obj0 = 0 ;
20970 PyObject * obj1 = 0 ;
20971 char *kwnames[] = {
20972 (char *) "self",(char *) "win", NULL
20973 };
20974
20975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20977 if (SWIG_arg_fail(1)) SWIG_fail;
20978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20979 if (SWIG_arg_fail(2)) SWIG_fail;
20980 {
20981 PyThreadState* __tstate = wxPyBeginAllowThreads();
20982 (arg1)->SetChangedWindow(arg2);
20983
20984 wxPyEndAllowThreads(__tstate);
20985 if (PyErr_Occurred()) SWIG_fail;
20986 }
20987 Py_INCREF(Py_None); resultobj = Py_None;
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20995 PyObject *resultobj;
20996 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20997 wxWindow *result;
20998 PyObject * obj0 = 0 ;
20999 char *kwnames[] = {
21000 (char *) "self", NULL
21001 };
21002
21003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21005 if (SWIG_arg_fail(1)) SWIG_fail;
21006 {
21007 PyThreadState* __tstate = wxPyBeginAllowThreads();
21008 result = (wxWindow *)(arg1)->GetChangedWindow();
21009
21010 wxPyEndAllowThreads(__tstate);
21011 if (PyErr_Occurred()) SWIG_fail;
21012 }
21013 {
21014 resultobj = wxPyMake_wxObject(result, 0);
21015 }
21016 return resultobj;
21017 fail:
21018 return NULL;
21019 }
21020
21021
21022 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21023 PyObject *obj;
21024 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21025 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21026 Py_INCREF(obj);
21027 return Py_BuildValue((char *)"");
21028 }
21029 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21030 PyObject *resultobj;
21031 int arg1 = (int) 0 ;
21032 wxQueryNewPaletteEvent *result;
21033 PyObject * obj0 = 0 ;
21034 char *kwnames[] = {
21035 (char *) "winid", NULL
21036 };
21037
21038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21039 if (obj0) {
21040 {
21041 arg1 = (int)(SWIG_As_int(obj0));
21042 if (SWIG_arg_fail(1)) SWIG_fail;
21043 }
21044 }
21045 {
21046 PyThreadState* __tstate = wxPyBeginAllowThreads();
21047 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21048
21049 wxPyEndAllowThreads(__tstate);
21050 if (PyErr_Occurred()) SWIG_fail;
21051 }
21052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21053 return resultobj;
21054 fail:
21055 return NULL;
21056 }
21057
21058
21059 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21060 PyObject *resultobj;
21061 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21062 bool arg2 ;
21063 PyObject * obj0 = 0 ;
21064 PyObject * obj1 = 0 ;
21065 char *kwnames[] = {
21066 (char *) "self",(char *) "realized", NULL
21067 };
21068
21069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21071 if (SWIG_arg_fail(1)) SWIG_fail;
21072 {
21073 arg2 = (bool)(SWIG_As_bool(obj1));
21074 if (SWIG_arg_fail(2)) SWIG_fail;
21075 }
21076 {
21077 PyThreadState* __tstate = wxPyBeginAllowThreads();
21078 (arg1)->SetPaletteRealized(arg2);
21079
21080 wxPyEndAllowThreads(__tstate);
21081 if (PyErr_Occurred()) SWIG_fail;
21082 }
21083 Py_INCREF(Py_None); resultobj = Py_None;
21084 return resultobj;
21085 fail:
21086 return NULL;
21087 }
21088
21089
21090 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21091 PyObject *resultobj;
21092 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21093 bool result;
21094 PyObject * obj0 = 0 ;
21095 char *kwnames[] = {
21096 (char *) "self", NULL
21097 };
21098
21099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21101 if (SWIG_arg_fail(1)) SWIG_fail;
21102 {
21103 PyThreadState* __tstate = wxPyBeginAllowThreads();
21104 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21105
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 {
21110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21111 }
21112 return resultobj;
21113 fail:
21114 return NULL;
21115 }
21116
21117
21118 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21119 PyObject *obj;
21120 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21121 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21122 Py_INCREF(obj);
21123 return Py_BuildValue((char *)"");
21124 }
21125 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21126 PyObject *resultobj;
21127 wxNavigationKeyEvent *result;
21128 char *kwnames[] = {
21129 NULL
21130 };
21131
21132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21136
21137 wxPyEndAllowThreads(__tstate);
21138 if (PyErr_Occurred()) SWIG_fail;
21139 }
21140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21141 return resultobj;
21142 fail:
21143 return NULL;
21144 }
21145
21146
21147 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21148 PyObject *resultobj;
21149 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21150 bool result;
21151 PyObject * obj0 = 0 ;
21152 char *kwnames[] = {
21153 (char *) "self", NULL
21154 };
21155
21156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21158 if (SWIG_arg_fail(1)) SWIG_fail;
21159 {
21160 PyThreadState* __tstate = wxPyBeginAllowThreads();
21161 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21162
21163 wxPyEndAllowThreads(__tstate);
21164 if (PyErr_Occurred()) SWIG_fail;
21165 }
21166 {
21167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21168 }
21169 return resultobj;
21170 fail:
21171 return NULL;
21172 }
21173
21174
21175 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21176 PyObject *resultobj;
21177 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21178 bool arg2 ;
21179 PyObject * obj0 = 0 ;
21180 PyObject * obj1 = 0 ;
21181 char *kwnames[] = {
21182 (char *) "self",(char *) "forward", NULL
21183 };
21184
21185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21187 if (SWIG_arg_fail(1)) SWIG_fail;
21188 {
21189 arg2 = (bool)(SWIG_As_bool(obj1));
21190 if (SWIG_arg_fail(2)) SWIG_fail;
21191 }
21192 {
21193 PyThreadState* __tstate = wxPyBeginAllowThreads();
21194 (arg1)->SetDirection(arg2);
21195
21196 wxPyEndAllowThreads(__tstate);
21197 if (PyErr_Occurred()) SWIG_fail;
21198 }
21199 Py_INCREF(Py_None); resultobj = Py_None;
21200 return resultobj;
21201 fail:
21202 return NULL;
21203 }
21204
21205
21206 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21207 PyObject *resultobj;
21208 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21209 bool result;
21210 PyObject * obj0 = 0 ;
21211 char *kwnames[] = {
21212 (char *) "self", NULL
21213 };
21214
21215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21217 if (SWIG_arg_fail(1)) SWIG_fail;
21218 {
21219 PyThreadState* __tstate = wxPyBeginAllowThreads();
21220 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21221
21222 wxPyEndAllowThreads(__tstate);
21223 if (PyErr_Occurred()) SWIG_fail;
21224 }
21225 {
21226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21227 }
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21235 PyObject *resultobj;
21236 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21237 bool arg2 ;
21238 PyObject * obj0 = 0 ;
21239 PyObject * obj1 = 0 ;
21240 char *kwnames[] = {
21241 (char *) "self",(char *) "ischange", NULL
21242 };
21243
21244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21246 if (SWIG_arg_fail(1)) SWIG_fail;
21247 {
21248 arg2 = (bool)(SWIG_As_bool(obj1));
21249 if (SWIG_arg_fail(2)) SWIG_fail;
21250 }
21251 {
21252 PyThreadState* __tstate = wxPyBeginAllowThreads();
21253 (arg1)->SetWindowChange(arg2);
21254
21255 wxPyEndAllowThreads(__tstate);
21256 if (PyErr_Occurred()) SWIG_fail;
21257 }
21258 Py_INCREF(Py_None); resultobj = Py_None;
21259 return resultobj;
21260 fail:
21261 return NULL;
21262 }
21263
21264
21265 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21266 PyObject *resultobj;
21267 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21268 bool result;
21269 PyObject * obj0 = 0 ;
21270 char *kwnames[] = {
21271 (char *) "self", NULL
21272 };
21273
21274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21276 if (SWIG_arg_fail(1)) SWIG_fail;
21277 {
21278 PyThreadState* __tstate = wxPyBeginAllowThreads();
21279 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21280
21281 wxPyEndAllowThreads(__tstate);
21282 if (PyErr_Occurred()) SWIG_fail;
21283 }
21284 {
21285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21286 }
21287 return resultobj;
21288 fail:
21289 return NULL;
21290 }
21291
21292
21293 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21294 PyObject *resultobj;
21295 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21296 bool arg2 ;
21297 PyObject * obj0 = 0 ;
21298 PyObject * obj1 = 0 ;
21299 char *kwnames[] = {
21300 (char *) "self",(char *) "bIs", NULL
21301 };
21302
21303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21305 if (SWIG_arg_fail(1)) SWIG_fail;
21306 {
21307 arg2 = (bool)(SWIG_As_bool(obj1));
21308 if (SWIG_arg_fail(2)) SWIG_fail;
21309 }
21310 {
21311 PyThreadState* __tstate = wxPyBeginAllowThreads();
21312 (arg1)->SetFromTab(arg2);
21313
21314 wxPyEndAllowThreads(__tstate);
21315 if (PyErr_Occurred()) SWIG_fail;
21316 }
21317 Py_INCREF(Py_None); resultobj = Py_None;
21318 return resultobj;
21319 fail:
21320 return NULL;
21321 }
21322
21323
21324 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21325 PyObject *resultobj;
21326 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21327 long arg2 ;
21328 PyObject * obj0 = 0 ;
21329 PyObject * obj1 = 0 ;
21330 char *kwnames[] = {
21331 (char *) "self",(char *) "flags", NULL
21332 };
21333
21334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21336 if (SWIG_arg_fail(1)) SWIG_fail;
21337 {
21338 arg2 = (long)(SWIG_As_long(obj1));
21339 if (SWIG_arg_fail(2)) SWIG_fail;
21340 }
21341 {
21342 PyThreadState* __tstate = wxPyBeginAllowThreads();
21343 (arg1)->SetFlags(arg2);
21344
21345 wxPyEndAllowThreads(__tstate);
21346 if (PyErr_Occurred()) SWIG_fail;
21347 }
21348 Py_INCREF(Py_None); resultobj = Py_None;
21349 return resultobj;
21350 fail:
21351 return NULL;
21352 }
21353
21354
21355 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21356 PyObject *resultobj;
21357 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21358 wxWindow *result;
21359 PyObject * obj0 = 0 ;
21360 char *kwnames[] = {
21361 (char *) "self", NULL
21362 };
21363
21364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21366 if (SWIG_arg_fail(1)) SWIG_fail;
21367 {
21368 PyThreadState* __tstate = wxPyBeginAllowThreads();
21369 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21370
21371 wxPyEndAllowThreads(__tstate);
21372 if (PyErr_Occurred()) SWIG_fail;
21373 }
21374 {
21375 resultobj = wxPyMake_wxObject(result, 0);
21376 }
21377 return resultobj;
21378 fail:
21379 return NULL;
21380 }
21381
21382
21383 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21384 PyObject *resultobj;
21385 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21386 wxWindow *arg2 = (wxWindow *) 0 ;
21387 PyObject * obj0 = 0 ;
21388 PyObject * obj1 = 0 ;
21389 char *kwnames[] = {
21390 (char *) "self",(char *) "win", NULL
21391 };
21392
21393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21395 if (SWIG_arg_fail(1)) SWIG_fail;
21396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21397 if (SWIG_arg_fail(2)) SWIG_fail;
21398 {
21399 PyThreadState* __tstate = wxPyBeginAllowThreads();
21400 (arg1)->SetCurrentFocus(arg2);
21401
21402 wxPyEndAllowThreads(__tstate);
21403 if (PyErr_Occurred()) SWIG_fail;
21404 }
21405 Py_INCREF(Py_None); resultobj = Py_None;
21406 return resultobj;
21407 fail:
21408 return NULL;
21409 }
21410
21411
21412 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21413 PyObject *obj;
21414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21415 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21416 Py_INCREF(obj);
21417 return Py_BuildValue((char *)"");
21418 }
21419 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21420 PyObject *resultobj;
21421 wxWindow *arg1 = (wxWindow *) NULL ;
21422 wxWindowCreateEvent *result;
21423 PyObject * obj0 = 0 ;
21424 char *kwnames[] = {
21425 (char *) "win", NULL
21426 };
21427
21428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21429 if (obj0) {
21430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21431 if (SWIG_arg_fail(1)) SWIG_fail;
21432 }
21433 {
21434 PyThreadState* __tstate = wxPyBeginAllowThreads();
21435 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21436
21437 wxPyEndAllowThreads(__tstate);
21438 if (PyErr_Occurred()) SWIG_fail;
21439 }
21440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21448 PyObject *resultobj;
21449 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21450 wxWindow *result;
21451 PyObject * obj0 = 0 ;
21452 char *kwnames[] = {
21453 (char *) "self", NULL
21454 };
21455
21456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21458 if (SWIG_arg_fail(1)) SWIG_fail;
21459 {
21460 PyThreadState* __tstate = wxPyBeginAllowThreads();
21461 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21462
21463 wxPyEndAllowThreads(__tstate);
21464 if (PyErr_Occurred()) SWIG_fail;
21465 }
21466 {
21467 resultobj = wxPyMake_wxObject(result, 0);
21468 }
21469 return resultobj;
21470 fail:
21471 return NULL;
21472 }
21473
21474
21475 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21476 PyObject *obj;
21477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21478 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21479 Py_INCREF(obj);
21480 return Py_BuildValue((char *)"");
21481 }
21482 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21483 PyObject *resultobj;
21484 wxWindow *arg1 = (wxWindow *) NULL ;
21485 wxWindowDestroyEvent *result;
21486 PyObject * obj0 = 0 ;
21487 char *kwnames[] = {
21488 (char *) "win", NULL
21489 };
21490
21491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21492 if (obj0) {
21493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21494 if (SWIG_arg_fail(1)) SWIG_fail;
21495 }
21496 {
21497 PyThreadState* __tstate = wxPyBeginAllowThreads();
21498 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21499
21500 wxPyEndAllowThreads(__tstate);
21501 if (PyErr_Occurred()) SWIG_fail;
21502 }
21503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21504 return resultobj;
21505 fail:
21506 return NULL;
21507 }
21508
21509
21510 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21511 PyObject *resultobj;
21512 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21513 wxWindow *result;
21514 PyObject * obj0 = 0 ;
21515 char *kwnames[] = {
21516 (char *) "self", NULL
21517 };
21518
21519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21521 if (SWIG_arg_fail(1)) SWIG_fail;
21522 {
21523 PyThreadState* __tstate = wxPyBeginAllowThreads();
21524 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21525
21526 wxPyEndAllowThreads(__tstate);
21527 if (PyErr_Occurred()) SWIG_fail;
21528 }
21529 {
21530 resultobj = wxPyMake_wxObject(result, 0);
21531 }
21532 return resultobj;
21533 fail:
21534 return NULL;
21535 }
21536
21537
21538 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21539 PyObject *obj;
21540 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21541 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21542 Py_INCREF(obj);
21543 return Py_BuildValue((char *)"");
21544 }
21545 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21546 PyObject *resultobj;
21547 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21548 int arg2 = (int) 0 ;
21549 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21550 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21551 wxContextMenuEvent *result;
21552 wxPoint temp3 ;
21553 PyObject * obj0 = 0 ;
21554 PyObject * obj1 = 0 ;
21555 PyObject * obj2 = 0 ;
21556 char *kwnames[] = {
21557 (char *) "type",(char *) "winid",(char *) "pt", NULL
21558 };
21559
21560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21561 if (obj0) {
21562 {
21563 arg1 = (wxEventType)(SWIG_As_int(obj0));
21564 if (SWIG_arg_fail(1)) SWIG_fail;
21565 }
21566 }
21567 if (obj1) {
21568 {
21569 arg2 = (int)(SWIG_As_int(obj1));
21570 if (SWIG_arg_fail(2)) SWIG_fail;
21571 }
21572 }
21573 if (obj2) {
21574 {
21575 arg3 = &temp3;
21576 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21577 }
21578 }
21579 {
21580 PyThreadState* __tstate = wxPyBeginAllowThreads();
21581 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21582
21583 wxPyEndAllowThreads(__tstate);
21584 if (PyErr_Occurred()) SWIG_fail;
21585 }
21586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21587 return resultobj;
21588 fail:
21589 return NULL;
21590 }
21591
21592
21593 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21594 PyObject *resultobj;
21595 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21596 wxPoint *result;
21597 PyObject * obj0 = 0 ;
21598 char *kwnames[] = {
21599 (char *) "self", NULL
21600 };
21601
21602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21604 if (SWIG_arg_fail(1)) SWIG_fail;
21605 {
21606 PyThreadState* __tstate = wxPyBeginAllowThreads();
21607 {
21608 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21609 result = (wxPoint *) &_result_ref;
21610 }
21611
21612 wxPyEndAllowThreads(__tstate);
21613 if (PyErr_Occurred()) SWIG_fail;
21614 }
21615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21616 return resultobj;
21617 fail:
21618 return NULL;
21619 }
21620
21621
21622 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21623 PyObject *resultobj;
21624 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21625 wxPoint *arg2 = 0 ;
21626 wxPoint temp2 ;
21627 PyObject * obj0 = 0 ;
21628 PyObject * obj1 = 0 ;
21629 char *kwnames[] = {
21630 (char *) "self",(char *) "pos", NULL
21631 };
21632
21633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21635 if (SWIG_arg_fail(1)) SWIG_fail;
21636 {
21637 arg2 = &temp2;
21638 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21639 }
21640 {
21641 PyThreadState* __tstate = wxPyBeginAllowThreads();
21642 (arg1)->SetPosition((wxPoint const &)*arg2);
21643
21644 wxPyEndAllowThreads(__tstate);
21645 if (PyErr_Occurred()) SWIG_fail;
21646 }
21647 Py_INCREF(Py_None); resultobj = Py_None;
21648 return resultobj;
21649 fail:
21650 return NULL;
21651 }
21652
21653
21654 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21655 PyObject *obj;
21656 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21657 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21658 Py_INCREF(obj);
21659 return Py_BuildValue((char *)"");
21660 }
21661 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21662 PyObject *resultobj;
21663 wxIdleEvent *result;
21664 char *kwnames[] = {
21665 NULL
21666 };
21667
21668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21669 {
21670 PyThreadState* __tstate = wxPyBeginAllowThreads();
21671 result = (wxIdleEvent *)new wxIdleEvent();
21672
21673 wxPyEndAllowThreads(__tstate);
21674 if (PyErr_Occurred()) SWIG_fail;
21675 }
21676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21677 return resultobj;
21678 fail:
21679 return NULL;
21680 }
21681
21682
21683 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21684 PyObject *resultobj;
21685 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21686 bool arg2 = (bool) true ;
21687 PyObject * obj0 = 0 ;
21688 PyObject * obj1 = 0 ;
21689 char *kwnames[] = {
21690 (char *) "self",(char *) "needMore", NULL
21691 };
21692
21693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21695 if (SWIG_arg_fail(1)) SWIG_fail;
21696 if (obj1) {
21697 {
21698 arg2 = (bool)(SWIG_As_bool(obj1));
21699 if (SWIG_arg_fail(2)) SWIG_fail;
21700 }
21701 }
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 (arg1)->RequestMore(arg2);
21705
21706 wxPyEndAllowThreads(__tstate);
21707 if (PyErr_Occurred()) SWIG_fail;
21708 }
21709 Py_INCREF(Py_None); resultobj = Py_None;
21710 return resultobj;
21711 fail:
21712 return NULL;
21713 }
21714
21715
21716 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj;
21718 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21719 bool result;
21720 PyObject * obj0 = 0 ;
21721 char *kwnames[] = {
21722 (char *) "self", NULL
21723 };
21724
21725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21727 if (SWIG_arg_fail(1)) SWIG_fail;
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21731
21732 wxPyEndAllowThreads(__tstate);
21733 if (PyErr_Occurred()) SWIG_fail;
21734 }
21735 {
21736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21737 }
21738 return resultobj;
21739 fail:
21740 return NULL;
21741 }
21742
21743
21744 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21745 PyObject *resultobj;
21746 wxIdleMode arg1 ;
21747 PyObject * obj0 = 0 ;
21748 char *kwnames[] = {
21749 (char *) "mode", NULL
21750 };
21751
21752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21753 {
21754 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21755 if (SWIG_arg_fail(1)) SWIG_fail;
21756 }
21757 {
21758 PyThreadState* __tstate = wxPyBeginAllowThreads();
21759 wxIdleEvent::SetMode((wxIdleMode )arg1);
21760
21761 wxPyEndAllowThreads(__tstate);
21762 if (PyErr_Occurred()) SWIG_fail;
21763 }
21764 Py_INCREF(Py_None); resultobj = Py_None;
21765 return resultobj;
21766 fail:
21767 return NULL;
21768 }
21769
21770
21771 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21772 PyObject *resultobj;
21773 wxIdleMode result;
21774 char *kwnames[] = {
21775 NULL
21776 };
21777
21778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 result = (wxIdleMode)wxIdleEvent::GetMode();
21782
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 resultobj = SWIG_From_int((result));
21787 return resultobj;
21788 fail:
21789 return NULL;
21790 }
21791
21792
21793 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21794 PyObject *resultobj;
21795 wxWindow *arg1 = (wxWindow *) 0 ;
21796 bool result;
21797 PyObject * obj0 = 0 ;
21798 char *kwnames[] = {
21799 (char *) "win", NULL
21800 };
21801
21802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21804 if (SWIG_arg_fail(1)) SWIG_fail;
21805 {
21806 PyThreadState* __tstate = wxPyBeginAllowThreads();
21807 result = (bool)wxIdleEvent::CanSend(arg1);
21808
21809 wxPyEndAllowThreads(__tstate);
21810 if (PyErr_Occurred()) SWIG_fail;
21811 }
21812 {
21813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21814 }
21815 return resultobj;
21816 fail:
21817 return NULL;
21818 }
21819
21820
21821 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21822 PyObject *obj;
21823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21824 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21825 Py_INCREF(obj);
21826 return Py_BuildValue((char *)"");
21827 }
21828 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21829 PyObject *resultobj;
21830 int arg1 = (int) 0 ;
21831 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21832 wxPyEvent *result;
21833 PyObject * obj0 = 0 ;
21834 PyObject * obj1 = 0 ;
21835 char *kwnames[] = {
21836 (char *) "winid",(char *) "commandType", NULL
21837 };
21838
21839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21840 if (obj0) {
21841 {
21842 arg1 = (int)(SWIG_As_int(obj0));
21843 if (SWIG_arg_fail(1)) SWIG_fail;
21844 }
21845 }
21846 if (obj1) {
21847 {
21848 arg2 = (wxEventType)(SWIG_As_int(obj1));
21849 if (SWIG_arg_fail(2)) SWIG_fail;
21850 }
21851 }
21852 {
21853 PyThreadState* __tstate = wxPyBeginAllowThreads();
21854 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21855
21856 wxPyEndAllowThreads(__tstate);
21857 if (PyErr_Occurred()) SWIG_fail;
21858 }
21859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21860 return resultobj;
21861 fail:
21862 return NULL;
21863 }
21864
21865
21866 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21867 PyObject *resultobj;
21868 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21869 PyObject * obj0 = 0 ;
21870 char *kwnames[] = {
21871 (char *) "self", NULL
21872 };
21873
21874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21876 if (SWIG_arg_fail(1)) SWIG_fail;
21877 {
21878 PyThreadState* __tstate = wxPyBeginAllowThreads();
21879 delete arg1;
21880
21881 wxPyEndAllowThreads(__tstate);
21882 if (PyErr_Occurred()) SWIG_fail;
21883 }
21884 Py_INCREF(Py_None); resultobj = Py_None;
21885 return resultobj;
21886 fail:
21887 return NULL;
21888 }
21889
21890
21891 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21892 PyObject *resultobj;
21893 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21894 PyObject *arg2 = (PyObject *) 0 ;
21895 PyObject * obj0 = 0 ;
21896 PyObject * obj1 = 0 ;
21897 char *kwnames[] = {
21898 (char *) "self",(char *) "self", NULL
21899 };
21900
21901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21903 if (SWIG_arg_fail(1)) SWIG_fail;
21904 arg2 = obj1;
21905 {
21906 PyThreadState* __tstate = wxPyBeginAllowThreads();
21907 (arg1)->SetSelf(arg2);
21908
21909 wxPyEndAllowThreads(__tstate);
21910 if (PyErr_Occurred()) SWIG_fail;
21911 }
21912 Py_INCREF(Py_None); resultobj = Py_None;
21913 return resultobj;
21914 fail:
21915 return NULL;
21916 }
21917
21918
21919 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21920 PyObject *resultobj;
21921 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21922 PyObject *result;
21923 PyObject * obj0 = 0 ;
21924 char *kwnames[] = {
21925 (char *) "self", NULL
21926 };
21927
21928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21930 if (SWIG_arg_fail(1)) SWIG_fail;
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 result = (PyObject *)(arg1)->GetSelf();
21934
21935 wxPyEndAllowThreads(__tstate);
21936 if (PyErr_Occurred()) SWIG_fail;
21937 }
21938 resultobj = result;
21939 return resultobj;
21940 fail:
21941 return NULL;
21942 }
21943
21944
21945 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21946 PyObject *obj;
21947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21948 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21949 Py_INCREF(obj);
21950 return Py_BuildValue((char *)"");
21951 }
21952 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21953 PyObject *resultobj;
21954 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21955 int arg2 = (int) 0 ;
21956 wxPyCommandEvent *result;
21957 PyObject * obj0 = 0 ;
21958 PyObject * obj1 = 0 ;
21959 char *kwnames[] = {
21960 (char *) "commandType",(char *) "id", NULL
21961 };
21962
21963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21964 if (obj0) {
21965 {
21966 arg1 = (wxEventType)(SWIG_As_int(obj0));
21967 if (SWIG_arg_fail(1)) SWIG_fail;
21968 }
21969 }
21970 if (obj1) {
21971 {
21972 arg2 = (int)(SWIG_As_int(obj1));
21973 if (SWIG_arg_fail(2)) SWIG_fail;
21974 }
21975 }
21976 {
21977 PyThreadState* __tstate = wxPyBeginAllowThreads();
21978 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21979
21980 wxPyEndAllowThreads(__tstate);
21981 if (PyErr_Occurred()) SWIG_fail;
21982 }
21983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21984 return resultobj;
21985 fail:
21986 return NULL;
21987 }
21988
21989
21990 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21991 PyObject *resultobj;
21992 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21993 PyObject * obj0 = 0 ;
21994 char *kwnames[] = {
21995 (char *) "self", NULL
21996 };
21997
21998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22000 if (SWIG_arg_fail(1)) SWIG_fail;
22001 {
22002 PyThreadState* __tstate = wxPyBeginAllowThreads();
22003 delete arg1;
22004
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 Py_INCREF(Py_None); resultobj = Py_None;
22009 return resultobj;
22010 fail:
22011 return NULL;
22012 }
22013
22014
22015 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22016 PyObject *resultobj;
22017 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22018 PyObject *arg2 = (PyObject *) 0 ;
22019 PyObject * obj0 = 0 ;
22020 PyObject * obj1 = 0 ;
22021 char *kwnames[] = {
22022 (char *) "self",(char *) "self", NULL
22023 };
22024
22025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22027 if (SWIG_arg_fail(1)) SWIG_fail;
22028 arg2 = obj1;
22029 {
22030 PyThreadState* __tstate = wxPyBeginAllowThreads();
22031 (arg1)->SetSelf(arg2);
22032
22033 wxPyEndAllowThreads(__tstate);
22034 if (PyErr_Occurred()) SWIG_fail;
22035 }
22036 Py_INCREF(Py_None); resultobj = Py_None;
22037 return resultobj;
22038 fail:
22039 return NULL;
22040 }
22041
22042
22043 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22044 PyObject *resultobj;
22045 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22046 PyObject *result;
22047 PyObject * obj0 = 0 ;
22048 char *kwnames[] = {
22049 (char *) "self", NULL
22050 };
22051
22052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22054 if (SWIG_arg_fail(1)) SWIG_fail;
22055 {
22056 PyThreadState* __tstate = wxPyBeginAllowThreads();
22057 result = (PyObject *)(arg1)->GetSelf();
22058
22059 wxPyEndAllowThreads(__tstate);
22060 if (PyErr_Occurred()) SWIG_fail;
22061 }
22062 resultobj = result;
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22070 PyObject *obj;
22071 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22072 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22073 Py_INCREF(obj);
22074 return Py_BuildValue((char *)"");
22075 }
22076 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22077 PyObject *resultobj;
22078 wxWindow *arg1 = (wxWindow *) 0 ;
22079 wxDateTime *arg2 = 0 ;
22080 wxEventType arg3 ;
22081 wxDateEvent *result;
22082 PyObject * obj0 = 0 ;
22083 PyObject * obj1 = 0 ;
22084 PyObject * obj2 = 0 ;
22085 char *kwnames[] = {
22086 (char *) "win",(char *) "dt",(char *) "type", NULL
22087 };
22088
22089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22091 if (SWIG_arg_fail(1)) SWIG_fail;
22092 {
22093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22094 if (SWIG_arg_fail(2)) SWIG_fail;
22095 if (arg2 == NULL) {
22096 SWIG_null_ref("wxDateTime");
22097 }
22098 if (SWIG_arg_fail(2)) SWIG_fail;
22099 }
22100 {
22101 arg3 = (wxEventType)(SWIG_As_int(obj2));
22102 if (SWIG_arg_fail(3)) SWIG_fail;
22103 }
22104 {
22105 PyThreadState* __tstate = wxPyBeginAllowThreads();
22106 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22107
22108 wxPyEndAllowThreads(__tstate);
22109 if (PyErr_Occurred()) SWIG_fail;
22110 }
22111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22112 return resultobj;
22113 fail:
22114 return NULL;
22115 }
22116
22117
22118 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22119 PyObject *resultobj;
22120 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22121 wxDateTime *result;
22122 PyObject * obj0 = 0 ;
22123 char *kwnames[] = {
22124 (char *) "self", NULL
22125 };
22126
22127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22129 if (SWIG_arg_fail(1)) SWIG_fail;
22130 {
22131 PyThreadState* __tstate = wxPyBeginAllowThreads();
22132 {
22133 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22134 result = (wxDateTime *) &_result_ref;
22135 }
22136
22137 wxPyEndAllowThreads(__tstate);
22138 if (PyErr_Occurred()) SWIG_fail;
22139 }
22140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22141 return resultobj;
22142 fail:
22143 return NULL;
22144 }
22145
22146
22147 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22148 PyObject *resultobj;
22149 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22150 wxDateTime *arg2 = 0 ;
22151 PyObject * obj0 = 0 ;
22152 PyObject * obj1 = 0 ;
22153 char *kwnames[] = {
22154 (char *) "self",(char *) "date", NULL
22155 };
22156
22157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22159 if (SWIG_arg_fail(1)) SWIG_fail;
22160 {
22161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22162 if (SWIG_arg_fail(2)) SWIG_fail;
22163 if (arg2 == NULL) {
22164 SWIG_null_ref("wxDateTime");
22165 }
22166 if (SWIG_arg_fail(2)) SWIG_fail;
22167 }
22168 {
22169 PyThreadState* __tstate = wxPyBeginAllowThreads();
22170 (arg1)->SetDate((wxDateTime const &)*arg2);
22171
22172 wxPyEndAllowThreads(__tstate);
22173 if (PyErr_Occurred()) SWIG_fail;
22174 }
22175 Py_INCREF(Py_None); resultobj = Py_None;
22176 return resultobj;
22177 fail:
22178 return NULL;
22179 }
22180
22181
22182 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22183 PyObject *obj;
22184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22185 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22186 Py_INCREF(obj);
22187 return Py_BuildValue((char *)"");
22188 }
22189 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22190 PyObject *resultobj;
22191 wxPyApp *result;
22192 char *kwnames[] = {
22193 NULL
22194 };
22195
22196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22197 {
22198 PyThreadState* __tstate = wxPyBeginAllowThreads();
22199 result = (wxPyApp *)new_wxPyApp();
22200
22201 wxPyEndAllowThreads(__tstate);
22202 if (PyErr_Occurred()) SWIG_fail;
22203 }
22204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22205 return resultobj;
22206 fail:
22207 return NULL;
22208 }
22209
22210
22211 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22212 PyObject *resultobj;
22213 wxPyApp *arg1 = (wxPyApp *) 0 ;
22214 PyObject * obj0 = 0 ;
22215 char *kwnames[] = {
22216 (char *) "self", NULL
22217 };
22218
22219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22221 if (SWIG_arg_fail(1)) SWIG_fail;
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 delete arg1;
22225
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 Py_INCREF(Py_None); resultobj = Py_None;
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22237 PyObject *resultobj;
22238 wxPyApp *arg1 = (wxPyApp *) 0 ;
22239 PyObject *arg2 = (PyObject *) 0 ;
22240 PyObject *arg3 = (PyObject *) 0 ;
22241 PyObject * obj0 = 0 ;
22242 PyObject * obj1 = 0 ;
22243 PyObject * obj2 = 0 ;
22244 char *kwnames[] = {
22245 (char *) "self",(char *) "self",(char *) "_class", NULL
22246 };
22247
22248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22250 if (SWIG_arg_fail(1)) SWIG_fail;
22251 arg2 = obj1;
22252 arg3 = obj2;
22253 {
22254 PyThreadState* __tstate = wxPyBeginAllowThreads();
22255 (arg1)->_setCallbackInfo(arg2,arg3);
22256
22257 wxPyEndAllowThreads(__tstate);
22258 if (PyErr_Occurred()) SWIG_fail;
22259 }
22260 Py_INCREF(Py_None); resultobj = Py_None;
22261 return resultobj;
22262 fail:
22263 return NULL;
22264 }
22265
22266
22267 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22268 PyObject *resultobj;
22269 wxPyApp *arg1 = (wxPyApp *) 0 ;
22270 wxString result;
22271 PyObject * obj0 = 0 ;
22272 char *kwnames[] = {
22273 (char *) "self", NULL
22274 };
22275
22276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22278 if (SWIG_arg_fail(1)) SWIG_fail;
22279 {
22280 PyThreadState* __tstate = wxPyBeginAllowThreads();
22281 result = ((wxPyApp const *)arg1)->GetAppName();
22282
22283 wxPyEndAllowThreads(__tstate);
22284 if (PyErr_Occurred()) SWIG_fail;
22285 }
22286 {
22287 #if wxUSE_UNICODE
22288 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22289 #else
22290 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22291 #endif
22292 }
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22300 PyObject *resultobj;
22301 wxPyApp *arg1 = (wxPyApp *) 0 ;
22302 wxString *arg2 = 0 ;
22303 bool temp2 = false ;
22304 PyObject * obj0 = 0 ;
22305 PyObject * obj1 = 0 ;
22306 char *kwnames[] = {
22307 (char *) "self",(char *) "name", NULL
22308 };
22309
22310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22312 if (SWIG_arg_fail(1)) SWIG_fail;
22313 {
22314 arg2 = wxString_in_helper(obj1);
22315 if (arg2 == NULL) SWIG_fail;
22316 temp2 = true;
22317 }
22318 {
22319 PyThreadState* __tstate = wxPyBeginAllowThreads();
22320 (arg1)->SetAppName((wxString const &)*arg2);
22321
22322 wxPyEndAllowThreads(__tstate);
22323 if (PyErr_Occurred()) SWIG_fail;
22324 }
22325 Py_INCREF(Py_None); resultobj = Py_None;
22326 {
22327 if (temp2)
22328 delete arg2;
22329 }
22330 return resultobj;
22331 fail:
22332 {
22333 if (temp2)
22334 delete arg2;
22335 }
22336 return NULL;
22337 }
22338
22339
22340 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22341 PyObject *resultobj;
22342 wxPyApp *arg1 = (wxPyApp *) 0 ;
22343 wxString result;
22344 PyObject * obj0 = 0 ;
22345 char *kwnames[] = {
22346 (char *) "self", NULL
22347 };
22348
22349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22351 if (SWIG_arg_fail(1)) SWIG_fail;
22352 {
22353 PyThreadState* __tstate = wxPyBeginAllowThreads();
22354 result = ((wxPyApp const *)arg1)->GetClassName();
22355
22356 wxPyEndAllowThreads(__tstate);
22357 if (PyErr_Occurred()) SWIG_fail;
22358 }
22359 {
22360 #if wxUSE_UNICODE
22361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22362 #else
22363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22364 #endif
22365 }
22366 return resultobj;
22367 fail:
22368 return NULL;
22369 }
22370
22371
22372 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22373 PyObject *resultobj;
22374 wxPyApp *arg1 = (wxPyApp *) 0 ;
22375 wxString *arg2 = 0 ;
22376 bool temp2 = false ;
22377 PyObject * obj0 = 0 ;
22378 PyObject * obj1 = 0 ;
22379 char *kwnames[] = {
22380 (char *) "self",(char *) "name", NULL
22381 };
22382
22383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22385 if (SWIG_arg_fail(1)) SWIG_fail;
22386 {
22387 arg2 = wxString_in_helper(obj1);
22388 if (arg2 == NULL) SWIG_fail;
22389 temp2 = true;
22390 }
22391 {
22392 PyThreadState* __tstate = wxPyBeginAllowThreads();
22393 (arg1)->SetClassName((wxString const &)*arg2);
22394
22395 wxPyEndAllowThreads(__tstate);
22396 if (PyErr_Occurred()) SWIG_fail;
22397 }
22398 Py_INCREF(Py_None); resultobj = Py_None;
22399 {
22400 if (temp2)
22401 delete arg2;
22402 }
22403 return resultobj;
22404 fail:
22405 {
22406 if (temp2)
22407 delete arg2;
22408 }
22409 return NULL;
22410 }
22411
22412
22413 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22414 PyObject *resultobj;
22415 wxPyApp *arg1 = (wxPyApp *) 0 ;
22416 wxString *result;
22417 PyObject * obj0 = 0 ;
22418 char *kwnames[] = {
22419 (char *) "self", NULL
22420 };
22421
22422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22424 if (SWIG_arg_fail(1)) SWIG_fail;
22425 {
22426 PyThreadState* __tstate = wxPyBeginAllowThreads();
22427 {
22428 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22429 result = (wxString *) &_result_ref;
22430 }
22431
22432 wxPyEndAllowThreads(__tstate);
22433 if (PyErr_Occurred()) SWIG_fail;
22434 }
22435 {
22436 #if wxUSE_UNICODE
22437 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22438 #else
22439 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22440 #endif
22441 }
22442 return resultobj;
22443 fail:
22444 return NULL;
22445 }
22446
22447
22448 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22449 PyObject *resultobj;
22450 wxPyApp *arg1 = (wxPyApp *) 0 ;
22451 wxString *arg2 = 0 ;
22452 bool temp2 = false ;
22453 PyObject * obj0 = 0 ;
22454 PyObject * obj1 = 0 ;
22455 char *kwnames[] = {
22456 (char *) "self",(char *) "name", NULL
22457 };
22458
22459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22461 if (SWIG_arg_fail(1)) SWIG_fail;
22462 {
22463 arg2 = wxString_in_helper(obj1);
22464 if (arg2 == NULL) SWIG_fail;
22465 temp2 = true;
22466 }
22467 {
22468 PyThreadState* __tstate = wxPyBeginAllowThreads();
22469 (arg1)->SetVendorName((wxString const &)*arg2);
22470
22471 wxPyEndAllowThreads(__tstate);
22472 if (PyErr_Occurred()) SWIG_fail;
22473 }
22474 Py_INCREF(Py_None); resultobj = Py_None;
22475 {
22476 if (temp2)
22477 delete arg2;
22478 }
22479 return resultobj;
22480 fail:
22481 {
22482 if (temp2)
22483 delete arg2;
22484 }
22485 return NULL;
22486 }
22487
22488
22489 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22490 PyObject *resultobj;
22491 wxPyApp *arg1 = (wxPyApp *) 0 ;
22492 wxAppTraits *result;
22493 PyObject * obj0 = 0 ;
22494 char *kwnames[] = {
22495 (char *) "self", NULL
22496 };
22497
22498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22500 if (SWIG_arg_fail(1)) SWIG_fail;
22501 {
22502 PyThreadState* __tstate = wxPyBeginAllowThreads();
22503 result = (wxAppTraits *)(arg1)->GetTraits();
22504
22505 wxPyEndAllowThreads(__tstate);
22506 if (PyErr_Occurred()) SWIG_fail;
22507 }
22508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22509 return resultobj;
22510 fail:
22511 return NULL;
22512 }
22513
22514
22515 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22516 PyObject *resultobj;
22517 wxPyApp *arg1 = (wxPyApp *) 0 ;
22518 PyObject * obj0 = 0 ;
22519 char *kwnames[] = {
22520 (char *) "self", NULL
22521 };
22522
22523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22525 if (SWIG_arg_fail(1)) SWIG_fail;
22526 {
22527 PyThreadState* __tstate = wxPyBeginAllowThreads();
22528 (arg1)->ProcessPendingEvents();
22529
22530 wxPyEndAllowThreads(__tstate);
22531 if (PyErr_Occurred()) SWIG_fail;
22532 }
22533 Py_INCREF(Py_None); resultobj = Py_None;
22534 return resultobj;
22535 fail:
22536 return NULL;
22537 }
22538
22539
22540 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22541 PyObject *resultobj;
22542 wxPyApp *arg1 = (wxPyApp *) 0 ;
22543 bool arg2 = (bool) false ;
22544 bool result;
22545 PyObject * obj0 = 0 ;
22546 PyObject * obj1 = 0 ;
22547 char *kwnames[] = {
22548 (char *) "self",(char *) "onlyIfNeeded", NULL
22549 };
22550
22551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22553 if (SWIG_arg_fail(1)) SWIG_fail;
22554 if (obj1) {
22555 {
22556 arg2 = (bool)(SWIG_As_bool(obj1));
22557 if (SWIG_arg_fail(2)) SWIG_fail;
22558 }
22559 }
22560 {
22561 PyThreadState* __tstate = wxPyBeginAllowThreads();
22562 result = (bool)(arg1)->Yield(arg2);
22563
22564 wxPyEndAllowThreads(__tstate);
22565 if (PyErr_Occurred()) SWIG_fail;
22566 }
22567 {
22568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22569 }
22570 return resultobj;
22571 fail:
22572 return NULL;
22573 }
22574
22575
22576 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22577 PyObject *resultobj;
22578 wxPyApp *arg1 = (wxPyApp *) 0 ;
22579 PyObject * obj0 = 0 ;
22580 char *kwnames[] = {
22581 (char *) "self", NULL
22582 };
22583
22584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22586 if (SWIG_arg_fail(1)) SWIG_fail;
22587 {
22588 PyThreadState* __tstate = wxPyBeginAllowThreads();
22589 (arg1)->WakeUpIdle();
22590
22591 wxPyEndAllowThreads(__tstate);
22592 if (PyErr_Occurred()) SWIG_fail;
22593 }
22594 Py_INCREF(Py_None); resultobj = Py_None;
22595 return resultobj;
22596 fail:
22597 return NULL;
22598 }
22599
22600
22601 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22602 PyObject *resultobj;
22603 bool result;
22604 char *kwnames[] = {
22605 NULL
22606 };
22607
22608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22609 {
22610 PyThreadState* __tstate = wxPyBeginAllowThreads();
22611 result = (bool)wxPyApp::IsMainLoopRunning();
22612
22613 wxPyEndAllowThreads(__tstate);
22614 if (PyErr_Occurred()) SWIG_fail;
22615 }
22616 {
22617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22618 }
22619 return resultobj;
22620 fail:
22621 return NULL;
22622 }
22623
22624
22625 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22626 PyObject *resultobj;
22627 wxPyApp *arg1 = (wxPyApp *) 0 ;
22628 int result;
22629 PyObject * obj0 = 0 ;
22630 char *kwnames[] = {
22631 (char *) "self", NULL
22632 };
22633
22634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22636 if (SWIG_arg_fail(1)) SWIG_fail;
22637 {
22638 PyThreadState* __tstate = wxPyBeginAllowThreads();
22639 result = (int)(arg1)->MainLoop();
22640
22641 wxPyEndAllowThreads(__tstate);
22642 if (PyErr_Occurred()) SWIG_fail;
22643 }
22644 {
22645 resultobj = SWIG_From_int((int)(result));
22646 }
22647 return resultobj;
22648 fail:
22649 return NULL;
22650 }
22651
22652
22653 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22654 PyObject *resultobj;
22655 wxPyApp *arg1 = (wxPyApp *) 0 ;
22656 PyObject * obj0 = 0 ;
22657 char *kwnames[] = {
22658 (char *) "self", NULL
22659 };
22660
22661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22663 if (SWIG_arg_fail(1)) SWIG_fail;
22664 {
22665 PyThreadState* __tstate = wxPyBeginAllowThreads();
22666 (arg1)->Exit();
22667
22668 wxPyEndAllowThreads(__tstate);
22669 if (PyErr_Occurred()) SWIG_fail;
22670 }
22671 Py_INCREF(Py_None); resultobj = Py_None;
22672 return resultobj;
22673 fail:
22674 return NULL;
22675 }
22676
22677
22678 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22679 PyObject *resultobj;
22680 wxPyApp *arg1 = (wxPyApp *) 0 ;
22681 PyObject * obj0 = 0 ;
22682 char *kwnames[] = {
22683 (char *) "self", NULL
22684 };
22685
22686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22688 if (SWIG_arg_fail(1)) SWIG_fail;
22689 {
22690 PyThreadState* __tstate = wxPyBeginAllowThreads();
22691 (arg1)->ExitMainLoop();
22692
22693 wxPyEndAllowThreads(__tstate);
22694 if (PyErr_Occurred()) SWIG_fail;
22695 }
22696 Py_INCREF(Py_None); resultobj = Py_None;
22697 return resultobj;
22698 fail:
22699 return NULL;
22700 }
22701
22702
22703 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22704 PyObject *resultobj;
22705 wxPyApp *arg1 = (wxPyApp *) 0 ;
22706 bool result;
22707 PyObject * obj0 = 0 ;
22708 char *kwnames[] = {
22709 (char *) "self", NULL
22710 };
22711
22712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22714 if (SWIG_arg_fail(1)) SWIG_fail;
22715 {
22716 PyThreadState* __tstate = wxPyBeginAllowThreads();
22717 result = (bool)(arg1)->Pending();
22718
22719 wxPyEndAllowThreads(__tstate);
22720 if (PyErr_Occurred()) SWIG_fail;
22721 }
22722 {
22723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22724 }
22725 return resultobj;
22726 fail:
22727 return NULL;
22728 }
22729
22730
22731 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22732 PyObject *resultobj;
22733 wxPyApp *arg1 = (wxPyApp *) 0 ;
22734 bool result;
22735 PyObject * obj0 = 0 ;
22736 char *kwnames[] = {
22737 (char *) "self", NULL
22738 };
22739
22740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22742 if (SWIG_arg_fail(1)) SWIG_fail;
22743 {
22744 PyThreadState* __tstate = wxPyBeginAllowThreads();
22745 result = (bool)(arg1)->Dispatch();
22746
22747 wxPyEndAllowThreads(__tstate);
22748 if (PyErr_Occurred()) SWIG_fail;
22749 }
22750 {
22751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22752 }
22753 return resultobj;
22754 fail:
22755 return NULL;
22756 }
22757
22758
22759 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22760 PyObject *resultobj;
22761 wxPyApp *arg1 = (wxPyApp *) 0 ;
22762 bool result;
22763 PyObject * obj0 = 0 ;
22764 char *kwnames[] = {
22765 (char *) "self", NULL
22766 };
22767
22768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22770 if (SWIG_arg_fail(1)) SWIG_fail;
22771 {
22772 PyThreadState* __tstate = wxPyBeginAllowThreads();
22773 result = (bool)(arg1)->ProcessIdle();
22774
22775 wxPyEndAllowThreads(__tstate);
22776 if (PyErr_Occurred()) SWIG_fail;
22777 }
22778 {
22779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22780 }
22781 return resultobj;
22782 fail:
22783 return NULL;
22784 }
22785
22786
22787 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22788 PyObject *resultobj;
22789 wxPyApp *arg1 = (wxPyApp *) 0 ;
22790 wxWindow *arg2 = (wxWindow *) 0 ;
22791 wxIdleEvent *arg3 = 0 ;
22792 bool result;
22793 PyObject * obj0 = 0 ;
22794 PyObject * obj1 = 0 ;
22795 PyObject * obj2 = 0 ;
22796 char *kwnames[] = {
22797 (char *) "self",(char *) "win",(char *) "event", NULL
22798 };
22799
22800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22802 if (SWIG_arg_fail(1)) SWIG_fail;
22803 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22804 if (SWIG_arg_fail(2)) SWIG_fail;
22805 {
22806 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22807 if (SWIG_arg_fail(3)) SWIG_fail;
22808 if (arg3 == NULL) {
22809 SWIG_null_ref("wxIdleEvent");
22810 }
22811 if (SWIG_arg_fail(3)) SWIG_fail;
22812 }
22813 {
22814 PyThreadState* __tstate = wxPyBeginAllowThreads();
22815 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22816
22817 wxPyEndAllowThreads(__tstate);
22818 if (PyErr_Occurred()) SWIG_fail;
22819 }
22820 {
22821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22822 }
22823 return resultobj;
22824 fail:
22825 return NULL;
22826 }
22827
22828
22829 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22830 PyObject *resultobj;
22831 wxPyApp *arg1 = (wxPyApp *) 0 ;
22832 bool result;
22833 PyObject * obj0 = 0 ;
22834 char *kwnames[] = {
22835 (char *) "self", NULL
22836 };
22837
22838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22840 if (SWIG_arg_fail(1)) SWIG_fail;
22841 {
22842 PyThreadState* __tstate = wxPyBeginAllowThreads();
22843 result = (bool)((wxPyApp const *)arg1)->IsActive();
22844
22845 wxPyEndAllowThreads(__tstate);
22846 if (PyErr_Occurred()) SWIG_fail;
22847 }
22848 {
22849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22850 }
22851 return resultobj;
22852 fail:
22853 return NULL;
22854 }
22855
22856
22857 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22858 PyObject *resultobj;
22859 wxPyApp *arg1 = (wxPyApp *) 0 ;
22860 wxWindow *arg2 = (wxWindow *) 0 ;
22861 PyObject * obj0 = 0 ;
22862 PyObject * obj1 = 0 ;
22863 char *kwnames[] = {
22864 (char *) "self",(char *) "win", NULL
22865 };
22866
22867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22869 if (SWIG_arg_fail(1)) SWIG_fail;
22870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22871 if (SWIG_arg_fail(2)) SWIG_fail;
22872 {
22873 PyThreadState* __tstate = wxPyBeginAllowThreads();
22874 (arg1)->SetTopWindow(arg2);
22875
22876 wxPyEndAllowThreads(__tstate);
22877 if (PyErr_Occurred()) SWIG_fail;
22878 }
22879 Py_INCREF(Py_None); resultobj = Py_None;
22880 return resultobj;
22881 fail:
22882 return NULL;
22883 }
22884
22885
22886 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22887 PyObject *resultobj;
22888 wxPyApp *arg1 = (wxPyApp *) 0 ;
22889 wxWindow *result;
22890 PyObject * obj0 = 0 ;
22891 char *kwnames[] = {
22892 (char *) "self", NULL
22893 };
22894
22895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22897 if (SWIG_arg_fail(1)) SWIG_fail;
22898 {
22899 PyThreadState* __tstate = wxPyBeginAllowThreads();
22900 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22901
22902 wxPyEndAllowThreads(__tstate);
22903 if (PyErr_Occurred()) SWIG_fail;
22904 }
22905 {
22906 resultobj = wxPyMake_wxObject(result, 0);
22907 }
22908 return resultobj;
22909 fail:
22910 return NULL;
22911 }
22912
22913
22914 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22915 PyObject *resultobj;
22916 wxPyApp *arg1 = (wxPyApp *) 0 ;
22917 bool arg2 ;
22918 PyObject * obj0 = 0 ;
22919 PyObject * obj1 = 0 ;
22920 char *kwnames[] = {
22921 (char *) "self",(char *) "flag", NULL
22922 };
22923
22924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22926 if (SWIG_arg_fail(1)) SWIG_fail;
22927 {
22928 arg2 = (bool)(SWIG_As_bool(obj1));
22929 if (SWIG_arg_fail(2)) SWIG_fail;
22930 }
22931 {
22932 PyThreadState* __tstate = wxPyBeginAllowThreads();
22933 (arg1)->SetExitOnFrameDelete(arg2);
22934
22935 wxPyEndAllowThreads(__tstate);
22936 if (PyErr_Occurred()) SWIG_fail;
22937 }
22938 Py_INCREF(Py_None); resultobj = Py_None;
22939 return resultobj;
22940 fail:
22941 return NULL;
22942 }
22943
22944
22945 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22946 PyObject *resultobj;
22947 wxPyApp *arg1 = (wxPyApp *) 0 ;
22948 bool result;
22949 PyObject * obj0 = 0 ;
22950 char *kwnames[] = {
22951 (char *) "self", NULL
22952 };
22953
22954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22956 if (SWIG_arg_fail(1)) SWIG_fail;
22957 {
22958 PyThreadState* __tstate = wxPyBeginAllowThreads();
22959 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22960
22961 wxPyEndAllowThreads(__tstate);
22962 if (PyErr_Occurred()) SWIG_fail;
22963 }
22964 {
22965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22966 }
22967 return resultobj;
22968 fail:
22969 return NULL;
22970 }
22971
22972
22973 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22974 PyObject *resultobj;
22975 wxPyApp *arg1 = (wxPyApp *) 0 ;
22976 bool arg2 ;
22977 PyObject * obj0 = 0 ;
22978 PyObject * obj1 = 0 ;
22979 char *kwnames[] = {
22980 (char *) "self",(char *) "flag", NULL
22981 };
22982
22983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22985 if (SWIG_arg_fail(1)) SWIG_fail;
22986 {
22987 arg2 = (bool)(SWIG_As_bool(obj1));
22988 if (SWIG_arg_fail(2)) SWIG_fail;
22989 }
22990 {
22991 PyThreadState* __tstate = wxPyBeginAllowThreads();
22992 (arg1)->SetUseBestVisual(arg2);
22993
22994 wxPyEndAllowThreads(__tstate);
22995 if (PyErr_Occurred()) SWIG_fail;
22996 }
22997 Py_INCREF(Py_None); resultobj = Py_None;
22998 return resultobj;
22999 fail:
23000 return NULL;
23001 }
23002
23003
23004 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23005 PyObject *resultobj;
23006 wxPyApp *arg1 = (wxPyApp *) 0 ;
23007 bool result;
23008 PyObject * obj0 = 0 ;
23009 char *kwnames[] = {
23010 (char *) "self", NULL
23011 };
23012
23013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23015 if (SWIG_arg_fail(1)) SWIG_fail;
23016 {
23017 PyThreadState* __tstate = wxPyBeginAllowThreads();
23018 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23019
23020 wxPyEndAllowThreads(__tstate);
23021 if (PyErr_Occurred()) SWIG_fail;
23022 }
23023 {
23024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23025 }
23026 return resultobj;
23027 fail:
23028 return NULL;
23029 }
23030
23031
23032 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23033 PyObject *resultobj;
23034 wxPyApp *arg1 = (wxPyApp *) 0 ;
23035 int arg2 ;
23036 PyObject * obj0 = 0 ;
23037 PyObject * obj1 = 0 ;
23038 char *kwnames[] = {
23039 (char *) "self",(char *) "mode", NULL
23040 };
23041
23042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23044 if (SWIG_arg_fail(1)) SWIG_fail;
23045 {
23046 arg2 = (int)(SWIG_As_int(obj1));
23047 if (SWIG_arg_fail(2)) SWIG_fail;
23048 }
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 (arg1)->SetPrintMode(arg2);
23052
23053 wxPyEndAllowThreads(__tstate);
23054 if (PyErr_Occurred()) SWIG_fail;
23055 }
23056 Py_INCREF(Py_None); resultobj = Py_None;
23057 return resultobj;
23058 fail:
23059 return NULL;
23060 }
23061
23062
23063 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23064 PyObject *resultobj;
23065 wxPyApp *arg1 = (wxPyApp *) 0 ;
23066 int result;
23067 PyObject * obj0 = 0 ;
23068 char *kwnames[] = {
23069 (char *) "self", NULL
23070 };
23071
23072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23074 if (SWIG_arg_fail(1)) SWIG_fail;
23075 {
23076 PyThreadState* __tstate = wxPyBeginAllowThreads();
23077 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23078
23079 wxPyEndAllowThreads(__tstate);
23080 if (PyErr_Occurred()) SWIG_fail;
23081 }
23082 {
23083 resultobj = SWIG_From_int((int)(result));
23084 }
23085 return resultobj;
23086 fail:
23087 return NULL;
23088 }
23089
23090
23091 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23092 PyObject *resultobj;
23093 wxPyApp *arg1 = (wxPyApp *) 0 ;
23094 int arg2 ;
23095 PyObject * obj0 = 0 ;
23096 PyObject * obj1 = 0 ;
23097 char *kwnames[] = {
23098 (char *) "self",(char *) "mode", NULL
23099 };
23100
23101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23103 if (SWIG_arg_fail(1)) SWIG_fail;
23104 {
23105 arg2 = (int)(SWIG_As_int(obj1));
23106 if (SWIG_arg_fail(2)) SWIG_fail;
23107 }
23108 {
23109 PyThreadState* __tstate = wxPyBeginAllowThreads();
23110 (arg1)->SetAssertMode(arg2);
23111
23112 wxPyEndAllowThreads(__tstate);
23113 if (PyErr_Occurred()) SWIG_fail;
23114 }
23115 Py_INCREF(Py_None); resultobj = Py_None;
23116 return resultobj;
23117 fail:
23118 return NULL;
23119 }
23120
23121
23122 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23123 PyObject *resultobj;
23124 wxPyApp *arg1 = (wxPyApp *) 0 ;
23125 int result;
23126 PyObject * obj0 = 0 ;
23127 char *kwnames[] = {
23128 (char *) "self", NULL
23129 };
23130
23131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23133 if (SWIG_arg_fail(1)) SWIG_fail;
23134 {
23135 PyThreadState* __tstate = wxPyBeginAllowThreads();
23136 result = (int)(arg1)->GetAssertMode();
23137
23138 wxPyEndAllowThreads(__tstate);
23139 if (PyErr_Occurred()) SWIG_fail;
23140 }
23141 {
23142 resultobj = SWIG_From_int((int)(result));
23143 }
23144 return resultobj;
23145 fail:
23146 return NULL;
23147 }
23148
23149
23150 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23151 PyObject *resultobj;
23152 bool result;
23153 char *kwnames[] = {
23154 NULL
23155 };
23156
23157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23158 {
23159 PyThreadState* __tstate = wxPyBeginAllowThreads();
23160 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23161
23162 wxPyEndAllowThreads(__tstate);
23163 if (PyErr_Occurred()) SWIG_fail;
23164 }
23165 {
23166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23167 }
23168 return resultobj;
23169 fail:
23170 return NULL;
23171 }
23172
23173
23174 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23175 PyObject *resultobj;
23176 long result;
23177 char *kwnames[] = {
23178 NULL
23179 };
23180
23181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23182 {
23183 PyThreadState* __tstate = wxPyBeginAllowThreads();
23184 result = (long)wxPyApp::GetMacAboutMenuItemId();
23185
23186 wxPyEndAllowThreads(__tstate);
23187 if (PyErr_Occurred()) SWIG_fail;
23188 }
23189 {
23190 resultobj = SWIG_From_long((long)(result));
23191 }
23192 return resultobj;
23193 fail:
23194 return NULL;
23195 }
23196
23197
23198 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23199 PyObject *resultobj;
23200 long result;
23201 char *kwnames[] = {
23202 NULL
23203 };
23204
23205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23206 {
23207 PyThreadState* __tstate = wxPyBeginAllowThreads();
23208 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23209
23210 wxPyEndAllowThreads(__tstate);
23211 if (PyErr_Occurred()) SWIG_fail;
23212 }
23213 {
23214 resultobj = SWIG_From_long((long)(result));
23215 }
23216 return resultobj;
23217 fail:
23218 return NULL;
23219 }
23220
23221
23222 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23223 PyObject *resultobj;
23224 long result;
23225 char *kwnames[] = {
23226 NULL
23227 };
23228
23229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23230 {
23231 PyThreadState* __tstate = wxPyBeginAllowThreads();
23232 result = (long)wxPyApp::GetMacExitMenuItemId();
23233
23234 wxPyEndAllowThreads(__tstate);
23235 if (PyErr_Occurred()) SWIG_fail;
23236 }
23237 {
23238 resultobj = SWIG_From_long((long)(result));
23239 }
23240 return resultobj;
23241 fail:
23242 return NULL;
23243 }
23244
23245
23246 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23247 PyObject *resultobj;
23248 wxString result;
23249 char *kwnames[] = {
23250 NULL
23251 };
23252
23253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23254 {
23255 PyThreadState* __tstate = wxPyBeginAllowThreads();
23256 result = wxPyApp::GetMacHelpMenuTitleName();
23257
23258 wxPyEndAllowThreads(__tstate);
23259 if (PyErr_Occurred()) SWIG_fail;
23260 }
23261 {
23262 #if wxUSE_UNICODE
23263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23264 #else
23265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23266 #endif
23267 }
23268 return resultobj;
23269 fail:
23270 return NULL;
23271 }
23272
23273
23274 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23275 PyObject *resultobj;
23276 bool arg1 ;
23277 PyObject * obj0 = 0 ;
23278 char *kwnames[] = {
23279 (char *) "val", NULL
23280 };
23281
23282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23283 {
23284 arg1 = (bool)(SWIG_As_bool(obj0));
23285 if (SWIG_arg_fail(1)) SWIG_fail;
23286 }
23287 {
23288 PyThreadState* __tstate = wxPyBeginAllowThreads();
23289 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23290
23291 wxPyEndAllowThreads(__tstate);
23292 if (PyErr_Occurred()) SWIG_fail;
23293 }
23294 Py_INCREF(Py_None); resultobj = Py_None;
23295 return resultobj;
23296 fail:
23297 return NULL;
23298 }
23299
23300
23301 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23302 PyObject *resultobj;
23303 long arg1 ;
23304 PyObject * obj0 = 0 ;
23305 char *kwnames[] = {
23306 (char *) "val", NULL
23307 };
23308
23309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23310 {
23311 arg1 = (long)(SWIG_As_long(obj0));
23312 if (SWIG_arg_fail(1)) SWIG_fail;
23313 }
23314 {
23315 PyThreadState* __tstate = wxPyBeginAllowThreads();
23316 wxPyApp::SetMacAboutMenuItemId(arg1);
23317
23318 wxPyEndAllowThreads(__tstate);
23319 if (PyErr_Occurred()) SWIG_fail;
23320 }
23321 Py_INCREF(Py_None); resultobj = Py_None;
23322 return resultobj;
23323 fail:
23324 return NULL;
23325 }
23326
23327
23328 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23329 PyObject *resultobj;
23330 long arg1 ;
23331 PyObject * obj0 = 0 ;
23332 char *kwnames[] = {
23333 (char *) "val", NULL
23334 };
23335
23336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23337 {
23338 arg1 = (long)(SWIG_As_long(obj0));
23339 if (SWIG_arg_fail(1)) SWIG_fail;
23340 }
23341 {
23342 PyThreadState* __tstate = wxPyBeginAllowThreads();
23343 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23344
23345 wxPyEndAllowThreads(__tstate);
23346 if (PyErr_Occurred()) SWIG_fail;
23347 }
23348 Py_INCREF(Py_None); resultobj = Py_None;
23349 return resultobj;
23350 fail:
23351 return NULL;
23352 }
23353
23354
23355 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23356 PyObject *resultobj;
23357 long arg1 ;
23358 PyObject * obj0 = 0 ;
23359 char *kwnames[] = {
23360 (char *) "val", NULL
23361 };
23362
23363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23364 {
23365 arg1 = (long)(SWIG_As_long(obj0));
23366 if (SWIG_arg_fail(1)) SWIG_fail;
23367 }
23368 {
23369 PyThreadState* __tstate = wxPyBeginAllowThreads();
23370 wxPyApp::SetMacExitMenuItemId(arg1);
23371
23372 wxPyEndAllowThreads(__tstate);
23373 if (PyErr_Occurred()) SWIG_fail;
23374 }
23375 Py_INCREF(Py_None); resultobj = Py_None;
23376 return resultobj;
23377 fail:
23378 return NULL;
23379 }
23380
23381
23382 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23383 PyObject *resultobj;
23384 wxString *arg1 = 0 ;
23385 bool temp1 = false ;
23386 PyObject * obj0 = 0 ;
23387 char *kwnames[] = {
23388 (char *) "val", NULL
23389 };
23390
23391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23392 {
23393 arg1 = wxString_in_helper(obj0);
23394 if (arg1 == NULL) SWIG_fail;
23395 temp1 = true;
23396 }
23397 {
23398 PyThreadState* __tstate = wxPyBeginAllowThreads();
23399 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23400
23401 wxPyEndAllowThreads(__tstate);
23402 if (PyErr_Occurred()) SWIG_fail;
23403 }
23404 Py_INCREF(Py_None); resultobj = Py_None;
23405 {
23406 if (temp1)
23407 delete arg1;
23408 }
23409 return resultobj;
23410 fail:
23411 {
23412 if (temp1)
23413 delete arg1;
23414 }
23415 return NULL;
23416 }
23417
23418
23419 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23420 PyObject *resultobj;
23421 wxPyApp *arg1 = (wxPyApp *) 0 ;
23422 PyObject * obj0 = 0 ;
23423 char *kwnames[] = {
23424 (char *) "self", NULL
23425 };
23426
23427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23429 if (SWIG_arg_fail(1)) SWIG_fail;
23430 {
23431 PyThreadState* __tstate = wxPyBeginAllowThreads();
23432 (arg1)->_BootstrapApp();
23433
23434 wxPyEndAllowThreads(__tstate);
23435 if (PyErr_Occurred()) SWIG_fail;
23436 }
23437 Py_INCREF(Py_None); resultobj = Py_None;
23438 return resultobj;
23439 fail:
23440 return NULL;
23441 }
23442
23443
23444 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23445 PyObject *resultobj;
23446 int result;
23447 char *kwnames[] = {
23448 NULL
23449 };
23450
23451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23452 {
23453 PyThreadState* __tstate = wxPyBeginAllowThreads();
23454 result = (int)PyApp_GetComCtl32Version();
23455
23456 wxPyEndAllowThreads(__tstate);
23457 if (PyErr_Occurred()) SWIG_fail;
23458 }
23459 {
23460 resultobj = SWIG_From_int((int)(result));
23461 }
23462 return resultobj;
23463 fail:
23464 return NULL;
23465 }
23466
23467
23468 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23469 PyObject *obj;
23470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23471 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23472 Py_INCREF(obj);
23473 return Py_BuildValue((char *)"");
23474 }
23475 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23476 PyObject *resultobj;
23477 char *kwnames[] = {
23478 NULL
23479 };
23480
23481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 wxExit();
23485
23486 wxPyEndAllowThreads(__tstate);
23487 if (PyErr_Occurred()) SWIG_fail;
23488 }
23489 Py_INCREF(Py_None); resultobj = Py_None;
23490 return resultobj;
23491 fail:
23492 return NULL;
23493 }
23494
23495
23496 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23497 PyObject *resultobj;
23498 bool result;
23499 char *kwnames[] = {
23500 NULL
23501 };
23502
23503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23504 {
23505 PyThreadState* __tstate = wxPyBeginAllowThreads();
23506 result = (bool)wxYield();
23507
23508 wxPyEndAllowThreads(__tstate);
23509 if (PyErr_Occurred()) SWIG_fail;
23510 }
23511 {
23512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23513 }
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23521 PyObject *resultobj;
23522 bool result;
23523 char *kwnames[] = {
23524 NULL
23525 };
23526
23527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23528 {
23529 PyThreadState* __tstate = wxPyBeginAllowThreads();
23530 result = (bool)wxYieldIfNeeded();
23531
23532 wxPyEndAllowThreads(__tstate);
23533 if (PyErr_Occurred()) SWIG_fail;
23534 }
23535 {
23536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23537 }
23538 return resultobj;
23539 fail:
23540 return NULL;
23541 }
23542
23543
23544 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23545 PyObject *resultobj;
23546 wxWindow *arg1 = (wxWindow *) NULL ;
23547 bool arg2 = (bool) false ;
23548 bool result;
23549 PyObject * obj0 = 0 ;
23550 PyObject * obj1 = 0 ;
23551 char *kwnames[] = {
23552 (char *) "win",(char *) "onlyIfNeeded", NULL
23553 };
23554
23555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23556 if (obj0) {
23557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23558 if (SWIG_arg_fail(1)) SWIG_fail;
23559 }
23560 if (obj1) {
23561 {
23562 arg2 = (bool)(SWIG_As_bool(obj1));
23563 if (SWIG_arg_fail(2)) SWIG_fail;
23564 }
23565 }
23566 {
23567 PyThreadState* __tstate = wxPyBeginAllowThreads();
23568 result = (bool)wxSafeYield(arg1,arg2);
23569
23570 wxPyEndAllowThreads(__tstate);
23571 if (PyErr_Occurred()) SWIG_fail;
23572 }
23573 {
23574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23575 }
23576 return resultobj;
23577 fail:
23578 return NULL;
23579 }
23580
23581
23582 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23583 PyObject *resultobj;
23584 char *kwnames[] = {
23585 NULL
23586 };
23587
23588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23589 {
23590 PyThreadState* __tstate = wxPyBeginAllowThreads();
23591 wxWakeUpIdle();
23592
23593 wxPyEndAllowThreads(__tstate);
23594 if (PyErr_Occurred()) SWIG_fail;
23595 }
23596 Py_INCREF(Py_None); resultobj = Py_None;
23597 return resultobj;
23598 fail:
23599 return NULL;
23600 }
23601
23602
23603 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23604 PyObject *resultobj;
23605 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23606 wxEvent *arg2 = 0 ;
23607 PyObject * obj0 = 0 ;
23608 PyObject * obj1 = 0 ;
23609 char *kwnames[] = {
23610 (char *) "dest",(char *) "event", NULL
23611 };
23612
23613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23615 if (SWIG_arg_fail(1)) SWIG_fail;
23616 {
23617 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23618 if (SWIG_arg_fail(2)) SWIG_fail;
23619 if (arg2 == NULL) {
23620 SWIG_null_ref("wxEvent");
23621 }
23622 if (SWIG_arg_fail(2)) SWIG_fail;
23623 }
23624 {
23625 PyThreadState* __tstate = wxPyBeginAllowThreads();
23626 wxPostEvent(arg1,*arg2);
23627
23628 wxPyEndAllowThreads(__tstate);
23629 if (PyErr_Occurred()) SWIG_fail;
23630 }
23631 Py_INCREF(Py_None); resultobj = Py_None;
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23639 PyObject *resultobj;
23640 char *kwnames[] = {
23641 NULL
23642 };
23643
23644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23645 {
23646 PyThreadState* __tstate = wxPyBeginAllowThreads();
23647 wxApp_CleanUp();
23648
23649 wxPyEndAllowThreads(__tstate);
23650 if (PyErr_Occurred()) SWIG_fail;
23651 }
23652 Py_INCREF(Py_None); resultobj = Py_None;
23653 return resultobj;
23654 fail:
23655 return NULL;
23656 }
23657
23658
23659 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23660 PyObject *resultobj;
23661 wxPyApp *result;
23662 char *kwnames[] = {
23663 NULL
23664 };
23665
23666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23667 {
23668 PyThreadState* __tstate = wxPyBeginAllowThreads();
23669 result = (wxPyApp *)wxPyGetApp();
23670
23671 wxPyEndAllowThreads(__tstate);
23672 if (PyErr_Occurred()) SWIG_fail;
23673 }
23674 {
23675 resultobj = wxPyMake_wxObject(result, 0);
23676 }
23677 return resultobj;
23678 fail:
23679 return NULL;
23680 }
23681
23682
23683 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23684 PyObject *resultobj;
23685 char *arg1 = (char *) 0 ;
23686 PyObject * obj0 = 0 ;
23687 char *kwnames[] = {
23688 (char *) "encoding", NULL
23689 };
23690
23691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23692 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23693 SWIG_arg_fail(1);SWIG_fail;
23694 }
23695 {
23696 PyThreadState* __tstate = wxPyBeginAllowThreads();
23697 wxSetDefaultPyEncoding((char const *)arg1);
23698
23699 wxPyEndAllowThreads(__tstate);
23700 if (PyErr_Occurred()) SWIG_fail;
23701 }
23702 Py_INCREF(Py_None); resultobj = Py_None;
23703 return resultobj;
23704 fail:
23705 return NULL;
23706 }
23707
23708
23709 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23710 PyObject *resultobj;
23711 char *result;
23712 char *kwnames[] = {
23713 NULL
23714 };
23715
23716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23717 {
23718 PyThreadState* __tstate = wxPyBeginAllowThreads();
23719 result = (char *)wxGetDefaultPyEncoding();
23720
23721 wxPyEndAllowThreads(__tstate);
23722 if (PyErr_Occurred()) SWIG_fail;
23723 }
23724 resultobj = SWIG_FromCharPtr(result);
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23732 PyObject *resultobj;
23733 wxEventLoop *result;
23734 char *kwnames[] = {
23735 NULL
23736 };
23737
23738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23739 {
23740 PyThreadState* __tstate = wxPyBeginAllowThreads();
23741 result = (wxEventLoop *)new wxEventLoop();
23742
23743 wxPyEndAllowThreads(__tstate);
23744 if (PyErr_Occurred()) SWIG_fail;
23745 }
23746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23747 return resultobj;
23748 fail:
23749 return NULL;
23750 }
23751
23752
23753 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23754 PyObject *resultobj;
23755 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23756 PyObject * obj0 = 0 ;
23757 char *kwnames[] = {
23758 (char *) "self", NULL
23759 };
23760
23761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23763 if (SWIG_arg_fail(1)) SWIG_fail;
23764 {
23765 PyThreadState* __tstate = wxPyBeginAllowThreads();
23766 delete arg1;
23767
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 Py_INCREF(Py_None); resultobj = Py_None;
23772 return resultobj;
23773 fail:
23774 return NULL;
23775 }
23776
23777
23778 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23779 PyObject *resultobj;
23780 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23781 int result;
23782 PyObject * obj0 = 0 ;
23783 char *kwnames[] = {
23784 (char *) "self", NULL
23785 };
23786
23787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23789 if (SWIG_arg_fail(1)) SWIG_fail;
23790 {
23791 PyThreadState* __tstate = wxPyBeginAllowThreads();
23792 result = (int)(arg1)->Run();
23793
23794 wxPyEndAllowThreads(__tstate);
23795 if (PyErr_Occurred()) SWIG_fail;
23796 }
23797 {
23798 resultobj = SWIG_From_int((int)(result));
23799 }
23800 return resultobj;
23801 fail:
23802 return NULL;
23803 }
23804
23805
23806 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23807 PyObject *resultobj;
23808 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23809 int arg2 = (int) 0 ;
23810 PyObject * obj0 = 0 ;
23811 PyObject * obj1 = 0 ;
23812 char *kwnames[] = {
23813 (char *) "self",(char *) "rc", NULL
23814 };
23815
23816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23818 if (SWIG_arg_fail(1)) SWIG_fail;
23819 if (obj1) {
23820 {
23821 arg2 = (int)(SWIG_As_int(obj1));
23822 if (SWIG_arg_fail(2)) SWIG_fail;
23823 }
23824 }
23825 {
23826 PyThreadState* __tstate = wxPyBeginAllowThreads();
23827 (arg1)->Exit(arg2);
23828
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 Py_INCREF(Py_None); resultobj = Py_None;
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23840 PyObject *resultobj;
23841 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23842 bool result;
23843 PyObject * obj0 = 0 ;
23844 char *kwnames[] = {
23845 (char *) "self", NULL
23846 };
23847
23848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23850 if (SWIG_arg_fail(1)) SWIG_fail;
23851 {
23852 PyThreadState* __tstate = wxPyBeginAllowThreads();
23853 result = (bool)((wxEventLoop const *)arg1)->Pending();
23854
23855 wxPyEndAllowThreads(__tstate);
23856 if (PyErr_Occurred()) SWIG_fail;
23857 }
23858 {
23859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23860 }
23861 return resultobj;
23862 fail:
23863 return NULL;
23864 }
23865
23866
23867 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23868 PyObject *resultobj;
23869 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23870 bool result;
23871 PyObject * obj0 = 0 ;
23872 char *kwnames[] = {
23873 (char *) "self", NULL
23874 };
23875
23876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23878 if (SWIG_arg_fail(1)) SWIG_fail;
23879 {
23880 PyThreadState* __tstate = wxPyBeginAllowThreads();
23881 result = (bool)(arg1)->Dispatch();
23882
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 {
23887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23888 }
23889 return resultobj;
23890 fail:
23891 return NULL;
23892 }
23893
23894
23895 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23896 PyObject *resultobj;
23897 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23898 bool result;
23899 PyObject * obj0 = 0 ;
23900 char *kwnames[] = {
23901 (char *) "self", NULL
23902 };
23903
23904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23906 if (SWIG_arg_fail(1)) SWIG_fail;
23907 {
23908 PyThreadState* __tstate = wxPyBeginAllowThreads();
23909 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23910
23911 wxPyEndAllowThreads(__tstate);
23912 if (PyErr_Occurred()) SWIG_fail;
23913 }
23914 {
23915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23916 }
23917 return resultobj;
23918 fail:
23919 return NULL;
23920 }
23921
23922
23923 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23924 PyObject *resultobj;
23925 wxEventLoop *result;
23926 char *kwnames[] = {
23927 NULL
23928 };
23929
23930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23931 {
23932 PyThreadState* __tstate = wxPyBeginAllowThreads();
23933 result = (wxEventLoop *)wxEventLoop::GetActive();
23934
23935 wxPyEndAllowThreads(__tstate);
23936 if (PyErr_Occurred()) SWIG_fail;
23937 }
23938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23939 return resultobj;
23940 fail:
23941 return NULL;
23942 }
23943
23944
23945 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23946 PyObject *resultobj;
23947 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23948 PyObject * obj0 = 0 ;
23949 char *kwnames[] = {
23950 (char *) "loop", NULL
23951 };
23952
23953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23955 if (SWIG_arg_fail(1)) SWIG_fail;
23956 {
23957 PyThreadState* __tstate = wxPyBeginAllowThreads();
23958 wxEventLoop::SetActive(arg1);
23959
23960 wxPyEndAllowThreads(__tstate);
23961 if (PyErr_Occurred()) SWIG_fail;
23962 }
23963 Py_INCREF(Py_None); resultobj = Py_None;
23964 return resultobj;
23965 fail:
23966 return NULL;
23967 }
23968
23969
23970 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23971 PyObject *obj;
23972 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23973 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23974 Py_INCREF(obj);
23975 return Py_BuildValue((char *)"");
23976 }
23977 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23978 PyObject *resultobj;
23979 int arg1 = (int) 0 ;
23980 int arg2 = (int) 0 ;
23981 int arg3 = (int) 0 ;
23982 wxAcceleratorEntry *result;
23983 PyObject * obj0 = 0 ;
23984 PyObject * obj1 = 0 ;
23985 PyObject * obj2 = 0 ;
23986 char *kwnames[] = {
23987 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23988 };
23989
23990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23991 if (obj0) {
23992 {
23993 arg1 = (int)(SWIG_As_int(obj0));
23994 if (SWIG_arg_fail(1)) SWIG_fail;
23995 }
23996 }
23997 if (obj1) {
23998 {
23999 arg2 = (int)(SWIG_As_int(obj1));
24000 if (SWIG_arg_fail(2)) SWIG_fail;
24001 }
24002 }
24003 if (obj2) {
24004 {
24005 arg3 = (int)(SWIG_As_int(obj2));
24006 if (SWIG_arg_fail(3)) SWIG_fail;
24007 }
24008 }
24009 {
24010 PyThreadState* __tstate = wxPyBeginAllowThreads();
24011 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24012
24013 wxPyEndAllowThreads(__tstate);
24014 if (PyErr_Occurred()) SWIG_fail;
24015 }
24016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24017 return resultobj;
24018 fail:
24019 return NULL;
24020 }
24021
24022
24023 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24024 PyObject *resultobj;
24025 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24026 PyObject * obj0 = 0 ;
24027 char *kwnames[] = {
24028 (char *) "self", NULL
24029 };
24030
24031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24033 if (SWIG_arg_fail(1)) SWIG_fail;
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 delete arg1;
24037
24038 wxPyEndAllowThreads(__tstate);
24039 if (PyErr_Occurred()) SWIG_fail;
24040 }
24041 Py_INCREF(Py_None); resultobj = Py_None;
24042 return resultobj;
24043 fail:
24044 return NULL;
24045 }
24046
24047
24048 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24049 PyObject *resultobj;
24050 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24051 int arg2 ;
24052 int arg3 ;
24053 int arg4 ;
24054 PyObject * obj0 = 0 ;
24055 PyObject * obj1 = 0 ;
24056 PyObject * obj2 = 0 ;
24057 PyObject * obj3 = 0 ;
24058 char *kwnames[] = {
24059 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24060 };
24061
24062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24064 if (SWIG_arg_fail(1)) SWIG_fail;
24065 {
24066 arg2 = (int)(SWIG_As_int(obj1));
24067 if (SWIG_arg_fail(2)) SWIG_fail;
24068 }
24069 {
24070 arg3 = (int)(SWIG_As_int(obj2));
24071 if (SWIG_arg_fail(3)) SWIG_fail;
24072 }
24073 {
24074 arg4 = (int)(SWIG_As_int(obj3));
24075 if (SWIG_arg_fail(4)) SWIG_fail;
24076 }
24077 {
24078 PyThreadState* __tstate = wxPyBeginAllowThreads();
24079 (arg1)->Set(arg2,arg3,arg4);
24080
24081 wxPyEndAllowThreads(__tstate);
24082 if (PyErr_Occurred()) SWIG_fail;
24083 }
24084 Py_INCREF(Py_None); resultobj = Py_None;
24085 return resultobj;
24086 fail:
24087 return NULL;
24088 }
24089
24090
24091 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24092 PyObject *resultobj;
24093 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24094 int result;
24095 PyObject * obj0 = 0 ;
24096 char *kwnames[] = {
24097 (char *) "self", NULL
24098 };
24099
24100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24102 if (SWIG_arg_fail(1)) SWIG_fail;
24103 {
24104 PyThreadState* __tstate = wxPyBeginAllowThreads();
24105 result = (int)(arg1)->GetFlags();
24106
24107 wxPyEndAllowThreads(__tstate);
24108 if (PyErr_Occurred()) SWIG_fail;
24109 }
24110 {
24111 resultobj = SWIG_From_int((int)(result));
24112 }
24113 return resultobj;
24114 fail:
24115 return NULL;
24116 }
24117
24118
24119 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24120 PyObject *resultobj;
24121 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24122 int result;
24123 PyObject * obj0 = 0 ;
24124 char *kwnames[] = {
24125 (char *) "self", NULL
24126 };
24127
24128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24130 if (SWIG_arg_fail(1)) SWIG_fail;
24131 {
24132 PyThreadState* __tstate = wxPyBeginAllowThreads();
24133 result = (int)(arg1)->GetKeyCode();
24134
24135 wxPyEndAllowThreads(__tstate);
24136 if (PyErr_Occurred()) SWIG_fail;
24137 }
24138 {
24139 resultobj = SWIG_From_int((int)(result));
24140 }
24141 return resultobj;
24142 fail:
24143 return NULL;
24144 }
24145
24146
24147 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24148 PyObject *resultobj;
24149 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24150 int result;
24151 PyObject * obj0 = 0 ;
24152 char *kwnames[] = {
24153 (char *) "self", NULL
24154 };
24155
24156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24158 if (SWIG_arg_fail(1)) SWIG_fail;
24159 {
24160 PyThreadState* __tstate = wxPyBeginAllowThreads();
24161 result = (int)(arg1)->GetCommand();
24162
24163 wxPyEndAllowThreads(__tstate);
24164 if (PyErr_Occurred()) SWIG_fail;
24165 }
24166 {
24167 resultobj = SWIG_From_int((int)(result));
24168 }
24169 return resultobj;
24170 fail:
24171 return NULL;
24172 }
24173
24174
24175 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24176 PyObject *obj;
24177 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24178 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24179 Py_INCREF(obj);
24180 return Py_BuildValue((char *)"");
24181 }
24182 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24183 PyObject *resultobj;
24184 int arg1 ;
24185 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24186 wxAcceleratorTable *result;
24187 PyObject * obj0 = 0 ;
24188 char *kwnames[] = {
24189 (char *) "n", NULL
24190 };
24191
24192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24193 {
24194 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24195 if (arg2) arg1 = PyList_Size(obj0);
24196 else arg1 = 0;
24197 }
24198 {
24199 PyThreadState* __tstate = wxPyBeginAllowThreads();
24200 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24201
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24206 {
24207 delete [] arg2;
24208 }
24209 return resultobj;
24210 fail:
24211 {
24212 delete [] arg2;
24213 }
24214 return NULL;
24215 }
24216
24217
24218 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24219 PyObject *resultobj;
24220 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24221 PyObject * obj0 = 0 ;
24222 char *kwnames[] = {
24223 (char *) "self", NULL
24224 };
24225
24226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24228 if (SWIG_arg_fail(1)) SWIG_fail;
24229 {
24230 PyThreadState* __tstate = wxPyBeginAllowThreads();
24231 delete arg1;
24232
24233 wxPyEndAllowThreads(__tstate);
24234 if (PyErr_Occurred()) SWIG_fail;
24235 }
24236 Py_INCREF(Py_None); resultobj = Py_None;
24237 return resultobj;
24238 fail:
24239 return NULL;
24240 }
24241
24242
24243 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24244 PyObject *resultobj;
24245 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24246 bool result;
24247 PyObject * obj0 = 0 ;
24248 char *kwnames[] = {
24249 (char *) "self", NULL
24250 };
24251
24252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24254 if (SWIG_arg_fail(1)) SWIG_fail;
24255 {
24256 PyThreadState* __tstate = wxPyBeginAllowThreads();
24257 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24258
24259 wxPyEndAllowThreads(__tstate);
24260 if (PyErr_Occurred()) SWIG_fail;
24261 }
24262 {
24263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24264 }
24265 return resultobj;
24266 fail:
24267 return NULL;
24268 }
24269
24270
24271 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24272 PyObject *obj;
24273 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24274 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24275 Py_INCREF(obj);
24276 return Py_BuildValue((char *)"");
24277 }
24278 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24279 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24280 return 1;
24281 }
24282
24283
24284 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24285 PyObject *pyobj;
24286
24287 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24288 return pyobj;
24289 }
24290
24291
24292 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24293 PyObject *resultobj;
24294 wxString *arg1 = 0 ;
24295 wxAcceleratorEntry *result;
24296 bool temp1 = false ;
24297 PyObject * obj0 = 0 ;
24298 char *kwnames[] = {
24299 (char *) "label", NULL
24300 };
24301
24302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24303 {
24304 arg1 = wxString_in_helper(obj0);
24305 if (arg1 == NULL) SWIG_fail;
24306 temp1 = true;
24307 }
24308 {
24309 PyThreadState* __tstate = wxPyBeginAllowThreads();
24310 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24311
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24316 {
24317 if (temp1)
24318 delete arg1;
24319 }
24320 return resultobj;
24321 fail:
24322 {
24323 if (temp1)
24324 delete arg1;
24325 }
24326 return NULL;
24327 }
24328
24329
24330 static int _wrap_PanelNameStr_set(PyObject *) {
24331 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24332 return 1;
24333 }
24334
24335
24336 static PyObject *_wrap_PanelNameStr_get(void) {
24337 PyObject *pyobj;
24338
24339 {
24340 #if wxUSE_UNICODE
24341 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24342 #else
24343 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24344 #endif
24345 }
24346 return pyobj;
24347 }
24348
24349
24350 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj;
24352 wxVisualAttributes *result;
24353 char *kwnames[] = {
24354 NULL
24355 };
24356
24357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24358 {
24359 PyThreadState* __tstate = wxPyBeginAllowThreads();
24360 result = (wxVisualAttributes *)new_wxVisualAttributes();
24361
24362 wxPyEndAllowThreads(__tstate);
24363 if (PyErr_Occurred()) SWIG_fail;
24364 }
24365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24366 return resultobj;
24367 fail:
24368 return NULL;
24369 }
24370
24371
24372 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24373 PyObject *resultobj;
24374 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24375 PyObject * obj0 = 0 ;
24376 char *kwnames[] = {
24377 (char *) "self", NULL
24378 };
24379
24380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24382 if (SWIG_arg_fail(1)) SWIG_fail;
24383 {
24384 PyThreadState* __tstate = wxPyBeginAllowThreads();
24385 delete_wxVisualAttributes(arg1);
24386
24387 wxPyEndAllowThreads(__tstate);
24388 if (PyErr_Occurred()) SWIG_fail;
24389 }
24390 Py_INCREF(Py_None); resultobj = Py_None;
24391 return resultobj;
24392 fail:
24393 return NULL;
24394 }
24395
24396
24397 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24398 PyObject *resultobj;
24399 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24400 wxFont *arg2 = (wxFont *) 0 ;
24401 PyObject * obj0 = 0 ;
24402 PyObject * obj1 = 0 ;
24403 char *kwnames[] = {
24404 (char *) "self",(char *) "font", NULL
24405 };
24406
24407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24409 if (SWIG_arg_fail(1)) SWIG_fail;
24410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24411 if (SWIG_arg_fail(2)) SWIG_fail;
24412 if (arg1) (arg1)->font = *arg2;
24413
24414 Py_INCREF(Py_None); resultobj = Py_None;
24415 return resultobj;
24416 fail:
24417 return NULL;
24418 }
24419
24420
24421 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24422 PyObject *resultobj;
24423 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24424 wxFont *result;
24425 PyObject * obj0 = 0 ;
24426 char *kwnames[] = {
24427 (char *) "self", NULL
24428 };
24429
24430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24432 if (SWIG_arg_fail(1)) SWIG_fail;
24433 result = (wxFont *)& ((arg1)->font);
24434
24435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24436 return resultobj;
24437 fail:
24438 return NULL;
24439 }
24440
24441
24442 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24443 PyObject *resultobj;
24444 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24445 wxColour *arg2 = (wxColour *) 0 ;
24446 PyObject * obj0 = 0 ;
24447 PyObject * obj1 = 0 ;
24448 char *kwnames[] = {
24449 (char *) "self",(char *) "colFg", NULL
24450 };
24451
24452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24454 if (SWIG_arg_fail(1)) SWIG_fail;
24455 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24456 if (SWIG_arg_fail(2)) SWIG_fail;
24457 if (arg1) (arg1)->colFg = *arg2;
24458
24459 Py_INCREF(Py_None); resultobj = Py_None;
24460 return resultobj;
24461 fail:
24462 return NULL;
24463 }
24464
24465
24466 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24467 PyObject *resultobj;
24468 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24469 wxColour *result;
24470 PyObject * obj0 = 0 ;
24471 char *kwnames[] = {
24472 (char *) "self", NULL
24473 };
24474
24475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24477 if (SWIG_arg_fail(1)) SWIG_fail;
24478 result = (wxColour *)& ((arg1)->colFg);
24479
24480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24481 return resultobj;
24482 fail:
24483 return NULL;
24484 }
24485
24486
24487 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24488 PyObject *resultobj;
24489 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24490 wxColour *arg2 = (wxColour *) 0 ;
24491 PyObject * obj0 = 0 ;
24492 PyObject * obj1 = 0 ;
24493 char *kwnames[] = {
24494 (char *) "self",(char *) "colBg", NULL
24495 };
24496
24497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24499 if (SWIG_arg_fail(1)) SWIG_fail;
24500 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24501 if (SWIG_arg_fail(2)) SWIG_fail;
24502 if (arg1) (arg1)->colBg = *arg2;
24503
24504 Py_INCREF(Py_None); resultobj = Py_None;
24505 return resultobj;
24506 fail:
24507 return NULL;
24508 }
24509
24510
24511 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24512 PyObject *resultobj;
24513 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24514 wxColour *result;
24515 PyObject * obj0 = 0 ;
24516 char *kwnames[] = {
24517 (char *) "self", NULL
24518 };
24519
24520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24522 if (SWIG_arg_fail(1)) SWIG_fail;
24523 result = (wxColour *)& ((arg1)->colBg);
24524
24525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24533 PyObject *obj;
24534 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24535 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24536 Py_INCREF(obj);
24537 return Py_BuildValue((char *)"");
24538 }
24539 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24540 PyObject *resultobj;
24541 wxWindow *arg1 = (wxWindow *) 0 ;
24542 int arg2 = (int) (int)-1 ;
24543 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24544 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24545 wxSize const &arg4_defvalue = wxDefaultSize ;
24546 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24547 long arg5 = (long) 0 ;
24548 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24549 wxString *arg6 = (wxString *) &arg6_defvalue ;
24550 wxWindow *result;
24551 wxPoint temp3 ;
24552 wxSize temp4 ;
24553 bool temp6 = false ;
24554 PyObject * obj0 = 0 ;
24555 PyObject * obj1 = 0 ;
24556 PyObject * obj2 = 0 ;
24557 PyObject * obj3 = 0 ;
24558 PyObject * obj4 = 0 ;
24559 PyObject * obj5 = 0 ;
24560 char *kwnames[] = {
24561 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24562 };
24563
24564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24566 if (SWIG_arg_fail(1)) SWIG_fail;
24567 if (obj1) {
24568 {
24569 arg2 = (int const)(SWIG_As_int(obj1));
24570 if (SWIG_arg_fail(2)) SWIG_fail;
24571 }
24572 }
24573 if (obj2) {
24574 {
24575 arg3 = &temp3;
24576 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24577 }
24578 }
24579 if (obj3) {
24580 {
24581 arg4 = &temp4;
24582 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24583 }
24584 }
24585 if (obj4) {
24586 {
24587 arg5 = (long)(SWIG_As_long(obj4));
24588 if (SWIG_arg_fail(5)) SWIG_fail;
24589 }
24590 }
24591 if (obj5) {
24592 {
24593 arg6 = wxString_in_helper(obj5);
24594 if (arg6 == NULL) SWIG_fail;
24595 temp6 = true;
24596 }
24597 }
24598 {
24599 if (!wxPyCheckForApp()) SWIG_fail;
24600 PyThreadState* __tstate = wxPyBeginAllowThreads();
24601 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24602
24603 wxPyEndAllowThreads(__tstate);
24604 if (PyErr_Occurred()) SWIG_fail;
24605 }
24606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24607 {
24608 if (temp6)
24609 delete arg6;
24610 }
24611 return resultobj;
24612 fail:
24613 {
24614 if (temp6)
24615 delete arg6;
24616 }
24617 return NULL;
24618 }
24619
24620
24621 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24622 PyObject *resultobj;
24623 wxWindow *result;
24624 char *kwnames[] = {
24625 NULL
24626 };
24627
24628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24629 {
24630 if (!wxPyCheckForApp()) SWIG_fail;
24631 PyThreadState* __tstate = wxPyBeginAllowThreads();
24632 result = (wxWindow *)new wxWindow();
24633
24634 wxPyEndAllowThreads(__tstate);
24635 if (PyErr_Occurred()) SWIG_fail;
24636 }
24637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24638 return resultobj;
24639 fail:
24640 return NULL;
24641 }
24642
24643
24644 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24645 PyObject *resultobj;
24646 wxWindow *arg1 = (wxWindow *) 0 ;
24647 wxWindow *arg2 = (wxWindow *) 0 ;
24648 int arg3 = (int) (int)-1 ;
24649 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24650 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24651 wxSize const &arg5_defvalue = wxDefaultSize ;
24652 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24653 long arg6 = (long) 0 ;
24654 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24655 wxString *arg7 = (wxString *) &arg7_defvalue ;
24656 bool result;
24657 wxPoint temp4 ;
24658 wxSize temp5 ;
24659 bool temp7 = false ;
24660 PyObject * obj0 = 0 ;
24661 PyObject * obj1 = 0 ;
24662 PyObject * obj2 = 0 ;
24663 PyObject * obj3 = 0 ;
24664 PyObject * obj4 = 0 ;
24665 PyObject * obj5 = 0 ;
24666 PyObject * obj6 = 0 ;
24667 char *kwnames[] = {
24668 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24669 };
24670
24671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24673 if (SWIG_arg_fail(1)) SWIG_fail;
24674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24675 if (SWIG_arg_fail(2)) SWIG_fail;
24676 if (obj2) {
24677 {
24678 arg3 = (int const)(SWIG_As_int(obj2));
24679 if (SWIG_arg_fail(3)) SWIG_fail;
24680 }
24681 }
24682 if (obj3) {
24683 {
24684 arg4 = &temp4;
24685 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24686 }
24687 }
24688 if (obj4) {
24689 {
24690 arg5 = &temp5;
24691 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24692 }
24693 }
24694 if (obj5) {
24695 {
24696 arg6 = (long)(SWIG_As_long(obj5));
24697 if (SWIG_arg_fail(6)) SWIG_fail;
24698 }
24699 }
24700 if (obj6) {
24701 {
24702 arg7 = wxString_in_helper(obj6);
24703 if (arg7 == NULL) SWIG_fail;
24704 temp7 = true;
24705 }
24706 }
24707 {
24708 PyThreadState* __tstate = wxPyBeginAllowThreads();
24709 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24710
24711 wxPyEndAllowThreads(__tstate);
24712 if (PyErr_Occurred()) SWIG_fail;
24713 }
24714 {
24715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24716 }
24717 {
24718 if (temp7)
24719 delete arg7;
24720 }
24721 return resultobj;
24722 fail:
24723 {
24724 if (temp7)
24725 delete arg7;
24726 }
24727 return NULL;
24728 }
24729
24730
24731 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24732 PyObject *resultobj;
24733 wxWindow *arg1 = (wxWindow *) 0 ;
24734 bool arg2 = (bool) false ;
24735 bool result;
24736 PyObject * obj0 = 0 ;
24737 PyObject * obj1 = 0 ;
24738 char *kwnames[] = {
24739 (char *) "self",(char *) "force", NULL
24740 };
24741
24742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24744 if (SWIG_arg_fail(1)) SWIG_fail;
24745 if (obj1) {
24746 {
24747 arg2 = (bool)(SWIG_As_bool(obj1));
24748 if (SWIG_arg_fail(2)) SWIG_fail;
24749 }
24750 }
24751 {
24752 PyThreadState* __tstate = wxPyBeginAllowThreads();
24753 result = (bool)(arg1)->Close(arg2);
24754
24755 wxPyEndAllowThreads(__tstate);
24756 if (PyErr_Occurred()) SWIG_fail;
24757 }
24758 {
24759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24760 }
24761 return resultobj;
24762 fail:
24763 return NULL;
24764 }
24765
24766
24767 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24768 PyObject *resultobj;
24769 wxWindow *arg1 = (wxWindow *) 0 ;
24770 bool result;
24771 PyObject * obj0 = 0 ;
24772 char *kwnames[] = {
24773 (char *) "self", NULL
24774 };
24775
24776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24778 if (SWIG_arg_fail(1)) SWIG_fail;
24779 {
24780 PyThreadState* __tstate = wxPyBeginAllowThreads();
24781 result = (bool)(arg1)->Destroy();
24782
24783 wxPyEndAllowThreads(__tstate);
24784 if (PyErr_Occurred()) SWIG_fail;
24785 }
24786 {
24787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24788 }
24789 return resultobj;
24790 fail:
24791 return NULL;
24792 }
24793
24794
24795 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24796 PyObject *resultobj;
24797 wxWindow *arg1 = (wxWindow *) 0 ;
24798 bool result;
24799 PyObject * obj0 = 0 ;
24800 char *kwnames[] = {
24801 (char *) "self", NULL
24802 };
24803
24804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24806 if (SWIG_arg_fail(1)) SWIG_fail;
24807 {
24808 PyThreadState* __tstate = wxPyBeginAllowThreads();
24809 result = (bool)(arg1)->DestroyChildren();
24810
24811 wxPyEndAllowThreads(__tstate);
24812 if (PyErr_Occurred()) SWIG_fail;
24813 }
24814 {
24815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24816 }
24817 return resultobj;
24818 fail:
24819 return NULL;
24820 }
24821
24822
24823 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24824 PyObject *resultobj;
24825 wxWindow *arg1 = (wxWindow *) 0 ;
24826 bool result;
24827 PyObject * obj0 = 0 ;
24828 char *kwnames[] = {
24829 (char *) "self", NULL
24830 };
24831
24832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24834 if (SWIG_arg_fail(1)) SWIG_fail;
24835 {
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24838
24839 wxPyEndAllowThreads(__tstate);
24840 if (PyErr_Occurred()) SWIG_fail;
24841 }
24842 {
24843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24844 }
24845 return resultobj;
24846 fail:
24847 return NULL;
24848 }
24849
24850
24851 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24852 PyObject *resultobj;
24853 wxWindow *arg1 = (wxWindow *) 0 ;
24854 wxString *arg2 = 0 ;
24855 bool temp2 = false ;
24856 PyObject * obj0 = 0 ;
24857 PyObject * obj1 = 0 ;
24858 char *kwnames[] = {
24859 (char *) "self",(char *) "title", NULL
24860 };
24861
24862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24864 if (SWIG_arg_fail(1)) SWIG_fail;
24865 {
24866 arg2 = wxString_in_helper(obj1);
24867 if (arg2 == NULL) SWIG_fail;
24868 temp2 = true;
24869 }
24870 {
24871 PyThreadState* __tstate = wxPyBeginAllowThreads();
24872 (arg1)->SetTitle((wxString const &)*arg2);
24873
24874 wxPyEndAllowThreads(__tstate);
24875 if (PyErr_Occurred()) SWIG_fail;
24876 }
24877 Py_INCREF(Py_None); resultobj = Py_None;
24878 {
24879 if (temp2)
24880 delete arg2;
24881 }
24882 return resultobj;
24883 fail:
24884 {
24885 if (temp2)
24886 delete arg2;
24887 }
24888 return NULL;
24889 }
24890
24891
24892 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24893 PyObject *resultobj;
24894 wxWindow *arg1 = (wxWindow *) 0 ;
24895 wxString result;
24896 PyObject * obj0 = 0 ;
24897 char *kwnames[] = {
24898 (char *) "self", NULL
24899 };
24900
24901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24903 if (SWIG_arg_fail(1)) SWIG_fail;
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = ((wxWindow const *)arg1)->GetTitle();
24907
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 {
24912 #if wxUSE_UNICODE
24913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24914 #else
24915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24916 #endif
24917 }
24918 return resultobj;
24919 fail:
24920 return NULL;
24921 }
24922
24923
24924 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24925 PyObject *resultobj;
24926 wxWindow *arg1 = (wxWindow *) 0 ;
24927 wxString *arg2 = 0 ;
24928 bool temp2 = false ;
24929 PyObject * obj0 = 0 ;
24930 PyObject * obj1 = 0 ;
24931 char *kwnames[] = {
24932 (char *) "self",(char *) "label", NULL
24933 };
24934
24935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24937 if (SWIG_arg_fail(1)) SWIG_fail;
24938 {
24939 arg2 = wxString_in_helper(obj1);
24940 if (arg2 == NULL) SWIG_fail;
24941 temp2 = true;
24942 }
24943 {
24944 PyThreadState* __tstate = wxPyBeginAllowThreads();
24945 (arg1)->SetLabel((wxString const &)*arg2);
24946
24947 wxPyEndAllowThreads(__tstate);
24948 if (PyErr_Occurred()) SWIG_fail;
24949 }
24950 Py_INCREF(Py_None); resultobj = Py_None;
24951 {
24952 if (temp2)
24953 delete arg2;
24954 }
24955 return resultobj;
24956 fail:
24957 {
24958 if (temp2)
24959 delete arg2;
24960 }
24961 return NULL;
24962 }
24963
24964
24965 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24966 PyObject *resultobj;
24967 wxWindow *arg1 = (wxWindow *) 0 ;
24968 wxString result;
24969 PyObject * obj0 = 0 ;
24970 char *kwnames[] = {
24971 (char *) "self", NULL
24972 };
24973
24974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24976 if (SWIG_arg_fail(1)) SWIG_fail;
24977 {
24978 PyThreadState* __tstate = wxPyBeginAllowThreads();
24979 result = ((wxWindow const *)arg1)->GetLabel();
24980
24981 wxPyEndAllowThreads(__tstate);
24982 if (PyErr_Occurred()) SWIG_fail;
24983 }
24984 {
24985 #if wxUSE_UNICODE
24986 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24987 #else
24988 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24989 #endif
24990 }
24991 return resultobj;
24992 fail:
24993 return NULL;
24994 }
24995
24996
24997 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24998 PyObject *resultobj;
24999 wxWindow *arg1 = (wxWindow *) 0 ;
25000 wxString *arg2 = 0 ;
25001 bool temp2 = false ;
25002 PyObject * obj0 = 0 ;
25003 PyObject * obj1 = 0 ;
25004 char *kwnames[] = {
25005 (char *) "self",(char *) "name", NULL
25006 };
25007
25008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25010 if (SWIG_arg_fail(1)) SWIG_fail;
25011 {
25012 arg2 = wxString_in_helper(obj1);
25013 if (arg2 == NULL) SWIG_fail;
25014 temp2 = true;
25015 }
25016 {
25017 PyThreadState* __tstate = wxPyBeginAllowThreads();
25018 (arg1)->SetName((wxString const &)*arg2);
25019
25020 wxPyEndAllowThreads(__tstate);
25021 if (PyErr_Occurred()) SWIG_fail;
25022 }
25023 Py_INCREF(Py_None); resultobj = Py_None;
25024 {
25025 if (temp2)
25026 delete arg2;
25027 }
25028 return resultobj;
25029 fail:
25030 {
25031 if (temp2)
25032 delete arg2;
25033 }
25034 return NULL;
25035 }
25036
25037
25038 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25039 PyObject *resultobj;
25040 wxWindow *arg1 = (wxWindow *) 0 ;
25041 wxString result;
25042 PyObject * obj0 = 0 ;
25043 char *kwnames[] = {
25044 (char *) "self", NULL
25045 };
25046
25047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25049 if (SWIG_arg_fail(1)) SWIG_fail;
25050 {
25051 PyThreadState* __tstate = wxPyBeginAllowThreads();
25052 result = ((wxWindow const *)arg1)->GetName();
25053
25054 wxPyEndAllowThreads(__tstate);
25055 if (PyErr_Occurred()) SWIG_fail;
25056 }
25057 {
25058 #if wxUSE_UNICODE
25059 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25060 #else
25061 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25062 #endif
25063 }
25064 return resultobj;
25065 fail:
25066 return NULL;
25067 }
25068
25069
25070 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25071 PyObject *resultobj;
25072 wxWindow *arg1 = (wxWindow *) 0 ;
25073 wxWindowVariant arg2 ;
25074 PyObject * obj0 = 0 ;
25075 PyObject * obj1 = 0 ;
25076 char *kwnames[] = {
25077 (char *) "self",(char *) "variant", NULL
25078 };
25079
25080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25082 if (SWIG_arg_fail(1)) SWIG_fail;
25083 {
25084 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25085 if (SWIG_arg_fail(2)) SWIG_fail;
25086 }
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25090
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 Py_INCREF(Py_None); resultobj = Py_None;
25095 return resultobj;
25096 fail:
25097 return NULL;
25098 }
25099
25100
25101 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25102 PyObject *resultobj;
25103 wxWindow *arg1 = (wxWindow *) 0 ;
25104 wxWindowVariant result;
25105 PyObject * obj0 = 0 ;
25106 char *kwnames[] = {
25107 (char *) "self", NULL
25108 };
25109
25110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25112 if (SWIG_arg_fail(1)) SWIG_fail;
25113 {
25114 PyThreadState* __tstate = wxPyBeginAllowThreads();
25115 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25116
25117 wxPyEndAllowThreads(__tstate);
25118 if (PyErr_Occurred()) SWIG_fail;
25119 }
25120 resultobj = SWIG_From_int((result));
25121 return resultobj;
25122 fail:
25123 return NULL;
25124 }
25125
25126
25127 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25128 PyObject *resultobj;
25129 wxWindow *arg1 = (wxWindow *) 0 ;
25130 int arg2 ;
25131 PyObject * obj0 = 0 ;
25132 PyObject * obj1 = 0 ;
25133 char *kwnames[] = {
25134 (char *) "self",(char *) "winid", NULL
25135 };
25136
25137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25139 if (SWIG_arg_fail(1)) SWIG_fail;
25140 {
25141 arg2 = (int)(SWIG_As_int(obj1));
25142 if (SWIG_arg_fail(2)) SWIG_fail;
25143 }
25144 {
25145 PyThreadState* __tstate = wxPyBeginAllowThreads();
25146 (arg1)->SetId(arg2);
25147
25148 wxPyEndAllowThreads(__tstate);
25149 if (PyErr_Occurred()) SWIG_fail;
25150 }
25151 Py_INCREF(Py_None); resultobj = Py_None;
25152 return resultobj;
25153 fail:
25154 return NULL;
25155 }
25156
25157
25158 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25159 PyObject *resultobj;
25160 wxWindow *arg1 = (wxWindow *) 0 ;
25161 int result;
25162 PyObject * obj0 = 0 ;
25163 char *kwnames[] = {
25164 (char *) "self", NULL
25165 };
25166
25167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25169 if (SWIG_arg_fail(1)) SWIG_fail;
25170 {
25171 PyThreadState* __tstate = wxPyBeginAllowThreads();
25172 result = (int)((wxWindow const *)arg1)->GetId();
25173
25174 wxPyEndAllowThreads(__tstate);
25175 if (PyErr_Occurred()) SWIG_fail;
25176 }
25177 {
25178 resultobj = SWIG_From_int((int)(result));
25179 }
25180 return resultobj;
25181 fail:
25182 return NULL;
25183 }
25184
25185
25186 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25187 PyObject *resultobj;
25188 int result;
25189 char *kwnames[] = {
25190 NULL
25191 };
25192
25193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25194 {
25195 PyThreadState* __tstate = wxPyBeginAllowThreads();
25196 result = (int)wxWindow::NewControlId();
25197
25198 wxPyEndAllowThreads(__tstate);
25199 if (PyErr_Occurred()) SWIG_fail;
25200 }
25201 {
25202 resultobj = SWIG_From_int((int)(result));
25203 }
25204 return resultobj;
25205 fail:
25206 return NULL;
25207 }
25208
25209
25210 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25211 PyObject *resultobj;
25212 int arg1 ;
25213 int result;
25214 PyObject * obj0 = 0 ;
25215 char *kwnames[] = {
25216 (char *) "winid", NULL
25217 };
25218
25219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25220 {
25221 arg1 = (int)(SWIG_As_int(obj0));
25222 if (SWIG_arg_fail(1)) SWIG_fail;
25223 }
25224 {
25225 PyThreadState* __tstate = wxPyBeginAllowThreads();
25226 result = (int)wxWindow::NextControlId(arg1);
25227
25228 wxPyEndAllowThreads(__tstate);
25229 if (PyErr_Occurred()) SWIG_fail;
25230 }
25231 {
25232 resultobj = SWIG_From_int((int)(result));
25233 }
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25241 PyObject *resultobj;
25242 int arg1 ;
25243 int result;
25244 PyObject * obj0 = 0 ;
25245 char *kwnames[] = {
25246 (char *) "winid", NULL
25247 };
25248
25249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25250 {
25251 arg1 = (int)(SWIG_As_int(obj0));
25252 if (SWIG_arg_fail(1)) SWIG_fail;
25253 }
25254 {
25255 PyThreadState* __tstate = wxPyBeginAllowThreads();
25256 result = (int)wxWindow::PrevControlId(arg1);
25257
25258 wxPyEndAllowThreads(__tstate);
25259 if (PyErr_Occurred()) SWIG_fail;
25260 }
25261 {
25262 resultobj = SWIG_From_int((int)(result));
25263 }
25264 return resultobj;
25265 fail:
25266 return NULL;
25267 }
25268
25269
25270 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25271 PyObject *resultobj;
25272 wxWindow *arg1 = (wxWindow *) 0 ;
25273 wxSize *arg2 = 0 ;
25274 wxSize temp2 ;
25275 PyObject * obj0 = 0 ;
25276 PyObject * obj1 = 0 ;
25277 char *kwnames[] = {
25278 (char *) "self",(char *) "size", NULL
25279 };
25280
25281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25283 if (SWIG_arg_fail(1)) SWIG_fail;
25284 {
25285 arg2 = &temp2;
25286 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25287 }
25288 {
25289 PyThreadState* __tstate = wxPyBeginAllowThreads();
25290 (arg1)->SetSize((wxSize const &)*arg2);
25291
25292 wxPyEndAllowThreads(__tstate);
25293 if (PyErr_Occurred()) SWIG_fail;
25294 }
25295 Py_INCREF(Py_None); resultobj = Py_None;
25296 return resultobj;
25297 fail:
25298 return NULL;
25299 }
25300
25301
25302 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25303 PyObject *resultobj;
25304 wxWindow *arg1 = (wxWindow *) 0 ;
25305 int arg2 ;
25306 int arg3 ;
25307 int arg4 ;
25308 int arg5 ;
25309 int arg6 = (int) wxSIZE_AUTO ;
25310 PyObject * obj0 = 0 ;
25311 PyObject * obj1 = 0 ;
25312 PyObject * obj2 = 0 ;
25313 PyObject * obj3 = 0 ;
25314 PyObject * obj4 = 0 ;
25315 PyObject * obj5 = 0 ;
25316 char *kwnames[] = {
25317 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25318 };
25319
25320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25322 if (SWIG_arg_fail(1)) SWIG_fail;
25323 {
25324 arg2 = (int)(SWIG_As_int(obj1));
25325 if (SWIG_arg_fail(2)) SWIG_fail;
25326 }
25327 {
25328 arg3 = (int)(SWIG_As_int(obj2));
25329 if (SWIG_arg_fail(3)) SWIG_fail;
25330 }
25331 {
25332 arg4 = (int)(SWIG_As_int(obj3));
25333 if (SWIG_arg_fail(4)) SWIG_fail;
25334 }
25335 {
25336 arg5 = (int)(SWIG_As_int(obj4));
25337 if (SWIG_arg_fail(5)) SWIG_fail;
25338 }
25339 if (obj5) {
25340 {
25341 arg6 = (int)(SWIG_As_int(obj5));
25342 if (SWIG_arg_fail(6)) SWIG_fail;
25343 }
25344 }
25345 {
25346 PyThreadState* __tstate = wxPyBeginAllowThreads();
25347 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25348
25349 wxPyEndAllowThreads(__tstate);
25350 if (PyErr_Occurred()) SWIG_fail;
25351 }
25352 Py_INCREF(Py_None); resultobj = Py_None;
25353 return resultobj;
25354 fail:
25355 return NULL;
25356 }
25357
25358
25359 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25360 PyObject *resultobj;
25361 wxWindow *arg1 = (wxWindow *) 0 ;
25362 wxRect *arg2 = 0 ;
25363 int arg3 = (int) wxSIZE_AUTO ;
25364 wxRect temp2 ;
25365 PyObject * obj0 = 0 ;
25366 PyObject * obj1 = 0 ;
25367 PyObject * obj2 = 0 ;
25368 char *kwnames[] = {
25369 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25370 };
25371
25372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25374 if (SWIG_arg_fail(1)) SWIG_fail;
25375 {
25376 arg2 = &temp2;
25377 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25378 }
25379 if (obj2) {
25380 {
25381 arg3 = (int)(SWIG_As_int(obj2));
25382 if (SWIG_arg_fail(3)) SWIG_fail;
25383 }
25384 }
25385 {
25386 PyThreadState* __tstate = wxPyBeginAllowThreads();
25387 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25388
25389 wxPyEndAllowThreads(__tstate);
25390 if (PyErr_Occurred()) SWIG_fail;
25391 }
25392 Py_INCREF(Py_None); resultobj = Py_None;
25393 return resultobj;
25394 fail:
25395 return NULL;
25396 }
25397
25398
25399 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25400 PyObject *resultobj;
25401 wxWindow *arg1 = (wxWindow *) 0 ;
25402 int arg2 ;
25403 int arg3 ;
25404 PyObject * obj0 = 0 ;
25405 PyObject * obj1 = 0 ;
25406 PyObject * obj2 = 0 ;
25407 char *kwnames[] = {
25408 (char *) "self",(char *) "width",(char *) "height", NULL
25409 };
25410
25411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25413 if (SWIG_arg_fail(1)) SWIG_fail;
25414 {
25415 arg2 = (int)(SWIG_As_int(obj1));
25416 if (SWIG_arg_fail(2)) SWIG_fail;
25417 }
25418 {
25419 arg3 = (int)(SWIG_As_int(obj2));
25420 if (SWIG_arg_fail(3)) SWIG_fail;
25421 }
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 (arg1)->SetSize(arg2,arg3);
25425
25426 wxPyEndAllowThreads(__tstate);
25427 if (PyErr_Occurred()) SWIG_fail;
25428 }
25429 Py_INCREF(Py_None); resultobj = Py_None;
25430 return resultobj;
25431 fail:
25432 return NULL;
25433 }
25434
25435
25436 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25437 PyObject *resultobj;
25438 wxWindow *arg1 = (wxWindow *) 0 ;
25439 wxPoint *arg2 = 0 ;
25440 int arg3 = (int) wxSIZE_USE_EXISTING ;
25441 wxPoint temp2 ;
25442 PyObject * obj0 = 0 ;
25443 PyObject * obj1 = 0 ;
25444 PyObject * obj2 = 0 ;
25445 char *kwnames[] = {
25446 (char *) "self",(char *) "pt",(char *) "flags", NULL
25447 };
25448
25449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25451 if (SWIG_arg_fail(1)) SWIG_fail;
25452 {
25453 arg2 = &temp2;
25454 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25455 }
25456 if (obj2) {
25457 {
25458 arg3 = (int)(SWIG_As_int(obj2));
25459 if (SWIG_arg_fail(3)) SWIG_fail;
25460 }
25461 }
25462 {
25463 PyThreadState* __tstate = wxPyBeginAllowThreads();
25464 (arg1)->Move((wxPoint const &)*arg2,arg3);
25465
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 Py_INCREF(Py_None); resultobj = Py_None;
25470 return resultobj;
25471 fail:
25472 return NULL;
25473 }
25474
25475
25476 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25477 PyObject *resultobj;
25478 wxWindow *arg1 = (wxWindow *) 0 ;
25479 int arg2 ;
25480 int arg3 ;
25481 int arg4 = (int) wxSIZE_USE_EXISTING ;
25482 PyObject * obj0 = 0 ;
25483 PyObject * obj1 = 0 ;
25484 PyObject * obj2 = 0 ;
25485 PyObject * obj3 = 0 ;
25486 char *kwnames[] = {
25487 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25488 };
25489
25490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25492 if (SWIG_arg_fail(1)) SWIG_fail;
25493 {
25494 arg2 = (int)(SWIG_As_int(obj1));
25495 if (SWIG_arg_fail(2)) SWIG_fail;
25496 }
25497 {
25498 arg3 = (int)(SWIG_As_int(obj2));
25499 if (SWIG_arg_fail(3)) SWIG_fail;
25500 }
25501 if (obj3) {
25502 {
25503 arg4 = (int)(SWIG_As_int(obj3));
25504 if (SWIG_arg_fail(4)) SWIG_fail;
25505 }
25506 }
25507 {
25508 PyThreadState* __tstate = wxPyBeginAllowThreads();
25509 (arg1)->Move(arg2,arg3,arg4);
25510
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 Py_INCREF(Py_None); resultobj = Py_None;
25515 return resultobj;
25516 fail:
25517 return NULL;
25518 }
25519
25520
25521 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25522 PyObject *resultobj;
25523 wxWindow *arg1 = (wxWindow *) 0 ;
25524 wxSize const &arg2_defvalue = wxDefaultSize ;
25525 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25526 wxSize temp2 ;
25527 PyObject * obj0 = 0 ;
25528 PyObject * obj1 = 0 ;
25529 char *kwnames[] = {
25530 (char *) "self",(char *) "size", NULL
25531 };
25532
25533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25535 if (SWIG_arg_fail(1)) SWIG_fail;
25536 if (obj1) {
25537 {
25538 arg2 = &temp2;
25539 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25540 }
25541 }
25542 {
25543 PyThreadState* __tstate = wxPyBeginAllowThreads();
25544 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25545
25546 wxPyEndAllowThreads(__tstate);
25547 if (PyErr_Occurred()) SWIG_fail;
25548 }
25549 Py_INCREF(Py_None); resultobj = Py_None;
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25557 PyObject *resultobj;
25558 wxWindow *arg1 = (wxWindow *) 0 ;
25559 PyObject * obj0 = 0 ;
25560 char *kwnames[] = {
25561 (char *) "self", NULL
25562 };
25563
25564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25566 if (SWIG_arg_fail(1)) SWIG_fail;
25567 {
25568 PyThreadState* __tstate = wxPyBeginAllowThreads();
25569 (arg1)->Raise();
25570
25571 wxPyEndAllowThreads(__tstate);
25572 if (PyErr_Occurred()) SWIG_fail;
25573 }
25574 Py_INCREF(Py_None); resultobj = Py_None;
25575 return resultobj;
25576 fail:
25577 return NULL;
25578 }
25579
25580
25581 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25582 PyObject *resultobj;
25583 wxWindow *arg1 = (wxWindow *) 0 ;
25584 PyObject * obj0 = 0 ;
25585 char *kwnames[] = {
25586 (char *) "self", NULL
25587 };
25588
25589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",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 (arg1)->Lower();
25595
25596 wxPyEndAllowThreads(__tstate);
25597 if (PyErr_Occurred()) SWIG_fail;
25598 }
25599 Py_INCREF(Py_None); resultobj = Py_None;
25600 return resultobj;
25601 fail:
25602 return NULL;
25603 }
25604
25605
25606 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25607 PyObject *resultobj;
25608 wxWindow *arg1 = (wxWindow *) 0 ;
25609 wxSize *arg2 = 0 ;
25610 wxSize temp2 ;
25611 PyObject * obj0 = 0 ;
25612 PyObject * obj1 = 0 ;
25613 char *kwnames[] = {
25614 (char *) "self",(char *) "size", NULL
25615 };
25616
25617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25619 if (SWIG_arg_fail(1)) SWIG_fail;
25620 {
25621 arg2 = &temp2;
25622 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25623 }
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 (arg1)->SetClientSize((wxSize const &)*arg2);
25627
25628 wxPyEndAllowThreads(__tstate);
25629 if (PyErr_Occurred()) SWIG_fail;
25630 }
25631 Py_INCREF(Py_None); resultobj = Py_None;
25632 return resultobj;
25633 fail:
25634 return NULL;
25635 }
25636
25637
25638 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25639 PyObject *resultobj;
25640 wxWindow *arg1 = (wxWindow *) 0 ;
25641 int arg2 ;
25642 int arg3 ;
25643 PyObject * obj0 = 0 ;
25644 PyObject * obj1 = 0 ;
25645 PyObject * obj2 = 0 ;
25646 char *kwnames[] = {
25647 (char *) "self",(char *) "width",(char *) "height", NULL
25648 };
25649
25650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25652 if (SWIG_arg_fail(1)) SWIG_fail;
25653 {
25654 arg2 = (int)(SWIG_As_int(obj1));
25655 if (SWIG_arg_fail(2)) SWIG_fail;
25656 }
25657 {
25658 arg3 = (int)(SWIG_As_int(obj2));
25659 if (SWIG_arg_fail(3)) SWIG_fail;
25660 }
25661 {
25662 PyThreadState* __tstate = wxPyBeginAllowThreads();
25663 (arg1)->SetClientSize(arg2,arg3);
25664
25665 wxPyEndAllowThreads(__tstate);
25666 if (PyErr_Occurred()) SWIG_fail;
25667 }
25668 Py_INCREF(Py_None); resultobj = Py_None;
25669 return resultobj;
25670 fail:
25671 return NULL;
25672 }
25673
25674
25675 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25676 PyObject *resultobj;
25677 wxWindow *arg1 = (wxWindow *) 0 ;
25678 wxRect *arg2 = 0 ;
25679 wxRect temp2 ;
25680 PyObject * obj0 = 0 ;
25681 PyObject * obj1 = 0 ;
25682 char *kwnames[] = {
25683 (char *) "self",(char *) "rect", NULL
25684 };
25685
25686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25688 if (SWIG_arg_fail(1)) SWIG_fail;
25689 {
25690 arg2 = &temp2;
25691 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25692 }
25693 {
25694 PyThreadState* __tstate = wxPyBeginAllowThreads();
25695 (arg1)->SetClientSize((wxRect const &)*arg2);
25696
25697 wxPyEndAllowThreads(__tstate);
25698 if (PyErr_Occurred()) SWIG_fail;
25699 }
25700 Py_INCREF(Py_None); resultobj = Py_None;
25701 return resultobj;
25702 fail:
25703 return NULL;
25704 }
25705
25706
25707 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25708 PyObject *resultobj;
25709 wxWindow *arg1 = (wxWindow *) 0 ;
25710 wxPoint result;
25711 PyObject * obj0 = 0 ;
25712 char *kwnames[] = {
25713 (char *) "self", NULL
25714 };
25715
25716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",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 result = (arg1)->GetPosition();
25722
25723 wxPyEndAllowThreads(__tstate);
25724 if (PyErr_Occurred()) SWIG_fail;
25725 }
25726 {
25727 wxPoint * resultptr;
25728 resultptr = new wxPoint((wxPoint &)(result));
25729 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25730 }
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25738 PyObject *resultobj;
25739 wxWindow *arg1 = (wxWindow *) 0 ;
25740 int *arg2 = (int *) 0 ;
25741 int *arg3 = (int *) 0 ;
25742 int temp2 ;
25743 int res2 = 0 ;
25744 int temp3 ;
25745 int res3 = 0 ;
25746 PyObject * obj0 = 0 ;
25747 char *kwnames[] = {
25748 (char *) "self", NULL
25749 };
25750
25751 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25752 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25755 if (SWIG_arg_fail(1)) SWIG_fail;
25756 {
25757 PyThreadState* __tstate = wxPyBeginAllowThreads();
25758 (arg1)->GetPosition(arg2,arg3);
25759
25760 wxPyEndAllowThreads(__tstate);
25761 if (PyErr_Occurred()) SWIG_fail;
25762 }
25763 Py_INCREF(Py_None); resultobj = Py_None;
25764 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25765 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25766 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25767 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25768 return resultobj;
25769 fail:
25770 return NULL;
25771 }
25772
25773
25774 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25775 PyObject *resultobj;
25776 wxWindow *arg1 = (wxWindow *) 0 ;
25777 wxSize result;
25778 PyObject * obj0 = 0 ;
25779 char *kwnames[] = {
25780 (char *) "self", NULL
25781 };
25782
25783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25785 if (SWIG_arg_fail(1)) SWIG_fail;
25786 {
25787 PyThreadState* __tstate = wxPyBeginAllowThreads();
25788 result = ((wxWindow const *)arg1)->GetSize();
25789
25790 wxPyEndAllowThreads(__tstate);
25791 if (PyErr_Occurred()) SWIG_fail;
25792 }
25793 {
25794 wxSize * resultptr;
25795 resultptr = new wxSize((wxSize &)(result));
25796 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25797 }
25798 return resultobj;
25799 fail:
25800 return NULL;
25801 }
25802
25803
25804 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25805 PyObject *resultobj;
25806 wxWindow *arg1 = (wxWindow *) 0 ;
25807 int *arg2 = (int *) 0 ;
25808 int *arg3 = (int *) 0 ;
25809 int temp2 ;
25810 int res2 = 0 ;
25811 int temp3 ;
25812 int res3 = 0 ;
25813 PyObject * obj0 = 0 ;
25814 char *kwnames[] = {
25815 (char *) "self", NULL
25816 };
25817
25818 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25819 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25822 if (SWIG_arg_fail(1)) SWIG_fail;
25823 {
25824 PyThreadState* __tstate = wxPyBeginAllowThreads();
25825 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25826
25827 wxPyEndAllowThreads(__tstate);
25828 if (PyErr_Occurred()) SWIG_fail;
25829 }
25830 Py_INCREF(Py_None); resultobj = Py_None;
25831 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25832 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25833 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25834 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25835 return resultobj;
25836 fail:
25837 return NULL;
25838 }
25839
25840
25841 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25842 PyObject *resultobj;
25843 wxWindow *arg1 = (wxWindow *) 0 ;
25844 wxRect result;
25845 PyObject * obj0 = 0 ;
25846 char *kwnames[] = {
25847 (char *) "self", NULL
25848 };
25849
25850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25852 if (SWIG_arg_fail(1)) SWIG_fail;
25853 {
25854 PyThreadState* __tstate = wxPyBeginAllowThreads();
25855 result = ((wxWindow const *)arg1)->GetRect();
25856
25857 wxPyEndAllowThreads(__tstate);
25858 if (PyErr_Occurred()) SWIG_fail;
25859 }
25860 {
25861 wxRect * resultptr;
25862 resultptr = new wxRect((wxRect &)(result));
25863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25864 }
25865 return resultobj;
25866 fail:
25867 return NULL;
25868 }
25869
25870
25871 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25872 PyObject *resultobj;
25873 wxWindow *arg1 = (wxWindow *) 0 ;
25874 wxSize result;
25875 PyObject * obj0 = 0 ;
25876 char *kwnames[] = {
25877 (char *) "self", NULL
25878 };
25879
25880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25882 if (SWIG_arg_fail(1)) SWIG_fail;
25883 {
25884 PyThreadState* __tstate = wxPyBeginAllowThreads();
25885 result = ((wxWindow const *)arg1)->GetClientSize();
25886
25887 wxPyEndAllowThreads(__tstate);
25888 if (PyErr_Occurred()) SWIG_fail;
25889 }
25890 {
25891 wxSize * resultptr;
25892 resultptr = new wxSize((wxSize &)(result));
25893 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25894 }
25895 return resultobj;
25896 fail:
25897 return NULL;
25898 }
25899
25900
25901 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25902 PyObject *resultobj;
25903 wxWindow *arg1 = (wxWindow *) 0 ;
25904 int *arg2 = (int *) 0 ;
25905 int *arg3 = (int *) 0 ;
25906 int temp2 ;
25907 int res2 = 0 ;
25908 int temp3 ;
25909 int res3 = 0 ;
25910 PyObject * obj0 = 0 ;
25911 char *kwnames[] = {
25912 (char *) "self", NULL
25913 };
25914
25915 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25916 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25919 if (SWIG_arg_fail(1)) SWIG_fail;
25920 {
25921 PyThreadState* __tstate = wxPyBeginAllowThreads();
25922 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25923
25924 wxPyEndAllowThreads(__tstate);
25925 if (PyErr_Occurred()) SWIG_fail;
25926 }
25927 Py_INCREF(Py_None); resultobj = Py_None;
25928 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25929 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25930 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25931 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25932 return resultobj;
25933 fail:
25934 return NULL;
25935 }
25936
25937
25938 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25939 PyObject *resultobj;
25940 wxWindow *arg1 = (wxWindow *) 0 ;
25941 wxPoint result;
25942 PyObject * obj0 = 0 ;
25943 char *kwnames[] = {
25944 (char *) "self", NULL
25945 };
25946
25947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25949 if (SWIG_arg_fail(1)) SWIG_fail;
25950 {
25951 PyThreadState* __tstate = wxPyBeginAllowThreads();
25952 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25953
25954 wxPyEndAllowThreads(__tstate);
25955 if (PyErr_Occurred()) SWIG_fail;
25956 }
25957 {
25958 wxPoint * resultptr;
25959 resultptr = new wxPoint((wxPoint &)(result));
25960 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25961 }
25962 return resultobj;
25963 fail:
25964 return NULL;
25965 }
25966
25967
25968 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25969 PyObject *resultobj;
25970 wxWindow *arg1 = (wxWindow *) 0 ;
25971 wxRect result;
25972 PyObject * obj0 = 0 ;
25973 char *kwnames[] = {
25974 (char *) "self", NULL
25975 };
25976
25977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25979 if (SWIG_arg_fail(1)) SWIG_fail;
25980 {
25981 PyThreadState* __tstate = wxPyBeginAllowThreads();
25982 result = ((wxWindow const *)arg1)->GetClientRect();
25983
25984 wxPyEndAllowThreads(__tstate);
25985 if (PyErr_Occurred()) SWIG_fail;
25986 }
25987 {
25988 wxRect * resultptr;
25989 resultptr = new wxRect((wxRect &)(result));
25990 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25991 }
25992 return resultobj;
25993 fail:
25994 return NULL;
25995 }
25996
25997
25998 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25999 PyObject *resultobj;
26000 wxWindow *arg1 = (wxWindow *) 0 ;
26001 wxSize result;
26002 PyObject * obj0 = 0 ;
26003 char *kwnames[] = {
26004 (char *) "self", NULL
26005 };
26006
26007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26009 if (SWIG_arg_fail(1)) SWIG_fail;
26010 {
26011 PyThreadState* __tstate = wxPyBeginAllowThreads();
26012 result = ((wxWindow const *)arg1)->GetBestSize();
26013
26014 wxPyEndAllowThreads(__tstate);
26015 if (PyErr_Occurred()) SWIG_fail;
26016 }
26017 {
26018 wxSize * resultptr;
26019 resultptr = new wxSize((wxSize &)(result));
26020 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26021 }
26022 return resultobj;
26023 fail:
26024 return NULL;
26025 }
26026
26027
26028 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26029 PyObject *resultobj;
26030 wxWindow *arg1 = (wxWindow *) 0 ;
26031 int *arg2 = (int *) 0 ;
26032 int *arg3 = (int *) 0 ;
26033 int temp2 ;
26034 int res2 = 0 ;
26035 int temp3 ;
26036 int res3 = 0 ;
26037 PyObject * obj0 = 0 ;
26038 char *kwnames[] = {
26039 (char *) "self", NULL
26040 };
26041
26042 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26043 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26046 if (SWIG_arg_fail(1)) SWIG_fail;
26047 {
26048 PyThreadState* __tstate = wxPyBeginAllowThreads();
26049 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26050
26051 wxPyEndAllowThreads(__tstate);
26052 if (PyErr_Occurred()) SWIG_fail;
26053 }
26054 Py_INCREF(Py_None); resultobj = Py_None;
26055 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26056 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26057 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26058 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26059 return resultobj;
26060 fail:
26061 return NULL;
26062 }
26063
26064
26065 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26066 PyObject *resultobj;
26067 wxWindow *arg1 = (wxWindow *) 0 ;
26068 PyObject * obj0 = 0 ;
26069 char *kwnames[] = {
26070 (char *) "self", NULL
26071 };
26072
26073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26075 if (SWIG_arg_fail(1)) SWIG_fail;
26076 {
26077 PyThreadState* __tstate = wxPyBeginAllowThreads();
26078 (arg1)->InvalidateBestSize();
26079
26080 wxPyEndAllowThreads(__tstate);
26081 if (PyErr_Occurred()) SWIG_fail;
26082 }
26083 Py_INCREF(Py_None); resultobj = Py_None;
26084 return resultobj;
26085 fail:
26086 return NULL;
26087 }
26088
26089
26090 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26091 PyObject *resultobj;
26092 wxWindow *arg1 = (wxWindow *) 0 ;
26093 wxSize result;
26094 PyObject * obj0 = 0 ;
26095 char *kwnames[] = {
26096 (char *) "self", NULL
26097 };
26098
26099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26101 if (SWIG_arg_fail(1)) SWIG_fail;
26102 {
26103 PyThreadState* __tstate = wxPyBeginAllowThreads();
26104 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26105
26106 wxPyEndAllowThreads(__tstate);
26107 if (PyErr_Occurred()) SWIG_fail;
26108 }
26109 {
26110 wxSize * resultptr;
26111 resultptr = new wxSize((wxSize &)(result));
26112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26113 }
26114 return resultobj;
26115 fail:
26116 return NULL;
26117 }
26118
26119
26120 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26121 PyObject *resultobj;
26122 wxWindow *arg1 = (wxWindow *) 0 ;
26123 wxSize result;
26124 PyObject * obj0 = 0 ;
26125 char *kwnames[] = {
26126 (char *) "self", NULL
26127 };
26128
26129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26131 if (SWIG_arg_fail(1)) SWIG_fail;
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26135
26136 wxPyEndAllowThreads(__tstate);
26137 if (PyErr_Occurred()) SWIG_fail;
26138 }
26139 {
26140 wxSize * resultptr;
26141 resultptr = new wxSize((wxSize &)(result));
26142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26143 }
26144 return resultobj;
26145 fail:
26146 return NULL;
26147 }
26148
26149
26150 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26151 PyObject *resultobj;
26152 wxWindow *arg1 = (wxWindow *) 0 ;
26153 int arg2 = (int) wxBOTH ;
26154 PyObject * obj0 = 0 ;
26155 PyObject * obj1 = 0 ;
26156 char *kwnames[] = {
26157 (char *) "self",(char *) "direction", NULL
26158 };
26159
26160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) 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 if (obj1) {
26164 {
26165 arg2 = (int)(SWIG_As_int(obj1));
26166 if (SWIG_arg_fail(2)) SWIG_fail;
26167 }
26168 }
26169 {
26170 PyThreadState* __tstate = wxPyBeginAllowThreads();
26171 (arg1)->Center(arg2);
26172
26173 wxPyEndAllowThreads(__tstate);
26174 if (PyErr_Occurred()) SWIG_fail;
26175 }
26176 Py_INCREF(Py_None); resultobj = Py_None;
26177 return resultobj;
26178 fail:
26179 return NULL;
26180 }
26181
26182
26183 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26184 PyObject *resultobj;
26185 wxWindow *arg1 = (wxWindow *) 0 ;
26186 int arg2 = (int) wxBOTH ;
26187 PyObject * obj0 = 0 ;
26188 PyObject * obj1 = 0 ;
26189 char *kwnames[] = {
26190 (char *) "self",(char *) "dir", NULL
26191 };
26192
26193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26195 if (SWIG_arg_fail(1)) SWIG_fail;
26196 if (obj1) {
26197 {
26198 arg2 = (int)(SWIG_As_int(obj1));
26199 if (SWIG_arg_fail(2)) SWIG_fail;
26200 }
26201 }
26202 {
26203 PyThreadState* __tstate = wxPyBeginAllowThreads();
26204 (arg1)->CenterOnScreen(arg2);
26205
26206 wxPyEndAllowThreads(__tstate);
26207 if (PyErr_Occurred()) SWIG_fail;
26208 }
26209 Py_INCREF(Py_None); resultobj = Py_None;
26210 return resultobj;
26211 fail:
26212 return NULL;
26213 }
26214
26215
26216 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26217 PyObject *resultobj;
26218 wxWindow *arg1 = (wxWindow *) 0 ;
26219 int arg2 = (int) wxBOTH ;
26220 PyObject * obj0 = 0 ;
26221 PyObject * obj1 = 0 ;
26222 char *kwnames[] = {
26223 (char *) "self",(char *) "dir", NULL
26224 };
26225
26226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) 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 if (obj1) {
26230 {
26231 arg2 = (int)(SWIG_As_int(obj1));
26232 if (SWIG_arg_fail(2)) SWIG_fail;
26233 }
26234 }
26235 {
26236 PyThreadState* __tstate = wxPyBeginAllowThreads();
26237 (arg1)->CenterOnParent(arg2);
26238
26239 wxPyEndAllowThreads(__tstate);
26240 if (PyErr_Occurred()) SWIG_fail;
26241 }
26242 Py_INCREF(Py_None); resultobj = Py_None;
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj;
26251 wxWindow *arg1 = (wxWindow *) 0 ;
26252 PyObject * obj0 = 0 ;
26253 char *kwnames[] = {
26254 (char *) "self", NULL
26255 };
26256
26257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26259 if (SWIG_arg_fail(1)) SWIG_fail;
26260 {
26261 PyThreadState* __tstate = wxPyBeginAllowThreads();
26262 (arg1)->Fit();
26263
26264 wxPyEndAllowThreads(__tstate);
26265 if (PyErr_Occurred()) SWIG_fail;
26266 }
26267 Py_INCREF(Py_None); resultobj = Py_None;
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26275 PyObject *resultobj;
26276 wxWindow *arg1 = (wxWindow *) 0 ;
26277 PyObject * obj0 = 0 ;
26278 char *kwnames[] = {
26279 (char *) "self", NULL
26280 };
26281
26282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26284 if (SWIG_arg_fail(1)) SWIG_fail;
26285 {
26286 PyThreadState* __tstate = wxPyBeginAllowThreads();
26287 (arg1)->FitInside();
26288
26289 wxPyEndAllowThreads(__tstate);
26290 if (PyErr_Occurred()) SWIG_fail;
26291 }
26292 Py_INCREF(Py_None); resultobj = Py_None;
26293 return resultobj;
26294 fail:
26295 return NULL;
26296 }
26297
26298
26299 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26300 PyObject *resultobj;
26301 wxWindow *arg1 = (wxWindow *) 0 ;
26302 int arg2 ;
26303 int arg3 ;
26304 int arg4 = (int) -1 ;
26305 int arg5 = (int) -1 ;
26306 int arg6 = (int) -1 ;
26307 int arg7 = (int) -1 ;
26308 PyObject * obj0 = 0 ;
26309 PyObject * obj1 = 0 ;
26310 PyObject * obj2 = 0 ;
26311 PyObject * obj3 = 0 ;
26312 PyObject * obj4 = 0 ;
26313 PyObject * obj5 = 0 ;
26314 PyObject * obj6 = 0 ;
26315 char *kwnames[] = {
26316 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26317 };
26318
26319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26321 if (SWIG_arg_fail(1)) SWIG_fail;
26322 {
26323 arg2 = (int)(SWIG_As_int(obj1));
26324 if (SWIG_arg_fail(2)) SWIG_fail;
26325 }
26326 {
26327 arg3 = (int)(SWIG_As_int(obj2));
26328 if (SWIG_arg_fail(3)) SWIG_fail;
26329 }
26330 if (obj3) {
26331 {
26332 arg4 = (int)(SWIG_As_int(obj3));
26333 if (SWIG_arg_fail(4)) SWIG_fail;
26334 }
26335 }
26336 if (obj4) {
26337 {
26338 arg5 = (int)(SWIG_As_int(obj4));
26339 if (SWIG_arg_fail(5)) SWIG_fail;
26340 }
26341 }
26342 if (obj5) {
26343 {
26344 arg6 = (int)(SWIG_As_int(obj5));
26345 if (SWIG_arg_fail(6)) SWIG_fail;
26346 }
26347 }
26348 if (obj6) {
26349 {
26350 arg7 = (int)(SWIG_As_int(obj6));
26351 if (SWIG_arg_fail(7)) SWIG_fail;
26352 }
26353 }
26354 {
26355 PyThreadState* __tstate = wxPyBeginAllowThreads();
26356 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26357
26358 wxPyEndAllowThreads(__tstate);
26359 if (PyErr_Occurred()) SWIG_fail;
26360 }
26361 Py_INCREF(Py_None); resultobj = Py_None;
26362 return resultobj;
26363 fail:
26364 return NULL;
26365 }
26366
26367
26368 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26369 PyObject *resultobj;
26370 wxWindow *arg1 = (wxWindow *) 0 ;
26371 wxSize *arg2 = 0 ;
26372 wxSize const &arg3_defvalue = wxDefaultSize ;
26373 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26374 wxSize const &arg4_defvalue = wxDefaultSize ;
26375 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26376 wxSize temp2 ;
26377 wxSize temp3 ;
26378 wxSize temp4 ;
26379 PyObject * obj0 = 0 ;
26380 PyObject * obj1 = 0 ;
26381 PyObject * obj2 = 0 ;
26382 PyObject * obj3 = 0 ;
26383 char *kwnames[] = {
26384 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26385 };
26386
26387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26389 if (SWIG_arg_fail(1)) SWIG_fail;
26390 {
26391 arg2 = &temp2;
26392 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26393 }
26394 if (obj2) {
26395 {
26396 arg3 = &temp3;
26397 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26398 }
26399 }
26400 if (obj3) {
26401 {
26402 arg4 = &temp4;
26403 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26404 }
26405 }
26406 {
26407 PyThreadState* __tstate = wxPyBeginAllowThreads();
26408 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26409
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 Py_INCREF(Py_None); resultobj = Py_None;
26414 return resultobj;
26415 fail:
26416 return NULL;
26417 }
26418
26419
26420 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26421 PyObject *resultobj;
26422 wxWindow *arg1 = (wxWindow *) 0 ;
26423 int arg2 ;
26424 int arg3 ;
26425 int arg4 = (int) -1 ;
26426 int arg5 = (int) -1 ;
26427 PyObject * obj0 = 0 ;
26428 PyObject * obj1 = 0 ;
26429 PyObject * obj2 = 0 ;
26430 PyObject * obj3 = 0 ;
26431 PyObject * obj4 = 0 ;
26432 char *kwnames[] = {
26433 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26434 };
26435
26436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26438 if (SWIG_arg_fail(1)) SWIG_fail;
26439 {
26440 arg2 = (int)(SWIG_As_int(obj1));
26441 if (SWIG_arg_fail(2)) SWIG_fail;
26442 }
26443 {
26444 arg3 = (int)(SWIG_As_int(obj2));
26445 if (SWIG_arg_fail(3)) SWIG_fail;
26446 }
26447 if (obj3) {
26448 {
26449 arg4 = (int)(SWIG_As_int(obj3));
26450 if (SWIG_arg_fail(4)) SWIG_fail;
26451 }
26452 }
26453 if (obj4) {
26454 {
26455 arg5 = (int)(SWIG_As_int(obj4));
26456 if (SWIG_arg_fail(5)) SWIG_fail;
26457 }
26458 }
26459 {
26460 PyThreadState* __tstate = wxPyBeginAllowThreads();
26461 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26462
26463 wxPyEndAllowThreads(__tstate);
26464 if (PyErr_Occurred()) SWIG_fail;
26465 }
26466 Py_INCREF(Py_None); resultobj = Py_None;
26467 return resultobj;
26468 fail:
26469 return NULL;
26470 }
26471
26472
26473 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26474 PyObject *resultobj;
26475 wxWindow *arg1 = (wxWindow *) 0 ;
26476 wxSize *arg2 = 0 ;
26477 wxSize const &arg3_defvalue = wxDefaultSize ;
26478 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26479 wxSize temp2 ;
26480 wxSize temp3 ;
26481 PyObject * obj0 = 0 ;
26482 PyObject * obj1 = 0 ;
26483 PyObject * obj2 = 0 ;
26484 char *kwnames[] = {
26485 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26486 };
26487
26488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26490 if (SWIG_arg_fail(1)) SWIG_fail;
26491 {
26492 arg2 = &temp2;
26493 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26494 }
26495 if (obj2) {
26496 {
26497 arg3 = &temp3;
26498 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26499 }
26500 }
26501 {
26502 PyThreadState* __tstate = wxPyBeginAllowThreads();
26503 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26504
26505 wxPyEndAllowThreads(__tstate);
26506 if (PyErr_Occurred()) SWIG_fail;
26507 }
26508 Py_INCREF(Py_None); resultobj = Py_None;
26509 return resultobj;
26510 fail:
26511 return NULL;
26512 }
26513
26514
26515 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26516 PyObject *resultobj;
26517 wxWindow *arg1 = (wxWindow *) 0 ;
26518 wxSize result;
26519 PyObject * obj0 = 0 ;
26520 char *kwnames[] = {
26521 (char *) "self", NULL
26522 };
26523
26524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26526 if (SWIG_arg_fail(1)) SWIG_fail;
26527 {
26528 PyThreadState* __tstate = wxPyBeginAllowThreads();
26529 result = ((wxWindow const *)arg1)->GetMaxSize();
26530
26531 wxPyEndAllowThreads(__tstate);
26532 if (PyErr_Occurred()) SWIG_fail;
26533 }
26534 {
26535 wxSize * resultptr;
26536 resultptr = new wxSize((wxSize &)(result));
26537 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26538 }
26539 return resultobj;
26540 fail:
26541 return NULL;
26542 }
26543
26544
26545 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26546 PyObject *resultobj;
26547 wxWindow *arg1 = (wxWindow *) 0 ;
26548 wxSize result;
26549 PyObject * obj0 = 0 ;
26550 char *kwnames[] = {
26551 (char *) "self", NULL
26552 };
26553
26554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26556 if (SWIG_arg_fail(1)) SWIG_fail;
26557 {
26558 PyThreadState* __tstate = wxPyBeginAllowThreads();
26559 result = ((wxWindow const *)arg1)->GetMinSize();
26560
26561 wxPyEndAllowThreads(__tstate);
26562 if (PyErr_Occurred()) SWIG_fail;
26563 }
26564 {
26565 wxSize * resultptr;
26566 resultptr = new wxSize((wxSize &)(result));
26567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26568 }
26569 return resultobj;
26570 fail:
26571 return NULL;
26572 }
26573
26574
26575 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26576 PyObject *resultobj;
26577 wxWindow *arg1 = (wxWindow *) 0 ;
26578 wxSize *arg2 = 0 ;
26579 wxSize temp2 ;
26580 PyObject * obj0 = 0 ;
26581 PyObject * obj1 = 0 ;
26582 char *kwnames[] = {
26583 (char *) "self",(char *) "minSize", NULL
26584 };
26585
26586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26588 if (SWIG_arg_fail(1)) SWIG_fail;
26589 {
26590 arg2 = &temp2;
26591 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26592 }
26593 {
26594 PyThreadState* __tstate = wxPyBeginAllowThreads();
26595 (arg1)->SetMinSize((wxSize const &)*arg2);
26596
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 Py_INCREF(Py_None); resultobj = Py_None;
26601 return resultobj;
26602 fail:
26603 return NULL;
26604 }
26605
26606
26607 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26608 PyObject *resultobj;
26609 wxWindow *arg1 = (wxWindow *) 0 ;
26610 wxSize *arg2 = 0 ;
26611 wxSize temp2 ;
26612 PyObject * obj0 = 0 ;
26613 PyObject * obj1 = 0 ;
26614 char *kwnames[] = {
26615 (char *) "self",(char *) "maxSize", NULL
26616 };
26617
26618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26620 if (SWIG_arg_fail(1)) SWIG_fail;
26621 {
26622 arg2 = &temp2;
26623 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26624 }
26625 {
26626 PyThreadState* __tstate = wxPyBeginAllowThreads();
26627 (arg1)->SetMaxSize((wxSize const &)*arg2);
26628
26629 wxPyEndAllowThreads(__tstate);
26630 if (PyErr_Occurred()) SWIG_fail;
26631 }
26632 Py_INCREF(Py_None); resultobj = Py_None;
26633 return resultobj;
26634 fail:
26635 return NULL;
26636 }
26637
26638
26639 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26640 PyObject *resultobj;
26641 wxWindow *arg1 = (wxWindow *) 0 ;
26642 int result;
26643 PyObject * obj0 = 0 ;
26644 char *kwnames[] = {
26645 (char *) "self", NULL
26646 };
26647
26648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26650 if (SWIG_arg_fail(1)) SWIG_fail;
26651 {
26652 PyThreadState* __tstate = wxPyBeginAllowThreads();
26653 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26654
26655 wxPyEndAllowThreads(__tstate);
26656 if (PyErr_Occurred()) SWIG_fail;
26657 }
26658 {
26659 resultobj = SWIG_From_int((int)(result));
26660 }
26661 return resultobj;
26662 fail:
26663 return NULL;
26664 }
26665
26666
26667 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26668 PyObject *resultobj;
26669 wxWindow *arg1 = (wxWindow *) 0 ;
26670 int result;
26671 PyObject * obj0 = 0 ;
26672 char *kwnames[] = {
26673 (char *) "self", NULL
26674 };
26675
26676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26678 if (SWIG_arg_fail(1)) SWIG_fail;
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26682
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 {
26687 resultobj = SWIG_From_int((int)(result));
26688 }
26689 return resultobj;
26690 fail:
26691 return NULL;
26692 }
26693
26694
26695 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26696 PyObject *resultobj;
26697 wxWindow *arg1 = (wxWindow *) 0 ;
26698 int result;
26699 PyObject * obj0 = 0 ;
26700 char *kwnames[] = {
26701 (char *) "self", NULL
26702 };
26703
26704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26706 if (SWIG_arg_fail(1)) SWIG_fail;
26707 {
26708 PyThreadState* __tstate = wxPyBeginAllowThreads();
26709 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26710
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 {
26715 resultobj = SWIG_From_int((int)(result));
26716 }
26717 return resultobj;
26718 fail:
26719 return NULL;
26720 }
26721
26722
26723 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26724 PyObject *resultobj;
26725 wxWindow *arg1 = (wxWindow *) 0 ;
26726 int result;
26727 PyObject * obj0 = 0 ;
26728 char *kwnames[] = {
26729 (char *) "self", NULL
26730 };
26731
26732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26734 if (SWIG_arg_fail(1)) SWIG_fail;
26735 {
26736 PyThreadState* __tstate = wxPyBeginAllowThreads();
26737 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26738
26739 wxPyEndAllowThreads(__tstate);
26740 if (PyErr_Occurred()) SWIG_fail;
26741 }
26742 {
26743 resultobj = SWIG_From_int((int)(result));
26744 }
26745 return resultobj;
26746 fail:
26747 return NULL;
26748 }
26749
26750
26751 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26752 PyObject *resultobj;
26753 wxWindow *arg1 = (wxWindow *) 0 ;
26754 wxSize *arg2 = 0 ;
26755 wxSize temp2 ;
26756 PyObject * obj0 = 0 ;
26757 PyObject * obj1 = 0 ;
26758 char *kwnames[] = {
26759 (char *) "self",(char *) "size", NULL
26760 };
26761
26762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26764 if (SWIG_arg_fail(1)) SWIG_fail;
26765 {
26766 arg2 = &temp2;
26767 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26768 }
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26772
26773 wxPyEndAllowThreads(__tstate);
26774 if (PyErr_Occurred()) SWIG_fail;
26775 }
26776 Py_INCREF(Py_None); resultobj = Py_None;
26777 return resultobj;
26778 fail:
26779 return NULL;
26780 }
26781
26782
26783 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26784 PyObject *resultobj;
26785 wxWindow *arg1 = (wxWindow *) 0 ;
26786 int arg2 ;
26787 int arg3 ;
26788 PyObject * obj0 = 0 ;
26789 PyObject * obj1 = 0 ;
26790 PyObject * obj2 = 0 ;
26791 char *kwnames[] = {
26792 (char *) "self",(char *) "w",(char *) "h", NULL
26793 };
26794
26795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26797 if (SWIG_arg_fail(1)) SWIG_fail;
26798 {
26799 arg2 = (int)(SWIG_As_int(obj1));
26800 if (SWIG_arg_fail(2)) SWIG_fail;
26801 }
26802 {
26803 arg3 = (int)(SWIG_As_int(obj2));
26804 if (SWIG_arg_fail(3)) SWIG_fail;
26805 }
26806 {
26807 PyThreadState* __tstate = wxPyBeginAllowThreads();
26808 (arg1)->SetVirtualSize(arg2,arg3);
26809
26810 wxPyEndAllowThreads(__tstate);
26811 if (PyErr_Occurred()) SWIG_fail;
26812 }
26813 Py_INCREF(Py_None); resultobj = Py_None;
26814 return resultobj;
26815 fail:
26816 return NULL;
26817 }
26818
26819
26820 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26821 PyObject *resultobj;
26822 wxWindow *arg1 = (wxWindow *) 0 ;
26823 wxSize result;
26824 PyObject * obj0 = 0 ;
26825 char *kwnames[] = {
26826 (char *) "self", NULL
26827 };
26828
26829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26831 if (SWIG_arg_fail(1)) SWIG_fail;
26832 {
26833 PyThreadState* __tstate = wxPyBeginAllowThreads();
26834 result = ((wxWindow const *)arg1)->GetVirtualSize();
26835
26836 wxPyEndAllowThreads(__tstate);
26837 if (PyErr_Occurred()) SWIG_fail;
26838 }
26839 {
26840 wxSize * resultptr;
26841 resultptr = new wxSize((wxSize &)(result));
26842 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26843 }
26844 return resultobj;
26845 fail:
26846 return NULL;
26847 }
26848
26849
26850 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26851 PyObject *resultobj;
26852 wxWindow *arg1 = (wxWindow *) 0 ;
26853 int *arg2 = (int *) 0 ;
26854 int *arg3 = (int *) 0 ;
26855 int temp2 ;
26856 int res2 = 0 ;
26857 int temp3 ;
26858 int res3 = 0 ;
26859 PyObject * obj0 = 0 ;
26860 char *kwnames[] = {
26861 (char *) "self", NULL
26862 };
26863
26864 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26865 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26868 if (SWIG_arg_fail(1)) SWIG_fail;
26869 {
26870 PyThreadState* __tstate = wxPyBeginAllowThreads();
26871 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26872
26873 wxPyEndAllowThreads(__tstate);
26874 if (PyErr_Occurred()) SWIG_fail;
26875 }
26876 Py_INCREF(Py_None); resultobj = Py_None;
26877 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26878 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26879 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26880 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26888 PyObject *resultobj;
26889 wxWindow *arg1 = (wxWindow *) 0 ;
26890 wxSize result;
26891 PyObject * obj0 = 0 ;
26892 char *kwnames[] = {
26893 (char *) "self", NULL
26894 };
26895
26896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26898 if (SWIG_arg_fail(1)) SWIG_fail;
26899 {
26900 PyThreadState* __tstate = wxPyBeginAllowThreads();
26901 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26902
26903 wxPyEndAllowThreads(__tstate);
26904 if (PyErr_Occurred()) SWIG_fail;
26905 }
26906 {
26907 wxSize * resultptr;
26908 resultptr = new wxSize((wxSize &)(result));
26909 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26910 }
26911 return resultobj;
26912 fail:
26913 return NULL;
26914 }
26915
26916
26917 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26918 PyObject *resultobj;
26919 wxWindow *arg1 = (wxWindow *) 0 ;
26920 bool arg2 = (bool) true ;
26921 bool result;
26922 PyObject * obj0 = 0 ;
26923 PyObject * obj1 = 0 ;
26924 char *kwnames[] = {
26925 (char *) "self",(char *) "show", NULL
26926 };
26927
26928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26930 if (SWIG_arg_fail(1)) SWIG_fail;
26931 if (obj1) {
26932 {
26933 arg2 = (bool)(SWIG_As_bool(obj1));
26934 if (SWIG_arg_fail(2)) SWIG_fail;
26935 }
26936 }
26937 {
26938 PyThreadState* __tstate = wxPyBeginAllowThreads();
26939 result = (bool)(arg1)->Show(arg2);
26940
26941 wxPyEndAllowThreads(__tstate);
26942 if (PyErr_Occurred()) SWIG_fail;
26943 }
26944 {
26945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26946 }
26947 return resultobj;
26948 fail:
26949 return NULL;
26950 }
26951
26952
26953 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26954 PyObject *resultobj;
26955 wxWindow *arg1 = (wxWindow *) 0 ;
26956 bool result;
26957 PyObject * obj0 = 0 ;
26958 char *kwnames[] = {
26959 (char *) "self", NULL
26960 };
26961
26962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26964 if (SWIG_arg_fail(1)) SWIG_fail;
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 result = (bool)(arg1)->Hide();
26968
26969 wxPyEndAllowThreads(__tstate);
26970 if (PyErr_Occurred()) SWIG_fail;
26971 }
26972 {
26973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26974 }
26975 return resultobj;
26976 fail:
26977 return NULL;
26978 }
26979
26980
26981 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26982 PyObject *resultobj;
26983 wxWindow *arg1 = (wxWindow *) 0 ;
26984 bool arg2 = (bool) true ;
26985 bool result;
26986 PyObject * obj0 = 0 ;
26987 PyObject * obj1 = 0 ;
26988 char *kwnames[] = {
26989 (char *) "self",(char *) "enable", NULL
26990 };
26991
26992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26994 if (SWIG_arg_fail(1)) SWIG_fail;
26995 if (obj1) {
26996 {
26997 arg2 = (bool)(SWIG_As_bool(obj1));
26998 if (SWIG_arg_fail(2)) SWIG_fail;
26999 }
27000 }
27001 {
27002 PyThreadState* __tstate = wxPyBeginAllowThreads();
27003 result = (bool)(arg1)->Enable(arg2);
27004
27005 wxPyEndAllowThreads(__tstate);
27006 if (PyErr_Occurred()) SWIG_fail;
27007 }
27008 {
27009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27010 }
27011 return resultobj;
27012 fail:
27013 return NULL;
27014 }
27015
27016
27017 static PyObject *_wrap_Window_Disable(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_Disable",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)(arg1)->Disable();
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_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27046 PyObject *resultobj;
27047 wxWindow *arg1 = (wxWindow *) 0 ;
27048 bool result;
27049 PyObject * obj0 = 0 ;
27050 char *kwnames[] = {
27051 (char *) "self", NULL
27052 };
27053
27054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27056 if (SWIG_arg_fail(1)) SWIG_fail;
27057 {
27058 PyThreadState* __tstate = wxPyBeginAllowThreads();
27059 result = (bool)((wxWindow const *)arg1)->IsShown();
27060
27061 wxPyEndAllowThreads(__tstate);
27062 if (PyErr_Occurred()) SWIG_fail;
27063 }
27064 {
27065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27066 }
27067 return resultobj;
27068 fail:
27069 return NULL;
27070 }
27071
27072
27073 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27074 PyObject *resultobj;
27075 wxWindow *arg1 = (wxWindow *) 0 ;
27076 bool result;
27077 PyObject * obj0 = 0 ;
27078 char *kwnames[] = {
27079 (char *) "self", NULL
27080 };
27081
27082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27084 if (SWIG_arg_fail(1)) SWIG_fail;
27085 {
27086 PyThreadState* __tstate = wxPyBeginAllowThreads();
27087 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27088
27089 wxPyEndAllowThreads(__tstate);
27090 if (PyErr_Occurred()) SWIG_fail;
27091 }
27092 {
27093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27094 }
27095 return resultobj;
27096 fail:
27097 return NULL;
27098 }
27099
27100
27101 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27102 PyObject *resultobj;
27103 wxWindow *arg1 = (wxWindow *) 0 ;
27104 long arg2 ;
27105 PyObject * obj0 = 0 ;
27106 PyObject * obj1 = 0 ;
27107 char *kwnames[] = {
27108 (char *) "self",(char *) "style", NULL
27109 };
27110
27111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27113 if (SWIG_arg_fail(1)) SWIG_fail;
27114 {
27115 arg2 = (long)(SWIG_As_long(obj1));
27116 if (SWIG_arg_fail(2)) SWIG_fail;
27117 }
27118 {
27119 PyThreadState* __tstate = wxPyBeginAllowThreads();
27120 (arg1)->SetWindowStyleFlag(arg2);
27121
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 Py_INCREF(Py_None); resultobj = Py_None;
27126 return resultobj;
27127 fail:
27128 return NULL;
27129 }
27130
27131
27132 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27133 PyObject *resultobj;
27134 wxWindow *arg1 = (wxWindow *) 0 ;
27135 long result;
27136 PyObject * obj0 = 0 ;
27137 char *kwnames[] = {
27138 (char *) "self", NULL
27139 };
27140
27141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27143 if (SWIG_arg_fail(1)) SWIG_fail;
27144 {
27145 PyThreadState* __tstate = wxPyBeginAllowThreads();
27146 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27147
27148 wxPyEndAllowThreads(__tstate);
27149 if (PyErr_Occurred()) SWIG_fail;
27150 }
27151 {
27152 resultobj = SWIG_From_long((long)(result));
27153 }
27154 return resultobj;
27155 fail:
27156 return NULL;
27157 }
27158
27159
27160 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27161 PyObject *resultobj;
27162 wxWindow *arg1 = (wxWindow *) 0 ;
27163 int arg2 ;
27164 bool result;
27165 PyObject * obj0 = 0 ;
27166 PyObject * obj1 = 0 ;
27167 char *kwnames[] = {
27168 (char *) "self",(char *) "flag", NULL
27169 };
27170
27171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27173 if (SWIG_arg_fail(1)) SWIG_fail;
27174 {
27175 arg2 = (int)(SWIG_As_int(obj1));
27176 if (SWIG_arg_fail(2)) SWIG_fail;
27177 }
27178 {
27179 PyThreadState* __tstate = wxPyBeginAllowThreads();
27180 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27181
27182 wxPyEndAllowThreads(__tstate);
27183 if (PyErr_Occurred()) SWIG_fail;
27184 }
27185 {
27186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27187 }
27188 return resultobj;
27189 fail:
27190 return NULL;
27191 }
27192
27193
27194 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27195 PyObject *resultobj;
27196 wxWindow *arg1 = (wxWindow *) 0 ;
27197 bool result;
27198 PyObject * obj0 = 0 ;
27199 char *kwnames[] = {
27200 (char *) "self", NULL
27201 };
27202
27203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27205 if (SWIG_arg_fail(1)) SWIG_fail;
27206 {
27207 PyThreadState* __tstate = wxPyBeginAllowThreads();
27208 result = (bool)((wxWindow const *)arg1)->IsRetained();
27209
27210 wxPyEndAllowThreads(__tstate);
27211 if (PyErr_Occurred()) SWIG_fail;
27212 }
27213 {
27214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27215 }
27216 return resultobj;
27217 fail:
27218 return NULL;
27219 }
27220
27221
27222 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27223 PyObject *resultobj;
27224 wxWindow *arg1 = (wxWindow *) 0 ;
27225 long arg2 ;
27226 PyObject * obj0 = 0 ;
27227 PyObject * obj1 = 0 ;
27228 char *kwnames[] = {
27229 (char *) "self",(char *) "exStyle", NULL
27230 };
27231
27232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27234 if (SWIG_arg_fail(1)) SWIG_fail;
27235 {
27236 arg2 = (long)(SWIG_As_long(obj1));
27237 if (SWIG_arg_fail(2)) SWIG_fail;
27238 }
27239 {
27240 PyThreadState* __tstate = wxPyBeginAllowThreads();
27241 (arg1)->SetExtraStyle(arg2);
27242
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 Py_INCREF(Py_None); resultobj = Py_None;
27247 return resultobj;
27248 fail:
27249 return NULL;
27250 }
27251
27252
27253 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27254 PyObject *resultobj;
27255 wxWindow *arg1 = (wxWindow *) 0 ;
27256 long result;
27257 PyObject * obj0 = 0 ;
27258 char *kwnames[] = {
27259 (char *) "self", NULL
27260 };
27261
27262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27264 if (SWIG_arg_fail(1)) SWIG_fail;
27265 {
27266 PyThreadState* __tstate = wxPyBeginAllowThreads();
27267 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27268
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 {
27273 resultobj = SWIG_From_long((long)(result));
27274 }
27275 return resultobj;
27276 fail:
27277 return NULL;
27278 }
27279
27280
27281 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27282 PyObject *resultobj;
27283 wxWindow *arg1 = (wxWindow *) 0 ;
27284 bool arg2 = (bool) true ;
27285 PyObject * obj0 = 0 ;
27286 PyObject * obj1 = 0 ;
27287 char *kwnames[] = {
27288 (char *) "self",(char *) "modal", NULL
27289 };
27290
27291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27293 if (SWIG_arg_fail(1)) SWIG_fail;
27294 if (obj1) {
27295 {
27296 arg2 = (bool)(SWIG_As_bool(obj1));
27297 if (SWIG_arg_fail(2)) SWIG_fail;
27298 }
27299 }
27300 {
27301 PyThreadState* __tstate = wxPyBeginAllowThreads();
27302 (arg1)->MakeModal(arg2);
27303
27304 wxPyEndAllowThreads(__tstate);
27305 if (PyErr_Occurred()) SWIG_fail;
27306 }
27307 Py_INCREF(Py_None); resultobj = Py_None;
27308 return resultobj;
27309 fail:
27310 return NULL;
27311 }
27312
27313
27314 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27315 PyObject *resultobj;
27316 wxWindow *arg1 = (wxWindow *) 0 ;
27317 bool arg2 ;
27318 PyObject * obj0 = 0 ;
27319 PyObject * obj1 = 0 ;
27320 char *kwnames[] = {
27321 (char *) "self",(char *) "enableTheme", NULL
27322 };
27323
27324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27326 if (SWIG_arg_fail(1)) SWIG_fail;
27327 {
27328 arg2 = (bool)(SWIG_As_bool(obj1));
27329 if (SWIG_arg_fail(2)) SWIG_fail;
27330 }
27331 {
27332 PyThreadState* __tstate = wxPyBeginAllowThreads();
27333 (arg1)->SetThemeEnabled(arg2);
27334
27335 wxPyEndAllowThreads(__tstate);
27336 if (PyErr_Occurred()) SWIG_fail;
27337 }
27338 Py_INCREF(Py_None); resultobj = Py_None;
27339 return resultobj;
27340 fail:
27341 return NULL;
27342 }
27343
27344
27345 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27346 PyObject *resultobj;
27347 wxWindow *arg1 = (wxWindow *) 0 ;
27348 bool result;
27349 PyObject * obj0 = 0 ;
27350 char *kwnames[] = {
27351 (char *) "self", NULL
27352 };
27353
27354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27356 if (SWIG_arg_fail(1)) SWIG_fail;
27357 {
27358 PyThreadState* __tstate = wxPyBeginAllowThreads();
27359 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27360
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 {
27365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27366 }
27367 return resultobj;
27368 fail:
27369 return NULL;
27370 }
27371
27372
27373 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27374 PyObject *resultobj;
27375 wxWindow *arg1 = (wxWindow *) 0 ;
27376 PyObject * obj0 = 0 ;
27377 char *kwnames[] = {
27378 (char *) "self", NULL
27379 };
27380
27381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27383 if (SWIG_arg_fail(1)) SWIG_fail;
27384 {
27385 PyThreadState* __tstate = wxPyBeginAllowThreads();
27386 (arg1)->SetFocus();
27387
27388 wxPyEndAllowThreads(__tstate);
27389 if (PyErr_Occurred()) SWIG_fail;
27390 }
27391 Py_INCREF(Py_None); resultobj = Py_None;
27392 return resultobj;
27393 fail:
27394 return NULL;
27395 }
27396
27397
27398 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27399 PyObject *resultobj;
27400 wxWindow *arg1 = (wxWindow *) 0 ;
27401 PyObject * obj0 = 0 ;
27402 char *kwnames[] = {
27403 (char *) "self", NULL
27404 };
27405
27406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27408 if (SWIG_arg_fail(1)) SWIG_fail;
27409 {
27410 PyThreadState* __tstate = wxPyBeginAllowThreads();
27411 (arg1)->SetFocusFromKbd();
27412
27413 wxPyEndAllowThreads(__tstate);
27414 if (PyErr_Occurred()) SWIG_fail;
27415 }
27416 Py_INCREF(Py_None); resultobj = Py_None;
27417 return resultobj;
27418 fail:
27419 return NULL;
27420 }
27421
27422
27423 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27424 PyObject *resultobj;
27425 wxWindow *result;
27426 char *kwnames[] = {
27427 NULL
27428 };
27429
27430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27431 {
27432 if (!wxPyCheckForApp()) SWIG_fail;
27433 PyThreadState* __tstate = wxPyBeginAllowThreads();
27434 result = (wxWindow *)wxWindow::FindFocus();
27435
27436 wxPyEndAllowThreads(__tstate);
27437 if (PyErr_Occurred()) SWIG_fail;
27438 }
27439 {
27440 resultobj = wxPyMake_wxObject(result, 0);
27441 }
27442 return resultobj;
27443 fail:
27444 return NULL;
27445 }
27446
27447
27448 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27449 PyObject *resultobj;
27450 wxWindow *arg1 = (wxWindow *) 0 ;
27451 bool result;
27452 PyObject * obj0 = 0 ;
27453 char *kwnames[] = {
27454 (char *) "self", NULL
27455 };
27456
27457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27459 if (SWIG_arg_fail(1)) SWIG_fail;
27460 {
27461 PyThreadState* __tstate = wxPyBeginAllowThreads();
27462 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27463
27464 wxPyEndAllowThreads(__tstate);
27465 if (PyErr_Occurred()) SWIG_fail;
27466 }
27467 {
27468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27469 }
27470 return resultobj;
27471 fail:
27472 return NULL;
27473 }
27474
27475
27476 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27477 PyObject *resultobj;
27478 wxWindow *arg1 = (wxWindow *) 0 ;
27479 bool result;
27480 PyObject * obj0 = 0 ;
27481 char *kwnames[] = {
27482 (char *) "self", NULL
27483 };
27484
27485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27487 if (SWIG_arg_fail(1)) SWIG_fail;
27488 {
27489 PyThreadState* __tstate = wxPyBeginAllowThreads();
27490 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27491
27492 wxPyEndAllowThreads(__tstate);
27493 if (PyErr_Occurred()) SWIG_fail;
27494 }
27495 {
27496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27497 }
27498 return resultobj;
27499 fail:
27500 return NULL;
27501 }
27502
27503
27504 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27505 PyObject *resultobj;
27506 wxWindow *arg1 = (wxWindow *) 0 ;
27507 wxWindow *result;
27508 PyObject * obj0 = 0 ;
27509 char *kwnames[] = {
27510 (char *) "self", NULL
27511 };
27512
27513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27515 if (SWIG_arg_fail(1)) SWIG_fail;
27516 {
27517 PyThreadState* __tstate = wxPyBeginAllowThreads();
27518 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27519
27520 wxPyEndAllowThreads(__tstate);
27521 if (PyErr_Occurred()) SWIG_fail;
27522 }
27523 {
27524 resultobj = wxPyMake_wxObject(result, 0);
27525 }
27526 return resultobj;
27527 fail:
27528 return NULL;
27529 }
27530
27531
27532 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27533 PyObject *resultobj;
27534 wxWindow *arg1 = (wxWindow *) 0 ;
27535 wxWindow *arg2 = (wxWindow *) 0 ;
27536 wxWindow *result;
27537 PyObject * obj0 = 0 ;
27538 PyObject * obj1 = 0 ;
27539 char *kwnames[] = {
27540 (char *) "self",(char *) "child", NULL
27541 };
27542
27543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27545 if (SWIG_arg_fail(1)) SWIG_fail;
27546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27547 if (SWIG_arg_fail(2)) SWIG_fail;
27548 {
27549 PyThreadState* __tstate = wxPyBeginAllowThreads();
27550 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27551
27552 wxPyEndAllowThreads(__tstate);
27553 if (PyErr_Occurred()) SWIG_fail;
27554 }
27555 {
27556 resultobj = wxPyMake_wxObject(result, 0);
27557 }
27558 return resultobj;
27559 fail:
27560 return NULL;
27561 }
27562
27563
27564 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27565 PyObject *resultobj;
27566 wxWindow *arg1 = (wxWindow *) 0 ;
27567 wxWindow *arg2 = (wxWindow *) 0 ;
27568 PyObject * obj0 = 0 ;
27569 PyObject * obj1 = 0 ;
27570 char *kwnames[] = {
27571 (char *) "self",(char *) "win", NULL
27572 };
27573
27574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27576 if (SWIG_arg_fail(1)) SWIG_fail;
27577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27578 if (SWIG_arg_fail(2)) SWIG_fail;
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 (arg1)->SetTmpDefaultItem(arg2);
27582
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 Py_INCREF(Py_None); resultobj = Py_None;
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj;
27595 wxWindow *arg1 = (wxWindow *) 0 ;
27596 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27597 bool result;
27598 PyObject * obj0 = 0 ;
27599 PyObject * obj1 = 0 ;
27600 char *kwnames[] = {
27601 (char *) "self",(char *) "flags", NULL
27602 };
27603
27604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27606 if (SWIG_arg_fail(1)) SWIG_fail;
27607 if (obj1) {
27608 {
27609 arg2 = (int)(SWIG_As_int(obj1));
27610 if (SWIG_arg_fail(2)) SWIG_fail;
27611 }
27612 }
27613 {
27614 PyThreadState* __tstate = wxPyBeginAllowThreads();
27615 result = (bool)(arg1)->Navigate(arg2);
27616
27617 wxPyEndAllowThreads(__tstate);
27618 if (PyErr_Occurred()) SWIG_fail;
27619 }
27620 {
27621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27622 }
27623 return resultobj;
27624 fail:
27625 return NULL;
27626 }
27627
27628
27629 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27630 PyObject *resultobj;
27631 wxWindow *arg1 = (wxWindow *) 0 ;
27632 wxWindow *arg2 = (wxWindow *) 0 ;
27633 PyObject * obj0 = 0 ;
27634 PyObject * obj1 = 0 ;
27635 char *kwnames[] = {
27636 (char *) "self",(char *) "win", NULL
27637 };
27638
27639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27641 if (SWIG_arg_fail(1)) SWIG_fail;
27642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27643 if (SWIG_arg_fail(2)) SWIG_fail;
27644 {
27645 PyThreadState* __tstate = wxPyBeginAllowThreads();
27646 (arg1)->MoveAfterInTabOrder(arg2);
27647
27648 wxPyEndAllowThreads(__tstate);
27649 if (PyErr_Occurred()) SWIG_fail;
27650 }
27651 Py_INCREF(Py_None); resultobj = Py_None;
27652 return resultobj;
27653 fail:
27654 return NULL;
27655 }
27656
27657
27658 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27659 PyObject *resultobj;
27660 wxWindow *arg1 = (wxWindow *) 0 ;
27661 wxWindow *arg2 = (wxWindow *) 0 ;
27662 PyObject * obj0 = 0 ;
27663 PyObject * obj1 = 0 ;
27664 char *kwnames[] = {
27665 (char *) "self",(char *) "win", NULL
27666 };
27667
27668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27670 if (SWIG_arg_fail(1)) SWIG_fail;
27671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27672 if (SWIG_arg_fail(2)) SWIG_fail;
27673 {
27674 PyThreadState* __tstate = wxPyBeginAllowThreads();
27675 (arg1)->MoveBeforeInTabOrder(arg2);
27676
27677 wxPyEndAllowThreads(__tstate);
27678 if (PyErr_Occurred()) SWIG_fail;
27679 }
27680 Py_INCREF(Py_None); resultobj = Py_None;
27681 return resultobj;
27682 fail:
27683 return NULL;
27684 }
27685
27686
27687 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27688 PyObject *resultobj;
27689 wxWindow *arg1 = (wxWindow *) 0 ;
27690 PyObject *result;
27691 PyObject * obj0 = 0 ;
27692 char *kwnames[] = {
27693 (char *) "self", NULL
27694 };
27695
27696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27698 if (SWIG_arg_fail(1)) SWIG_fail;
27699 {
27700 PyThreadState* __tstate = wxPyBeginAllowThreads();
27701 result = (PyObject *)wxWindow_GetChildren(arg1);
27702
27703 wxPyEndAllowThreads(__tstate);
27704 if (PyErr_Occurred()) SWIG_fail;
27705 }
27706 resultobj = result;
27707 return resultobj;
27708 fail:
27709 return NULL;
27710 }
27711
27712
27713 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27714 PyObject *resultobj;
27715 wxWindow *arg1 = (wxWindow *) 0 ;
27716 wxWindow *result;
27717 PyObject * obj0 = 0 ;
27718 char *kwnames[] = {
27719 (char *) "self", NULL
27720 };
27721
27722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27724 if (SWIG_arg_fail(1)) SWIG_fail;
27725 {
27726 PyThreadState* __tstate = wxPyBeginAllowThreads();
27727 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27728
27729 wxPyEndAllowThreads(__tstate);
27730 if (PyErr_Occurred()) SWIG_fail;
27731 }
27732 {
27733 resultobj = wxPyMake_wxObject(result, 0);
27734 }
27735 return resultobj;
27736 fail:
27737 return NULL;
27738 }
27739
27740
27741 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27742 PyObject *resultobj;
27743 wxWindow *arg1 = (wxWindow *) 0 ;
27744 wxWindow *result;
27745 PyObject * obj0 = 0 ;
27746 char *kwnames[] = {
27747 (char *) "self", NULL
27748 };
27749
27750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27752 if (SWIG_arg_fail(1)) SWIG_fail;
27753 {
27754 PyThreadState* __tstate = wxPyBeginAllowThreads();
27755 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27756
27757 wxPyEndAllowThreads(__tstate);
27758 if (PyErr_Occurred()) SWIG_fail;
27759 }
27760 {
27761 resultobj = wxPyMake_wxObject(result, 0);
27762 }
27763 return resultobj;
27764 fail:
27765 return NULL;
27766 }
27767
27768
27769 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27770 PyObject *resultobj;
27771 wxWindow *arg1 = (wxWindow *) 0 ;
27772 bool result;
27773 PyObject * obj0 = 0 ;
27774 char *kwnames[] = {
27775 (char *) "self", NULL
27776 };
27777
27778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27780 if (SWIG_arg_fail(1)) SWIG_fail;
27781 {
27782 PyThreadState* __tstate = wxPyBeginAllowThreads();
27783 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27784
27785 wxPyEndAllowThreads(__tstate);
27786 if (PyErr_Occurred()) SWIG_fail;
27787 }
27788 {
27789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27790 }
27791 return resultobj;
27792 fail:
27793 return NULL;
27794 }
27795
27796
27797 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27798 PyObject *resultobj;
27799 wxWindow *arg1 = (wxWindow *) 0 ;
27800 wxWindow *arg2 = (wxWindow *) 0 ;
27801 bool result;
27802 PyObject * obj0 = 0 ;
27803 PyObject * obj1 = 0 ;
27804 char *kwnames[] = {
27805 (char *) "self",(char *) "newParent", NULL
27806 };
27807
27808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27810 if (SWIG_arg_fail(1)) SWIG_fail;
27811 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27812 if (SWIG_arg_fail(2)) SWIG_fail;
27813 {
27814 PyThreadState* __tstate = wxPyBeginAllowThreads();
27815 result = (bool)(arg1)->Reparent(arg2);
27816
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 {
27821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27822 }
27823 return resultobj;
27824 fail:
27825 return NULL;
27826 }
27827
27828
27829 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27830 PyObject *resultobj;
27831 wxWindow *arg1 = (wxWindow *) 0 ;
27832 wxWindow *arg2 = (wxWindow *) 0 ;
27833 PyObject * obj0 = 0 ;
27834 PyObject * obj1 = 0 ;
27835 char *kwnames[] = {
27836 (char *) "self",(char *) "child", NULL
27837 };
27838
27839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27841 if (SWIG_arg_fail(1)) SWIG_fail;
27842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27843 if (SWIG_arg_fail(2)) SWIG_fail;
27844 {
27845 PyThreadState* __tstate = wxPyBeginAllowThreads();
27846 (arg1)->AddChild(arg2);
27847
27848 wxPyEndAllowThreads(__tstate);
27849 if (PyErr_Occurred()) SWIG_fail;
27850 }
27851 Py_INCREF(Py_None); resultobj = Py_None;
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27859 PyObject *resultobj;
27860 wxWindow *arg1 = (wxWindow *) 0 ;
27861 wxWindow *arg2 = (wxWindow *) 0 ;
27862 PyObject * obj0 = 0 ;
27863 PyObject * obj1 = 0 ;
27864 char *kwnames[] = {
27865 (char *) "self",(char *) "child", NULL
27866 };
27867
27868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27870 if (SWIG_arg_fail(1)) SWIG_fail;
27871 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27872 if (SWIG_arg_fail(2)) SWIG_fail;
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 (arg1)->RemoveChild(arg2);
27876
27877 wxPyEndAllowThreads(__tstate);
27878 if (PyErr_Occurred()) SWIG_fail;
27879 }
27880 Py_INCREF(Py_None); resultobj = Py_None;
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27888 PyObject *resultobj;
27889 wxWindow *arg1 = (wxWindow *) 0 ;
27890 long arg2 ;
27891 wxWindow *result;
27892 PyObject * obj0 = 0 ;
27893 PyObject * obj1 = 0 ;
27894 char *kwnames[] = {
27895 (char *) "self",(char *) "winid", NULL
27896 };
27897
27898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27900 if (SWIG_arg_fail(1)) SWIG_fail;
27901 {
27902 arg2 = (long)(SWIG_As_long(obj1));
27903 if (SWIG_arg_fail(2)) SWIG_fail;
27904 }
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 result = (wxWindow *)(arg1)->FindWindow(arg2);
27908
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 {
27913 resultobj = wxPyMake_wxObject(result, 0);
27914 }
27915 return resultobj;
27916 fail:
27917 return NULL;
27918 }
27919
27920
27921 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27922 PyObject *resultobj;
27923 wxWindow *arg1 = (wxWindow *) 0 ;
27924 wxString *arg2 = 0 ;
27925 wxWindow *result;
27926 bool temp2 = false ;
27927 PyObject * obj0 = 0 ;
27928 PyObject * obj1 = 0 ;
27929 char *kwnames[] = {
27930 (char *) "self",(char *) "name", NULL
27931 };
27932
27933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27935 if (SWIG_arg_fail(1)) SWIG_fail;
27936 {
27937 arg2 = wxString_in_helper(obj1);
27938 if (arg2 == NULL) SWIG_fail;
27939 temp2 = true;
27940 }
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27944
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 {
27949 resultobj = wxPyMake_wxObject(result, 0);
27950 }
27951 {
27952 if (temp2)
27953 delete arg2;
27954 }
27955 return resultobj;
27956 fail:
27957 {
27958 if (temp2)
27959 delete arg2;
27960 }
27961 return NULL;
27962 }
27963
27964
27965 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj;
27967 wxWindow *arg1 = (wxWindow *) 0 ;
27968 wxEvtHandler *result;
27969 PyObject * obj0 = 0 ;
27970 char *kwnames[] = {
27971 (char *) "self", NULL
27972 };
27973
27974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27976 if (SWIG_arg_fail(1)) SWIG_fail;
27977 {
27978 PyThreadState* __tstate = wxPyBeginAllowThreads();
27979 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27980
27981 wxPyEndAllowThreads(__tstate);
27982 if (PyErr_Occurred()) SWIG_fail;
27983 }
27984 {
27985 resultobj = wxPyMake_wxObject(result, 0);
27986 }
27987 return resultobj;
27988 fail:
27989 return NULL;
27990 }
27991
27992
27993 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27994 PyObject *resultobj;
27995 wxWindow *arg1 = (wxWindow *) 0 ;
27996 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27997 PyObject * obj0 = 0 ;
27998 PyObject * obj1 = 0 ;
27999 char *kwnames[] = {
28000 (char *) "self",(char *) "handler", NULL
28001 };
28002
28003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28005 if (SWIG_arg_fail(1)) SWIG_fail;
28006 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28007 if (SWIG_arg_fail(2)) SWIG_fail;
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 (arg1)->SetEventHandler(arg2);
28011
28012 wxPyEndAllowThreads(__tstate);
28013 if (PyErr_Occurred()) SWIG_fail;
28014 }
28015 Py_INCREF(Py_None); resultobj = Py_None;
28016 return resultobj;
28017 fail:
28018 return NULL;
28019 }
28020
28021
28022 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28023 PyObject *resultobj;
28024 wxWindow *arg1 = (wxWindow *) 0 ;
28025 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28026 PyObject * obj0 = 0 ;
28027 PyObject * obj1 = 0 ;
28028 char *kwnames[] = {
28029 (char *) "self",(char *) "handler", NULL
28030 };
28031
28032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28034 if (SWIG_arg_fail(1)) SWIG_fail;
28035 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28036 if (SWIG_arg_fail(2)) SWIG_fail;
28037 {
28038 PyThreadState* __tstate = wxPyBeginAllowThreads();
28039 (arg1)->PushEventHandler(arg2);
28040
28041 wxPyEndAllowThreads(__tstate);
28042 if (PyErr_Occurred()) SWIG_fail;
28043 }
28044 Py_INCREF(Py_None); resultobj = Py_None;
28045 return resultobj;
28046 fail:
28047 return NULL;
28048 }
28049
28050
28051 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28052 PyObject *resultobj;
28053 wxWindow *arg1 = (wxWindow *) 0 ;
28054 bool arg2 = (bool) false ;
28055 wxEvtHandler *result;
28056 PyObject * obj0 = 0 ;
28057 PyObject * obj1 = 0 ;
28058 char *kwnames[] = {
28059 (char *) "self",(char *) "deleteHandler", NULL
28060 };
28061
28062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28064 if (SWIG_arg_fail(1)) SWIG_fail;
28065 if (obj1) {
28066 {
28067 arg2 = (bool)(SWIG_As_bool(obj1));
28068 if (SWIG_arg_fail(2)) SWIG_fail;
28069 }
28070 }
28071 {
28072 PyThreadState* __tstate = wxPyBeginAllowThreads();
28073 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28074
28075 wxPyEndAllowThreads(__tstate);
28076 if (PyErr_Occurred()) SWIG_fail;
28077 }
28078 {
28079 resultobj = wxPyMake_wxObject(result, 0);
28080 }
28081 return resultobj;
28082 fail:
28083 return NULL;
28084 }
28085
28086
28087 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28088 PyObject *resultobj;
28089 wxWindow *arg1 = (wxWindow *) 0 ;
28090 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28091 bool result;
28092 PyObject * obj0 = 0 ;
28093 PyObject * obj1 = 0 ;
28094 char *kwnames[] = {
28095 (char *) "self",(char *) "handler", NULL
28096 };
28097
28098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28100 if (SWIG_arg_fail(1)) SWIG_fail;
28101 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28102 if (SWIG_arg_fail(2)) SWIG_fail;
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 result = (bool)(arg1)->RemoveEventHandler(arg2);
28106
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 {
28111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28112 }
28113 return resultobj;
28114 fail:
28115 return NULL;
28116 }
28117
28118
28119 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28120 PyObject *resultobj;
28121 wxWindow *arg1 = (wxWindow *) 0 ;
28122 wxValidator *arg2 = 0 ;
28123 PyObject * obj0 = 0 ;
28124 PyObject * obj1 = 0 ;
28125 char *kwnames[] = {
28126 (char *) "self",(char *) "validator", NULL
28127 };
28128
28129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28131 if (SWIG_arg_fail(1)) SWIG_fail;
28132 {
28133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28134 if (SWIG_arg_fail(2)) SWIG_fail;
28135 if (arg2 == NULL) {
28136 SWIG_null_ref("wxValidator");
28137 }
28138 if (SWIG_arg_fail(2)) SWIG_fail;
28139 }
28140 {
28141 PyThreadState* __tstate = wxPyBeginAllowThreads();
28142 (arg1)->SetValidator((wxValidator const &)*arg2);
28143
28144 wxPyEndAllowThreads(__tstate);
28145 if (PyErr_Occurred()) SWIG_fail;
28146 }
28147 Py_INCREF(Py_None); resultobj = Py_None;
28148 return resultobj;
28149 fail:
28150 return NULL;
28151 }
28152
28153
28154 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28155 PyObject *resultobj;
28156 wxWindow *arg1 = (wxWindow *) 0 ;
28157 wxValidator *result;
28158 PyObject * obj0 = 0 ;
28159 char *kwnames[] = {
28160 (char *) "self", NULL
28161 };
28162
28163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28165 if (SWIG_arg_fail(1)) SWIG_fail;
28166 {
28167 PyThreadState* __tstate = wxPyBeginAllowThreads();
28168 result = (wxValidator *)(arg1)->GetValidator();
28169
28170 wxPyEndAllowThreads(__tstate);
28171 if (PyErr_Occurred()) SWIG_fail;
28172 }
28173 {
28174 resultobj = wxPyMake_wxObject(result, 0);
28175 }
28176 return resultobj;
28177 fail:
28178 return NULL;
28179 }
28180
28181
28182 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28183 PyObject *resultobj;
28184 wxWindow *arg1 = (wxWindow *) 0 ;
28185 bool result;
28186 PyObject * obj0 = 0 ;
28187 char *kwnames[] = {
28188 (char *) "self", NULL
28189 };
28190
28191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28193 if (SWIG_arg_fail(1)) SWIG_fail;
28194 {
28195 PyThreadState* __tstate = wxPyBeginAllowThreads();
28196 result = (bool)(arg1)->Validate();
28197
28198 wxPyEndAllowThreads(__tstate);
28199 if (PyErr_Occurred()) SWIG_fail;
28200 }
28201 {
28202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28203 }
28204 return resultobj;
28205 fail:
28206 return NULL;
28207 }
28208
28209
28210 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28211 PyObject *resultobj;
28212 wxWindow *arg1 = (wxWindow *) 0 ;
28213 bool result;
28214 PyObject * obj0 = 0 ;
28215 char *kwnames[] = {
28216 (char *) "self", NULL
28217 };
28218
28219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28221 if (SWIG_arg_fail(1)) SWIG_fail;
28222 {
28223 PyThreadState* __tstate = wxPyBeginAllowThreads();
28224 result = (bool)(arg1)->TransferDataToWindow();
28225
28226 wxPyEndAllowThreads(__tstate);
28227 if (PyErr_Occurred()) SWIG_fail;
28228 }
28229 {
28230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28231 }
28232 return resultobj;
28233 fail:
28234 return NULL;
28235 }
28236
28237
28238 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28239 PyObject *resultobj;
28240 wxWindow *arg1 = (wxWindow *) 0 ;
28241 bool result;
28242 PyObject * obj0 = 0 ;
28243 char *kwnames[] = {
28244 (char *) "self", NULL
28245 };
28246
28247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28249 if (SWIG_arg_fail(1)) SWIG_fail;
28250 {
28251 PyThreadState* __tstate = wxPyBeginAllowThreads();
28252 result = (bool)(arg1)->TransferDataFromWindow();
28253
28254 wxPyEndAllowThreads(__tstate);
28255 if (PyErr_Occurred()) SWIG_fail;
28256 }
28257 {
28258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28259 }
28260 return resultobj;
28261 fail:
28262 return NULL;
28263 }
28264
28265
28266 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28267 PyObject *resultobj;
28268 wxWindow *arg1 = (wxWindow *) 0 ;
28269 PyObject * obj0 = 0 ;
28270 char *kwnames[] = {
28271 (char *) "self", NULL
28272 };
28273
28274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28276 if (SWIG_arg_fail(1)) SWIG_fail;
28277 {
28278 PyThreadState* __tstate = wxPyBeginAllowThreads();
28279 (arg1)->InitDialog();
28280
28281 wxPyEndAllowThreads(__tstate);
28282 if (PyErr_Occurred()) SWIG_fail;
28283 }
28284 Py_INCREF(Py_None); resultobj = Py_None;
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28292 PyObject *resultobj;
28293 wxWindow *arg1 = (wxWindow *) 0 ;
28294 wxAcceleratorTable *arg2 = 0 ;
28295 PyObject * obj0 = 0 ;
28296 PyObject * obj1 = 0 ;
28297 char *kwnames[] = {
28298 (char *) "self",(char *) "accel", NULL
28299 };
28300
28301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28306 if (SWIG_arg_fail(2)) SWIG_fail;
28307 if (arg2 == NULL) {
28308 SWIG_null_ref("wxAcceleratorTable");
28309 }
28310 if (SWIG_arg_fail(2)) SWIG_fail;
28311 }
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28315
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 Py_INCREF(Py_None); resultobj = Py_None;
28320 return resultobj;
28321 fail:
28322 return NULL;
28323 }
28324
28325
28326 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28327 PyObject *resultobj;
28328 wxWindow *arg1 = (wxWindow *) 0 ;
28329 wxAcceleratorTable *result;
28330 PyObject * obj0 = 0 ;
28331 char *kwnames[] = {
28332 (char *) "self", NULL
28333 };
28334
28335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28337 if (SWIG_arg_fail(1)) SWIG_fail;
28338 {
28339 PyThreadState* __tstate = wxPyBeginAllowThreads();
28340 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28341
28342 wxPyEndAllowThreads(__tstate);
28343 if (PyErr_Occurred()) SWIG_fail;
28344 }
28345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28346 return resultobj;
28347 fail:
28348 return NULL;
28349 }
28350
28351
28352 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28353 PyObject *resultobj;
28354 wxWindow *arg1 = (wxWindow *) 0 ;
28355 int arg2 ;
28356 int arg3 ;
28357 int arg4 ;
28358 bool result;
28359 PyObject * obj0 = 0 ;
28360 PyObject * obj1 = 0 ;
28361 PyObject * obj2 = 0 ;
28362 PyObject * obj3 = 0 ;
28363 char *kwnames[] = {
28364 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28365 };
28366
28367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28369 if (SWIG_arg_fail(1)) SWIG_fail;
28370 {
28371 arg2 = (int)(SWIG_As_int(obj1));
28372 if (SWIG_arg_fail(2)) SWIG_fail;
28373 }
28374 {
28375 arg3 = (int)(SWIG_As_int(obj2));
28376 if (SWIG_arg_fail(3)) SWIG_fail;
28377 }
28378 {
28379 arg4 = (int)(SWIG_As_int(obj3));
28380 if (SWIG_arg_fail(4)) SWIG_fail;
28381 }
28382 {
28383 PyThreadState* __tstate = wxPyBeginAllowThreads();
28384 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28385
28386 wxPyEndAllowThreads(__tstate);
28387 if (PyErr_Occurred()) SWIG_fail;
28388 }
28389 {
28390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28391 }
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28399 PyObject *resultobj;
28400 wxWindow *arg1 = (wxWindow *) 0 ;
28401 int arg2 ;
28402 bool result;
28403 PyObject * obj0 = 0 ;
28404 PyObject * obj1 = 0 ;
28405 char *kwnames[] = {
28406 (char *) "self",(char *) "hotkeyId", NULL
28407 };
28408
28409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28411 if (SWIG_arg_fail(1)) SWIG_fail;
28412 {
28413 arg2 = (int)(SWIG_As_int(obj1));
28414 if (SWIG_arg_fail(2)) SWIG_fail;
28415 }
28416 {
28417 PyThreadState* __tstate = wxPyBeginAllowThreads();
28418 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28419
28420 wxPyEndAllowThreads(__tstate);
28421 if (PyErr_Occurred()) SWIG_fail;
28422 }
28423 {
28424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28425 }
28426 return resultobj;
28427 fail:
28428 return NULL;
28429 }
28430
28431
28432 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28433 PyObject *resultobj;
28434 wxWindow *arg1 = (wxWindow *) 0 ;
28435 wxPoint *arg2 = 0 ;
28436 wxPoint result;
28437 wxPoint temp2 ;
28438 PyObject * obj0 = 0 ;
28439 PyObject * obj1 = 0 ;
28440 char *kwnames[] = {
28441 (char *) "self",(char *) "pt", NULL
28442 };
28443
28444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28446 if (SWIG_arg_fail(1)) SWIG_fail;
28447 {
28448 arg2 = &temp2;
28449 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28450 }
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28454
28455 wxPyEndAllowThreads(__tstate);
28456 if (PyErr_Occurred()) SWIG_fail;
28457 }
28458 {
28459 wxPoint * resultptr;
28460 resultptr = new wxPoint((wxPoint &)(result));
28461 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28462 }
28463 return resultobj;
28464 fail:
28465 return NULL;
28466 }
28467
28468
28469 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28470 PyObject *resultobj;
28471 wxWindow *arg1 = (wxWindow *) 0 ;
28472 wxSize *arg2 = 0 ;
28473 wxSize result;
28474 wxSize temp2 ;
28475 PyObject * obj0 = 0 ;
28476 PyObject * obj1 = 0 ;
28477 char *kwnames[] = {
28478 (char *) "self",(char *) "sz", NULL
28479 };
28480
28481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28483 if (SWIG_arg_fail(1)) SWIG_fail;
28484 {
28485 arg2 = &temp2;
28486 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28487 }
28488 {
28489 PyThreadState* __tstate = wxPyBeginAllowThreads();
28490 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28491
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 wxSize * resultptr;
28497 resultptr = new wxSize((wxSize &)(result));
28498 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28499 }
28500 return resultobj;
28501 fail:
28502 return NULL;
28503 }
28504
28505
28506 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28507 PyObject *resultobj;
28508 wxWindow *arg1 = (wxWindow *) 0 ;
28509 wxPoint *arg2 = 0 ;
28510 wxPoint result;
28511 wxPoint temp2 ;
28512 PyObject * obj0 = 0 ;
28513 PyObject * obj1 = 0 ;
28514 char *kwnames[] = {
28515 (char *) "self",(char *) "pt", NULL
28516 };
28517
28518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28520 if (SWIG_arg_fail(1)) SWIG_fail;
28521 {
28522 arg2 = &temp2;
28523 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28524 }
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28528
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 {
28533 wxPoint * resultptr;
28534 resultptr = new wxPoint((wxPoint &)(result));
28535 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28536 }
28537 return resultobj;
28538 fail:
28539 return NULL;
28540 }
28541
28542
28543 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28544 PyObject *resultobj;
28545 wxWindow *arg1 = (wxWindow *) 0 ;
28546 wxSize *arg2 = 0 ;
28547 wxSize result;
28548 wxSize temp2 ;
28549 PyObject * obj0 = 0 ;
28550 PyObject * obj1 = 0 ;
28551 char *kwnames[] = {
28552 (char *) "self",(char *) "sz", NULL
28553 };
28554
28555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28557 if (SWIG_arg_fail(1)) SWIG_fail;
28558 {
28559 arg2 = &temp2;
28560 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28561 }
28562 {
28563 PyThreadState* __tstate = wxPyBeginAllowThreads();
28564 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28565
28566 wxPyEndAllowThreads(__tstate);
28567 if (PyErr_Occurred()) SWIG_fail;
28568 }
28569 {
28570 wxSize * resultptr;
28571 resultptr = new wxSize((wxSize &)(result));
28572 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28573 }
28574 return resultobj;
28575 fail:
28576 return NULL;
28577 }
28578
28579
28580 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28581 PyObject *resultobj;
28582 wxWindow *arg1 = (wxWindow *) 0 ;
28583 wxPoint *arg2 = 0 ;
28584 wxPoint result;
28585 wxPoint temp2 ;
28586 PyObject * obj0 = 0 ;
28587 PyObject * obj1 = 0 ;
28588 char *kwnames[] = {
28589 (char *) "self",(char *) "pt", NULL
28590 };
28591
28592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28594 if (SWIG_arg_fail(1)) SWIG_fail;
28595 {
28596 arg2 = &temp2;
28597 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28598 }
28599 {
28600 PyThreadState* __tstate = wxPyBeginAllowThreads();
28601 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28602
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 {
28607 wxPoint * resultptr;
28608 resultptr = new wxPoint((wxPoint &)(result));
28609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28610 }
28611 return resultobj;
28612 fail:
28613 return NULL;
28614 }
28615
28616
28617 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28618 PyObject *resultobj;
28619 wxWindow *arg1 = (wxWindow *) 0 ;
28620 wxSize *arg2 = 0 ;
28621 wxSize result;
28622 wxSize temp2 ;
28623 PyObject * obj0 = 0 ;
28624 PyObject * obj1 = 0 ;
28625 char *kwnames[] = {
28626 (char *) "self",(char *) "sz", NULL
28627 };
28628
28629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28631 if (SWIG_arg_fail(1)) SWIG_fail;
28632 {
28633 arg2 = &temp2;
28634 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28635 }
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28639
28640 wxPyEndAllowThreads(__tstate);
28641 if (PyErr_Occurred()) SWIG_fail;
28642 }
28643 {
28644 wxSize * resultptr;
28645 resultptr = new wxSize((wxSize &)(result));
28646 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28647 }
28648 return resultobj;
28649 fail:
28650 return NULL;
28651 }
28652
28653
28654 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28655 PyObject *resultobj;
28656 wxWindow *arg1 = (wxWindow *) 0 ;
28657 int arg2 ;
28658 int arg3 ;
28659 PyObject * obj0 = 0 ;
28660 PyObject * obj1 = 0 ;
28661 PyObject * obj2 = 0 ;
28662 char *kwnames[] = {
28663 (char *) "self",(char *) "x",(char *) "y", NULL
28664 };
28665
28666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28668 if (SWIG_arg_fail(1)) SWIG_fail;
28669 {
28670 arg2 = (int)(SWIG_As_int(obj1));
28671 if (SWIG_arg_fail(2)) SWIG_fail;
28672 }
28673 {
28674 arg3 = (int)(SWIG_As_int(obj2));
28675 if (SWIG_arg_fail(3)) SWIG_fail;
28676 }
28677 {
28678 PyThreadState* __tstate = wxPyBeginAllowThreads();
28679 (arg1)->WarpPointer(arg2,arg3);
28680
28681 wxPyEndAllowThreads(__tstate);
28682 if (PyErr_Occurred()) SWIG_fail;
28683 }
28684 Py_INCREF(Py_None); resultobj = Py_None;
28685 return resultobj;
28686 fail:
28687 return NULL;
28688 }
28689
28690
28691 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28692 PyObject *resultobj;
28693 wxWindow *arg1 = (wxWindow *) 0 ;
28694 PyObject * obj0 = 0 ;
28695 char *kwnames[] = {
28696 (char *) "self", NULL
28697 };
28698
28699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28701 if (SWIG_arg_fail(1)) SWIG_fail;
28702 {
28703 PyThreadState* __tstate = wxPyBeginAllowThreads();
28704 (arg1)->CaptureMouse();
28705
28706 wxPyEndAllowThreads(__tstate);
28707 if (PyErr_Occurred()) SWIG_fail;
28708 }
28709 Py_INCREF(Py_None); resultobj = Py_None;
28710 return resultobj;
28711 fail:
28712 return NULL;
28713 }
28714
28715
28716 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28717 PyObject *resultobj;
28718 wxWindow *arg1 = (wxWindow *) 0 ;
28719 PyObject * obj0 = 0 ;
28720 char *kwnames[] = {
28721 (char *) "self", NULL
28722 };
28723
28724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28726 if (SWIG_arg_fail(1)) SWIG_fail;
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 (arg1)->ReleaseMouse();
28730
28731 wxPyEndAllowThreads(__tstate);
28732 if (PyErr_Occurred()) SWIG_fail;
28733 }
28734 Py_INCREF(Py_None); resultobj = Py_None;
28735 return resultobj;
28736 fail:
28737 return NULL;
28738 }
28739
28740
28741 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28742 PyObject *resultobj;
28743 wxWindow *result;
28744 char *kwnames[] = {
28745 NULL
28746 };
28747
28748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28749 {
28750 if (!wxPyCheckForApp()) SWIG_fail;
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 result = (wxWindow *)wxWindow::GetCapture();
28753
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 {
28758 resultobj = wxPyMake_wxObject(result, 0);
28759 }
28760 return resultobj;
28761 fail:
28762 return NULL;
28763 }
28764
28765
28766 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28767 PyObject *resultobj;
28768 wxWindow *arg1 = (wxWindow *) 0 ;
28769 bool result;
28770 PyObject * obj0 = 0 ;
28771 char *kwnames[] = {
28772 (char *) "self", NULL
28773 };
28774
28775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28777 if (SWIG_arg_fail(1)) SWIG_fail;
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 result = (bool)((wxWindow const *)arg1)->HasCapture();
28781
28782 wxPyEndAllowThreads(__tstate);
28783 if (PyErr_Occurred()) SWIG_fail;
28784 }
28785 {
28786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28787 }
28788 return resultobj;
28789 fail:
28790 return NULL;
28791 }
28792
28793
28794 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28795 PyObject *resultobj;
28796 wxWindow *arg1 = (wxWindow *) 0 ;
28797 bool arg2 = (bool) true ;
28798 wxRect *arg3 = (wxRect *) NULL ;
28799 PyObject * obj0 = 0 ;
28800 PyObject * obj1 = 0 ;
28801 PyObject * obj2 = 0 ;
28802 char *kwnames[] = {
28803 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28804 };
28805
28806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28808 if (SWIG_arg_fail(1)) SWIG_fail;
28809 if (obj1) {
28810 {
28811 arg2 = (bool)(SWIG_As_bool(obj1));
28812 if (SWIG_arg_fail(2)) SWIG_fail;
28813 }
28814 }
28815 if (obj2) {
28816 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28817 if (SWIG_arg_fail(3)) SWIG_fail;
28818 }
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28822
28823 wxPyEndAllowThreads(__tstate);
28824 if (PyErr_Occurred()) SWIG_fail;
28825 }
28826 Py_INCREF(Py_None); resultobj = Py_None;
28827 return resultobj;
28828 fail:
28829 return NULL;
28830 }
28831
28832
28833 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28834 PyObject *resultobj;
28835 wxWindow *arg1 = (wxWindow *) 0 ;
28836 wxRect *arg2 = 0 ;
28837 bool arg3 = (bool) true ;
28838 wxRect temp2 ;
28839 PyObject * obj0 = 0 ;
28840 PyObject * obj1 = 0 ;
28841 PyObject * obj2 = 0 ;
28842 char *kwnames[] = {
28843 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28844 };
28845
28846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28848 if (SWIG_arg_fail(1)) SWIG_fail;
28849 {
28850 arg2 = &temp2;
28851 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28852 }
28853 if (obj2) {
28854 {
28855 arg3 = (bool)(SWIG_As_bool(obj2));
28856 if (SWIG_arg_fail(3)) SWIG_fail;
28857 }
28858 }
28859 {
28860 PyThreadState* __tstate = wxPyBeginAllowThreads();
28861 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28862
28863 wxPyEndAllowThreads(__tstate);
28864 if (PyErr_Occurred()) SWIG_fail;
28865 }
28866 Py_INCREF(Py_None); resultobj = Py_None;
28867 return resultobj;
28868 fail:
28869 return NULL;
28870 }
28871
28872
28873 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28874 PyObject *resultobj;
28875 wxWindow *arg1 = (wxWindow *) 0 ;
28876 PyObject * obj0 = 0 ;
28877 char *kwnames[] = {
28878 (char *) "self", NULL
28879 };
28880
28881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28883 if (SWIG_arg_fail(1)) SWIG_fail;
28884 {
28885 PyThreadState* __tstate = wxPyBeginAllowThreads();
28886 (arg1)->Update();
28887
28888 wxPyEndAllowThreads(__tstate);
28889 if (PyErr_Occurred()) SWIG_fail;
28890 }
28891 Py_INCREF(Py_None); resultobj = Py_None;
28892 return resultobj;
28893 fail:
28894 return NULL;
28895 }
28896
28897
28898 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28899 PyObject *resultobj;
28900 wxWindow *arg1 = (wxWindow *) 0 ;
28901 PyObject * obj0 = 0 ;
28902 char *kwnames[] = {
28903 (char *) "self", NULL
28904 };
28905
28906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28908 if (SWIG_arg_fail(1)) SWIG_fail;
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 (arg1)->ClearBackground();
28912
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 Py_INCREF(Py_None); resultobj = Py_None;
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28924 PyObject *resultobj;
28925 wxWindow *arg1 = (wxWindow *) 0 ;
28926 PyObject * obj0 = 0 ;
28927 char *kwnames[] = {
28928 (char *) "self", NULL
28929 };
28930
28931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28933 if (SWIG_arg_fail(1)) SWIG_fail;
28934 {
28935 PyThreadState* __tstate = wxPyBeginAllowThreads();
28936 (arg1)->Freeze();
28937
28938 wxPyEndAllowThreads(__tstate);
28939 if (PyErr_Occurred()) SWIG_fail;
28940 }
28941 Py_INCREF(Py_None); resultobj = Py_None;
28942 return resultobj;
28943 fail:
28944 return NULL;
28945 }
28946
28947
28948 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28949 PyObject *resultobj;
28950 wxWindow *arg1 = (wxWindow *) 0 ;
28951 PyObject * obj0 = 0 ;
28952 char *kwnames[] = {
28953 (char *) "self", NULL
28954 };
28955
28956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28958 if (SWIG_arg_fail(1)) SWIG_fail;
28959 {
28960 PyThreadState* __tstate = wxPyBeginAllowThreads();
28961 (arg1)->Thaw();
28962
28963 wxPyEndAllowThreads(__tstate);
28964 if (PyErr_Occurred()) SWIG_fail;
28965 }
28966 Py_INCREF(Py_None); resultobj = Py_None;
28967 return resultobj;
28968 fail:
28969 return NULL;
28970 }
28971
28972
28973 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28974 PyObject *resultobj;
28975 wxWindow *arg1 = (wxWindow *) 0 ;
28976 wxDC *arg2 = 0 ;
28977 PyObject * obj0 = 0 ;
28978 PyObject * obj1 = 0 ;
28979 char *kwnames[] = {
28980 (char *) "self",(char *) "dc", NULL
28981 };
28982
28983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28985 if (SWIG_arg_fail(1)) SWIG_fail;
28986 {
28987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28988 if (SWIG_arg_fail(2)) SWIG_fail;
28989 if (arg2 == NULL) {
28990 SWIG_null_ref("wxDC");
28991 }
28992 if (SWIG_arg_fail(2)) SWIG_fail;
28993 }
28994 {
28995 PyThreadState* __tstate = wxPyBeginAllowThreads();
28996 (arg1)->PrepareDC(*arg2);
28997
28998 wxPyEndAllowThreads(__tstate);
28999 if (PyErr_Occurred()) SWIG_fail;
29000 }
29001 Py_INCREF(Py_None); resultobj = Py_None;
29002 return resultobj;
29003 fail:
29004 return NULL;
29005 }
29006
29007
29008 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29009 PyObject *resultobj;
29010 wxWindow *arg1 = (wxWindow *) 0 ;
29011 wxRegion *result;
29012 PyObject * obj0 = 0 ;
29013 char *kwnames[] = {
29014 (char *) "self", NULL
29015 };
29016
29017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29019 if (SWIG_arg_fail(1)) SWIG_fail;
29020 {
29021 PyThreadState* __tstate = wxPyBeginAllowThreads();
29022 {
29023 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29024 result = (wxRegion *) &_result_ref;
29025 }
29026
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29038 PyObject *resultobj;
29039 wxWindow *arg1 = (wxWindow *) 0 ;
29040 wxRect result;
29041 PyObject * obj0 = 0 ;
29042 char *kwnames[] = {
29043 (char *) "self", NULL
29044 };
29045
29046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29048 if (SWIG_arg_fail(1)) SWIG_fail;
29049 {
29050 PyThreadState* __tstate = wxPyBeginAllowThreads();
29051 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29052
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 {
29057 wxRect * resultptr;
29058 resultptr = new wxRect((wxRect &)(result));
29059 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29060 }
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29068 PyObject *resultobj;
29069 wxWindow *arg1 = (wxWindow *) 0 ;
29070 int arg2 ;
29071 int arg3 ;
29072 int arg4 = (int) 1 ;
29073 int arg5 = (int) 1 ;
29074 bool result;
29075 PyObject * obj0 = 0 ;
29076 PyObject * obj1 = 0 ;
29077 PyObject * obj2 = 0 ;
29078 PyObject * obj3 = 0 ;
29079 PyObject * obj4 = 0 ;
29080 char *kwnames[] = {
29081 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29082 };
29083
29084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29086 if (SWIG_arg_fail(1)) SWIG_fail;
29087 {
29088 arg2 = (int)(SWIG_As_int(obj1));
29089 if (SWIG_arg_fail(2)) SWIG_fail;
29090 }
29091 {
29092 arg3 = (int)(SWIG_As_int(obj2));
29093 if (SWIG_arg_fail(3)) SWIG_fail;
29094 }
29095 if (obj3) {
29096 {
29097 arg4 = (int)(SWIG_As_int(obj3));
29098 if (SWIG_arg_fail(4)) SWIG_fail;
29099 }
29100 }
29101 if (obj4) {
29102 {
29103 arg5 = (int)(SWIG_As_int(obj4));
29104 if (SWIG_arg_fail(5)) SWIG_fail;
29105 }
29106 }
29107 {
29108 PyThreadState* __tstate = wxPyBeginAllowThreads();
29109 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29110
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 {
29115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29116 }
29117 return resultobj;
29118 fail:
29119 return NULL;
29120 }
29121
29122
29123 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29124 PyObject *resultobj;
29125 wxWindow *arg1 = (wxWindow *) 0 ;
29126 wxPoint *arg2 = 0 ;
29127 bool result;
29128 wxPoint temp2 ;
29129 PyObject * obj0 = 0 ;
29130 PyObject * obj1 = 0 ;
29131 char *kwnames[] = {
29132 (char *) "self",(char *) "pt", NULL
29133 };
29134
29135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29137 if (SWIG_arg_fail(1)) SWIG_fail;
29138 {
29139 arg2 = &temp2;
29140 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29141 }
29142 {
29143 PyThreadState* __tstate = wxPyBeginAllowThreads();
29144 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29145
29146 wxPyEndAllowThreads(__tstate);
29147 if (PyErr_Occurred()) SWIG_fail;
29148 }
29149 {
29150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29151 }
29152 return resultobj;
29153 fail:
29154 return NULL;
29155 }
29156
29157
29158 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29159 PyObject *resultobj;
29160 wxWindow *arg1 = (wxWindow *) 0 ;
29161 wxRect *arg2 = 0 ;
29162 bool result;
29163 wxRect temp2 ;
29164 PyObject * obj0 = 0 ;
29165 PyObject * obj1 = 0 ;
29166 char *kwnames[] = {
29167 (char *) "self",(char *) "rect", NULL
29168 };
29169
29170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29172 if (SWIG_arg_fail(1)) SWIG_fail;
29173 {
29174 arg2 = &temp2;
29175 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29176 }
29177 {
29178 PyThreadState* __tstate = wxPyBeginAllowThreads();
29179 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29180
29181 wxPyEndAllowThreads(__tstate);
29182 if (PyErr_Occurred()) SWIG_fail;
29183 }
29184 {
29185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29186 }
29187 return resultobj;
29188 fail:
29189 return NULL;
29190 }
29191
29192
29193 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29194 PyObject *resultobj;
29195 wxWindow *arg1 = (wxWindow *) 0 ;
29196 wxVisualAttributes result;
29197 PyObject * obj0 = 0 ;
29198 char *kwnames[] = {
29199 (char *) "self", NULL
29200 };
29201
29202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29204 if (SWIG_arg_fail(1)) SWIG_fail;
29205 {
29206 PyThreadState* __tstate = wxPyBeginAllowThreads();
29207 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29208
29209 wxPyEndAllowThreads(__tstate);
29210 if (PyErr_Occurred()) SWIG_fail;
29211 }
29212 {
29213 wxVisualAttributes * resultptr;
29214 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29215 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29216 }
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29224 PyObject *resultobj;
29225 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29226 wxVisualAttributes result;
29227 PyObject * obj0 = 0 ;
29228 char *kwnames[] = {
29229 (char *) "variant", NULL
29230 };
29231
29232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29233 if (obj0) {
29234 {
29235 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29236 if (SWIG_arg_fail(1)) SWIG_fail;
29237 }
29238 }
29239 {
29240 if (!wxPyCheckForApp()) SWIG_fail;
29241 PyThreadState* __tstate = wxPyBeginAllowThreads();
29242 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29243
29244 wxPyEndAllowThreads(__tstate);
29245 if (PyErr_Occurred()) SWIG_fail;
29246 }
29247 {
29248 wxVisualAttributes * resultptr;
29249 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29250 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29251 }
29252 return resultobj;
29253 fail:
29254 return NULL;
29255 }
29256
29257
29258 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29259 PyObject *resultobj;
29260 wxWindow *arg1 = (wxWindow *) 0 ;
29261 wxColour *arg2 = 0 ;
29262 bool result;
29263 wxColour temp2 ;
29264 PyObject * obj0 = 0 ;
29265 PyObject * obj1 = 0 ;
29266 char *kwnames[] = {
29267 (char *) "self",(char *) "colour", NULL
29268 };
29269
29270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29272 if (SWIG_arg_fail(1)) SWIG_fail;
29273 {
29274 arg2 = &temp2;
29275 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29276 }
29277 {
29278 PyThreadState* __tstate = wxPyBeginAllowThreads();
29279 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29280
29281 wxPyEndAllowThreads(__tstate);
29282 if (PyErr_Occurred()) SWIG_fail;
29283 }
29284 {
29285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29286 }
29287 return resultobj;
29288 fail:
29289 return NULL;
29290 }
29291
29292
29293 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29294 PyObject *resultobj;
29295 wxWindow *arg1 = (wxWindow *) 0 ;
29296 wxColour *arg2 = 0 ;
29297 wxColour temp2 ;
29298 PyObject * obj0 = 0 ;
29299 PyObject * obj1 = 0 ;
29300 char *kwnames[] = {
29301 (char *) "self",(char *) "colour", NULL
29302 };
29303
29304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29306 if (SWIG_arg_fail(1)) SWIG_fail;
29307 {
29308 arg2 = &temp2;
29309 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29310 }
29311 {
29312 PyThreadState* __tstate = wxPyBeginAllowThreads();
29313 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29314
29315 wxPyEndAllowThreads(__tstate);
29316 if (PyErr_Occurred()) SWIG_fail;
29317 }
29318 Py_INCREF(Py_None); resultobj = Py_None;
29319 return resultobj;
29320 fail:
29321 return NULL;
29322 }
29323
29324
29325 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29326 PyObject *resultobj;
29327 wxWindow *arg1 = (wxWindow *) 0 ;
29328 wxColour *arg2 = 0 ;
29329 bool result;
29330 wxColour temp2 ;
29331 PyObject * obj0 = 0 ;
29332 PyObject * obj1 = 0 ;
29333 char *kwnames[] = {
29334 (char *) "self",(char *) "colour", NULL
29335 };
29336
29337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29339 if (SWIG_arg_fail(1)) SWIG_fail;
29340 {
29341 arg2 = &temp2;
29342 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29343 }
29344 {
29345 PyThreadState* __tstate = wxPyBeginAllowThreads();
29346 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29347
29348 wxPyEndAllowThreads(__tstate);
29349 if (PyErr_Occurred()) SWIG_fail;
29350 }
29351 {
29352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29353 }
29354 return resultobj;
29355 fail:
29356 return NULL;
29357 }
29358
29359
29360 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29361 PyObject *resultobj;
29362 wxWindow *arg1 = (wxWindow *) 0 ;
29363 wxColour *arg2 = 0 ;
29364 wxColour temp2 ;
29365 PyObject * obj0 = 0 ;
29366 PyObject * obj1 = 0 ;
29367 char *kwnames[] = {
29368 (char *) "self",(char *) "colour", NULL
29369 };
29370
29371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29373 if (SWIG_arg_fail(1)) SWIG_fail;
29374 {
29375 arg2 = &temp2;
29376 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29377 }
29378 {
29379 PyThreadState* __tstate = wxPyBeginAllowThreads();
29380 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29381
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 Py_INCREF(Py_None); resultobj = Py_None;
29386 return resultobj;
29387 fail:
29388 return NULL;
29389 }
29390
29391
29392 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29393 PyObject *resultobj;
29394 wxWindow *arg1 = (wxWindow *) 0 ;
29395 wxColour result;
29396 PyObject * obj0 = 0 ;
29397 char *kwnames[] = {
29398 (char *) "self", NULL
29399 };
29400
29401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29403 if (SWIG_arg_fail(1)) SWIG_fail;
29404 {
29405 PyThreadState* __tstate = wxPyBeginAllowThreads();
29406 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29407
29408 wxPyEndAllowThreads(__tstate);
29409 if (PyErr_Occurred()) SWIG_fail;
29410 }
29411 {
29412 wxColour * resultptr;
29413 resultptr = new wxColour((wxColour &)(result));
29414 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29415 }
29416 return resultobj;
29417 fail:
29418 return NULL;
29419 }
29420
29421
29422 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29423 PyObject *resultobj;
29424 wxWindow *arg1 = (wxWindow *) 0 ;
29425 wxColour result;
29426 PyObject * obj0 = 0 ;
29427 char *kwnames[] = {
29428 (char *) "self", NULL
29429 };
29430
29431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29433 if (SWIG_arg_fail(1)) SWIG_fail;
29434 {
29435 PyThreadState* __tstate = wxPyBeginAllowThreads();
29436 result = ((wxWindow const *)arg1)->GetForegroundColour();
29437
29438 wxPyEndAllowThreads(__tstate);
29439 if (PyErr_Occurred()) SWIG_fail;
29440 }
29441 {
29442 wxColour * resultptr;
29443 resultptr = new wxColour((wxColour &)(result));
29444 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29445 }
29446 return resultobj;
29447 fail:
29448 return NULL;
29449 }
29450
29451
29452 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29453 PyObject *resultobj;
29454 wxWindow *arg1 = (wxWindow *) 0 ;
29455 bool result;
29456 PyObject * obj0 = 0 ;
29457 char *kwnames[] = {
29458 (char *) "self", NULL
29459 };
29460
29461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29463 if (SWIG_arg_fail(1)) SWIG_fail;
29464 {
29465 PyThreadState* __tstate = wxPyBeginAllowThreads();
29466 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29467
29468 wxPyEndAllowThreads(__tstate);
29469 if (PyErr_Occurred()) SWIG_fail;
29470 }
29471 {
29472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29473 }
29474 return resultobj;
29475 fail:
29476 return NULL;
29477 }
29478
29479
29480 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29481 PyObject *resultobj;
29482 wxWindow *arg1 = (wxWindow *) 0 ;
29483 bool result;
29484 PyObject * obj0 = 0 ;
29485 char *kwnames[] = {
29486 (char *) "self", NULL
29487 };
29488
29489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29491 if (SWIG_arg_fail(1)) SWIG_fail;
29492 {
29493 PyThreadState* __tstate = wxPyBeginAllowThreads();
29494 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29495
29496 wxPyEndAllowThreads(__tstate);
29497 if (PyErr_Occurred()) SWIG_fail;
29498 }
29499 {
29500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29501 }
29502 return resultobj;
29503 fail:
29504 return NULL;
29505 }
29506
29507
29508 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29509 PyObject *resultobj;
29510 wxWindow *arg1 = (wxWindow *) 0 ;
29511 wxBackgroundStyle arg2 ;
29512 bool result;
29513 PyObject * obj0 = 0 ;
29514 PyObject * obj1 = 0 ;
29515 char *kwnames[] = {
29516 (char *) "self",(char *) "style", NULL
29517 };
29518
29519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29521 if (SWIG_arg_fail(1)) SWIG_fail;
29522 {
29523 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29524 if (SWIG_arg_fail(2)) SWIG_fail;
29525 }
29526 {
29527 PyThreadState* __tstate = wxPyBeginAllowThreads();
29528 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29529
29530 wxPyEndAllowThreads(__tstate);
29531 if (PyErr_Occurred()) SWIG_fail;
29532 }
29533 {
29534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29535 }
29536 return resultobj;
29537 fail:
29538 return NULL;
29539 }
29540
29541
29542 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29543 PyObject *resultobj;
29544 wxWindow *arg1 = (wxWindow *) 0 ;
29545 wxBackgroundStyle result;
29546 PyObject * obj0 = 0 ;
29547 char *kwnames[] = {
29548 (char *) "self", NULL
29549 };
29550
29551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29553 if (SWIG_arg_fail(1)) SWIG_fail;
29554 {
29555 PyThreadState* __tstate = wxPyBeginAllowThreads();
29556 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29557
29558 wxPyEndAllowThreads(__tstate);
29559 if (PyErr_Occurred()) SWIG_fail;
29560 }
29561 resultobj = SWIG_From_int((result));
29562 return resultobj;
29563 fail:
29564 return NULL;
29565 }
29566
29567
29568 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29569 PyObject *resultobj;
29570 wxWindow *arg1 = (wxWindow *) 0 ;
29571 bool result;
29572 PyObject * obj0 = 0 ;
29573 char *kwnames[] = {
29574 (char *) "self", NULL
29575 };
29576
29577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29579 if (SWIG_arg_fail(1)) SWIG_fail;
29580 {
29581 PyThreadState* __tstate = wxPyBeginAllowThreads();
29582 result = (bool)(arg1)->HasTransparentBackground();
29583
29584 wxPyEndAllowThreads(__tstate);
29585 if (PyErr_Occurred()) SWIG_fail;
29586 }
29587 {
29588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29589 }
29590 return resultobj;
29591 fail:
29592 return NULL;
29593 }
29594
29595
29596 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29597 PyObject *resultobj;
29598 wxWindow *arg1 = (wxWindow *) 0 ;
29599 wxCursor *arg2 = 0 ;
29600 bool result;
29601 PyObject * obj0 = 0 ;
29602 PyObject * obj1 = 0 ;
29603 char *kwnames[] = {
29604 (char *) "self",(char *) "cursor", NULL
29605 };
29606
29607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29609 if (SWIG_arg_fail(1)) SWIG_fail;
29610 {
29611 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29612 if (SWIG_arg_fail(2)) SWIG_fail;
29613 if (arg2 == NULL) {
29614 SWIG_null_ref("wxCursor");
29615 }
29616 if (SWIG_arg_fail(2)) SWIG_fail;
29617 }
29618 {
29619 PyThreadState* __tstate = wxPyBeginAllowThreads();
29620 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29621
29622 wxPyEndAllowThreads(__tstate);
29623 if (PyErr_Occurred()) SWIG_fail;
29624 }
29625 {
29626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29627 }
29628 return resultobj;
29629 fail:
29630 return NULL;
29631 }
29632
29633
29634 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29635 PyObject *resultobj;
29636 wxWindow *arg1 = (wxWindow *) 0 ;
29637 wxCursor result;
29638 PyObject * obj0 = 0 ;
29639 char *kwnames[] = {
29640 (char *) "self", NULL
29641 };
29642
29643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29645 if (SWIG_arg_fail(1)) SWIG_fail;
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 result = (arg1)->GetCursor();
29649
29650 wxPyEndAllowThreads(__tstate);
29651 if (PyErr_Occurred()) SWIG_fail;
29652 }
29653 {
29654 wxCursor * resultptr;
29655 resultptr = new wxCursor((wxCursor &)(result));
29656 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29657 }
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29665 PyObject *resultobj;
29666 wxWindow *arg1 = (wxWindow *) 0 ;
29667 wxFont *arg2 = 0 ;
29668 bool result;
29669 PyObject * obj0 = 0 ;
29670 PyObject * obj1 = 0 ;
29671 char *kwnames[] = {
29672 (char *) "self",(char *) "font", NULL
29673 };
29674
29675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29677 if (SWIG_arg_fail(1)) SWIG_fail;
29678 {
29679 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29680 if (SWIG_arg_fail(2)) SWIG_fail;
29681 if (arg2 == NULL) {
29682 SWIG_null_ref("wxFont");
29683 }
29684 if (SWIG_arg_fail(2)) SWIG_fail;
29685 }
29686 {
29687 PyThreadState* __tstate = wxPyBeginAllowThreads();
29688 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29689
29690 wxPyEndAllowThreads(__tstate);
29691 if (PyErr_Occurred()) SWIG_fail;
29692 }
29693 {
29694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29695 }
29696 return resultobj;
29697 fail:
29698 return NULL;
29699 }
29700
29701
29702 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29703 PyObject *resultobj;
29704 wxWindow *arg1 = (wxWindow *) 0 ;
29705 wxFont *arg2 = 0 ;
29706 PyObject * obj0 = 0 ;
29707 PyObject * obj1 = 0 ;
29708 char *kwnames[] = {
29709 (char *) "self",(char *) "font", NULL
29710 };
29711
29712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29714 if (SWIG_arg_fail(1)) SWIG_fail;
29715 {
29716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29717 if (SWIG_arg_fail(2)) SWIG_fail;
29718 if (arg2 == NULL) {
29719 SWIG_null_ref("wxFont");
29720 }
29721 if (SWIG_arg_fail(2)) SWIG_fail;
29722 }
29723 {
29724 PyThreadState* __tstate = wxPyBeginAllowThreads();
29725 (arg1)->SetOwnFont((wxFont const &)*arg2);
29726
29727 wxPyEndAllowThreads(__tstate);
29728 if (PyErr_Occurred()) SWIG_fail;
29729 }
29730 Py_INCREF(Py_None); resultobj = Py_None;
29731 return resultobj;
29732 fail:
29733 return NULL;
29734 }
29735
29736
29737 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29738 PyObject *resultobj;
29739 wxWindow *arg1 = (wxWindow *) 0 ;
29740 wxFont result;
29741 PyObject * obj0 = 0 ;
29742 char *kwnames[] = {
29743 (char *) "self", NULL
29744 };
29745
29746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29748 if (SWIG_arg_fail(1)) SWIG_fail;
29749 {
29750 PyThreadState* __tstate = wxPyBeginAllowThreads();
29751 result = (arg1)->GetFont();
29752
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 {
29757 wxFont * resultptr;
29758 resultptr = new wxFont((wxFont &)(result));
29759 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29760 }
29761 return resultobj;
29762 fail:
29763 return NULL;
29764 }
29765
29766
29767 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29768 PyObject *resultobj;
29769 wxWindow *arg1 = (wxWindow *) 0 ;
29770 wxCaret *arg2 = (wxCaret *) 0 ;
29771 PyObject * obj0 = 0 ;
29772 PyObject * obj1 = 0 ;
29773 char *kwnames[] = {
29774 (char *) "self",(char *) "caret", NULL
29775 };
29776
29777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29779 if (SWIG_arg_fail(1)) SWIG_fail;
29780 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29781 if (SWIG_arg_fail(2)) SWIG_fail;
29782 {
29783 PyThreadState* __tstate = wxPyBeginAllowThreads();
29784 (arg1)->SetCaret(arg2);
29785
29786 wxPyEndAllowThreads(__tstate);
29787 if (PyErr_Occurred()) SWIG_fail;
29788 }
29789 Py_INCREF(Py_None); resultobj = Py_None;
29790 return resultobj;
29791 fail:
29792 return NULL;
29793 }
29794
29795
29796 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29797 PyObject *resultobj;
29798 wxWindow *arg1 = (wxWindow *) 0 ;
29799 wxCaret *result;
29800 PyObject * obj0 = 0 ;
29801 char *kwnames[] = {
29802 (char *) "self", NULL
29803 };
29804
29805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29807 if (SWIG_arg_fail(1)) SWIG_fail;
29808 {
29809 PyThreadState* __tstate = wxPyBeginAllowThreads();
29810 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29811
29812 wxPyEndAllowThreads(__tstate);
29813 if (PyErr_Occurred()) SWIG_fail;
29814 }
29815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29816 return resultobj;
29817 fail:
29818 return NULL;
29819 }
29820
29821
29822 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29823 PyObject *resultobj;
29824 wxWindow *arg1 = (wxWindow *) 0 ;
29825 int result;
29826 PyObject * obj0 = 0 ;
29827 char *kwnames[] = {
29828 (char *) "self", NULL
29829 };
29830
29831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29833 if (SWIG_arg_fail(1)) SWIG_fail;
29834 {
29835 PyThreadState* __tstate = wxPyBeginAllowThreads();
29836 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29837
29838 wxPyEndAllowThreads(__tstate);
29839 if (PyErr_Occurred()) SWIG_fail;
29840 }
29841 {
29842 resultobj = SWIG_From_int((int)(result));
29843 }
29844 return resultobj;
29845 fail:
29846 return NULL;
29847 }
29848
29849
29850 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29851 PyObject *resultobj;
29852 wxWindow *arg1 = (wxWindow *) 0 ;
29853 int result;
29854 PyObject * obj0 = 0 ;
29855 char *kwnames[] = {
29856 (char *) "self", NULL
29857 };
29858
29859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29861 if (SWIG_arg_fail(1)) SWIG_fail;
29862 {
29863 PyThreadState* __tstate = wxPyBeginAllowThreads();
29864 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29865
29866 wxPyEndAllowThreads(__tstate);
29867 if (PyErr_Occurred()) SWIG_fail;
29868 }
29869 {
29870 resultobj = SWIG_From_int((int)(result));
29871 }
29872 return resultobj;
29873 fail:
29874 return NULL;
29875 }
29876
29877
29878 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29879 PyObject *resultobj;
29880 wxWindow *arg1 = (wxWindow *) 0 ;
29881 wxString *arg2 = 0 ;
29882 int *arg3 = (int *) 0 ;
29883 int *arg4 = (int *) 0 ;
29884 bool temp2 = false ;
29885 int temp3 ;
29886 int res3 = 0 ;
29887 int temp4 ;
29888 int res4 = 0 ;
29889 PyObject * obj0 = 0 ;
29890 PyObject * obj1 = 0 ;
29891 char *kwnames[] = {
29892 (char *) "self",(char *) "string", NULL
29893 };
29894
29895 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29896 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29899 if (SWIG_arg_fail(1)) SWIG_fail;
29900 {
29901 arg2 = wxString_in_helper(obj1);
29902 if (arg2 == NULL) SWIG_fail;
29903 temp2 = true;
29904 }
29905 {
29906 PyThreadState* __tstate = wxPyBeginAllowThreads();
29907 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29908
29909 wxPyEndAllowThreads(__tstate);
29910 if (PyErr_Occurred()) SWIG_fail;
29911 }
29912 Py_INCREF(Py_None); resultobj = Py_None;
29913 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29914 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29915 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29916 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29917 {
29918 if (temp2)
29919 delete arg2;
29920 }
29921 return resultobj;
29922 fail:
29923 {
29924 if (temp2)
29925 delete arg2;
29926 }
29927 return NULL;
29928 }
29929
29930
29931 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29932 PyObject *resultobj;
29933 wxWindow *arg1 = (wxWindow *) 0 ;
29934 wxString *arg2 = 0 ;
29935 int *arg3 = (int *) 0 ;
29936 int *arg4 = (int *) 0 ;
29937 int *arg5 = (int *) 0 ;
29938 int *arg6 = (int *) 0 ;
29939 wxFont *arg7 = (wxFont *) NULL ;
29940 bool temp2 = false ;
29941 int temp3 ;
29942 int res3 = 0 ;
29943 int temp4 ;
29944 int res4 = 0 ;
29945 int temp5 ;
29946 int res5 = 0 ;
29947 int temp6 ;
29948 int res6 = 0 ;
29949 PyObject * obj0 = 0 ;
29950 PyObject * obj1 = 0 ;
29951 PyObject * obj2 = 0 ;
29952 char *kwnames[] = {
29953 (char *) "self",(char *) "string",(char *) "font", NULL
29954 };
29955
29956 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29957 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29958 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29959 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29962 if (SWIG_arg_fail(1)) SWIG_fail;
29963 {
29964 arg2 = wxString_in_helper(obj1);
29965 if (arg2 == NULL) SWIG_fail;
29966 temp2 = true;
29967 }
29968 if (obj2) {
29969 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29970 if (SWIG_arg_fail(7)) SWIG_fail;
29971 }
29972 {
29973 PyThreadState* __tstate = wxPyBeginAllowThreads();
29974 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29975
29976 wxPyEndAllowThreads(__tstate);
29977 if (PyErr_Occurred()) SWIG_fail;
29978 }
29979 Py_INCREF(Py_None); resultobj = Py_None;
29980 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29981 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29982 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29983 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29984 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29985 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29986 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29987 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29988 {
29989 if (temp2)
29990 delete arg2;
29991 }
29992 return resultobj;
29993 fail:
29994 {
29995 if (temp2)
29996 delete arg2;
29997 }
29998 return NULL;
29999 }
30000
30001
30002 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30003 PyObject *resultobj;
30004 wxWindow *arg1 = (wxWindow *) 0 ;
30005 int *arg2 = (int *) 0 ;
30006 int *arg3 = (int *) 0 ;
30007 int temp2 ;
30008 int res2 = 0 ;
30009 int temp3 ;
30010 int res3 = 0 ;
30011 PyObject * obj0 = 0 ;
30012 PyObject * obj1 = 0 ;
30013 PyObject * obj2 = 0 ;
30014 char *kwnames[] = {
30015 (char *) "self",(char *) "x",(char *) "y", NULL
30016 };
30017
30018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30020 if (SWIG_arg_fail(1)) SWIG_fail;
30021 {
30022 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30023 temp2 = SWIG_As_int(obj1);
30024 if (SWIG_arg_fail(2)) SWIG_fail;
30025 arg2 = &temp2;
30026 res2 = SWIG_NEWOBJ;
30027 }
30028 }
30029 {
30030 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30031 temp3 = SWIG_As_int(obj2);
30032 if (SWIG_arg_fail(3)) SWIG_fail;
30033 arg3 = &temp3;
30034 res3 = SWIG_NEWOBJ;
30035 }
30036 }
30037 {
30038 PyThreadState* __tstate = wxPyBeginAllowThreads();
30039 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30040
30041 wxPyEndAllowThreads(__tstate);
30042 if (PyErr_Occurred()) SWIG_fail;
30043 }
30044 Py_INCREF(Py_None); resultobj = Py_None;
30045 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30046 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30047 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30048 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30049 return resultobj;
30050 fail:
30051 return NULL;
30052 }
30053
30054
30055 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30056 PyObject *resultobj;
30057 wxWindow *arg1 = (wxWindow *) 0 ;
30058 int *arg2 = (int *) 0 ;
30059 int *arg3 = (int *) 0 ;
30060 int temp2 ;
30061 int res2 = 0 ;
30062 int temp3 ;
30063 int res3 = 0 ;
30064 PyObject * obj0 = 0 ;
30065 PyObject * obj1 = 0 ;
30066 PyObject * obj2 = 0 ;
30067 char *kwnames[] = {
30068 (char *) "self",(char *) "x",(char *) "y", NULL
30069 };
30070
30071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30073 if (SWIG_arg_fail(1)) SWIG_fail;
30074 {
30075 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30076 temp2 = SWIG_As_int(obj1);
30077 if (SWIG_arg_fail(2)) SWIG_fail;
30078 arg2 = &temp2;
30079 res2 = SWIG_NEWOBJ;
30080 }
30081 }
30082 {
30083 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30084 temp3 = SWIG_As_int(obj2);
30085 if (SWIG_arg_fail(3)) SWIG_fail;
30086 arg3 = &temp3;
30087 res3 = SWIG_NEWOBJ;
30088 }
30089 }
30090 {
30091 PyThreadState* __tstate = wxPyBeginAllowThreads();
30092 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30093
30094 wxPyEndAllowThreads(__tstate);
30095 if (PyErr_Occurred()) SWIG_fail;
30096 }
30097 Py_INCREF(Py_None); resultobj = Py_None;
30098 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30099 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30100 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30101 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30102 return resultobj;
30103 fail:
30104 return NULL;
30105 }
30106
30107
30108 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30109 PyObject *resultobj;
30110 wxWindow *arg1 = (wxWindow *) 0 ;
30111 wxPoint *arg2 = 0 ;
30112 wxPoint result;
30113 wxPoint temp2 ;
30114 PyObject * obj0 = 0 ;
30115 PyObject * obj1 = 0 ;
30116 char *kwnames[] = {
30117 (char *) "self",(char *) "pt", NULL
30118 };
30119
30120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30122 if (SWIG_arg_fail(1)) SWIG_fail;
30123 {
30124 arg2 = &temp2;
30125 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30126 }
30127 {
30128 PyThreadState* __tstate = wxPyBeginAllowThreads();
30129 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30130
30131 wxPyEndAllowThreads(__tstate);
30132 if (PyErr_Occurred()) SWIG_fail;
30133 }
30134 {
30135 wxPoint * resultptr;
30136 resultptr = new wxPoint((wxPoint &)(result));
30137 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30138 }
30139 return resultobj;
30140 fail:
30141 return NULL;
30142 }
30143
30144
30145 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30146 PyObject *resultobj;
30147 wxWindow *arg1 = (wxWindow *) 0 ;
30148 wxPoint *arg2 = 0 ;
30149 wxPoint result;
30150 wxPoint temp2 ;
30151 PyObject * obj0 = 0 ;
30152 PyObject * obj1 = 0 ;
30153 char *kwnames[] = {
30154 (char *) "self",(char *) "pt", NULL
30155 };
30156
30157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30159 if (SWIG_arg_fail(1)) SWIG_fail;
30160 {
30161 arg2 = &temp2;
30162 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30163 }
30164 {
30165 PyThreadState* __tstate = wxPyBeginAllowThreads();
30166 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30167
30168 wxPyEndAllowThreads(__tstate);
30169 if (PyErr_Occurred()) SWIG_fail;
30170 }
30171 {
30172 wxPoint * resultptr;
30173 resultptr = new wxPoint((wxPoint &)(result));
30174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30175 }
30176 return resultobj;
30177 fail:
30178 return NULL;
30179 }
30180
30181
30182 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30183 PyObject *resultobj;
30184 wxWindow *arg1 = (wxWindow *) 0 ;
30185 int arg2 ;
30186 int arg3 ;
30187 wxHitTest result;
30188 PyObject * obj0 = 0 ;
30189 PyObject * obj1 = 0 ;
30190 PyObject * obj2 = 0 ;
30191 char *kwnames[] = {
30192 (char *) "self",(char *) "x",(char *) "y", NULL
30193 };
30194
30195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30197 if (SWIG_arg_fail(1)) SWIG_fail;
30198 {
30199 arg2 = (int)(SWIG_As_int(obj1));
30200 if (SWIG_arg_fail(2)) SWIG_fail;
30201 }
30202 {
30203 arg3 = (int)(SWIG_As_int(obj2));
30204 if (SWIG_arg_fail(3)) SWIG_fail;
30205 }
30206 {
30207 PyThreadState* __tstate = wxPyBeginAllowThreads();
30208 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30209
30210 wxPyEndAllowThreads(__tstate);
30211 if (PyErr_Occurred()) SWIG_fail;
30212 }
30213 resultobj = SWIG_From_int((result));
30214 return resultobj;
30215 fail:
30216 return NULL;
30217 }
30218
30219
30220 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30221 PyObject *resultobj;
30222 wxWindow *arg1 = (wxWindow *) 0 ;
30223 wxPoint *arg2 = 0 ;
30224 wxHitTest result;
30225 wxPoint temp2 ;
30226 PyObject * obj0 = 0 ;
30227 PyObject * obj1 = 0 ;
30228 char *kwnames[] = {
30229 (char *) "self",(char *) "pt", NULL
30230 };
30231
30232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30234 if (SWIG_arg_fail(1)) SWIG_fail;
30235 {
30236 arg2 = &temp2;
30237 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30238 }
30239 {
30240 PyThreadState* __tstate = wxPyBeginAllowThreads();
30241 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30242
30243 wxPyEndAllowThreads(__tstate);
30244 if (PyErr_Occurred()) SWIG_fail;
30245 }
30246 resultobj = SWIG_From_int((result));
30247 return resultobj;
30248 fail:
30249 return NULL;
30250 }
30251
30252
30253 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30254 PyObject *resultobj;
30255 wxWindow *arg1 = (wxWindow *) 0 ;
30256 long arg2 ;
30257 wxBorder result;
30258 PyObject * obj0 = 0 ;
30259 PyObject * obj1 = 0 ;
30260
30261 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30263 if (SWIG_arg_fail(1)) SWIG_fail;
30264 {
30265 arg2 = (long)(SWIG_As_long(obj1));
30266 if (SWIG_arg_fail(2)) SWIG_fail;
30267 }
30268 {
30269 PyThreadState* __tstate = wxPyBeginAllowThreads();
30270 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30271
30272 wxPyEndAllowThreads(__tstate);
30273 if (PyErr_Occurred()) SWIG_fail;
30274 }
30275 resultobj = SWIG_From_int((result));
30276 return resultobj;
30277 fail:
30278 return NULL;
30279 }
30280
30281
30282 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30283 PyObject *resultobj;
30284 wxWindow *arg1 = (wxWindow *) 0 ;
30285 wxBorder result;
30286 PyObject * obj0 = 0 ;
30287
30288 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30290 if (SWIG_arg_fail(1)) SWIG_fail;
30291 {
30292 PyThreadState* __tstate = wxPyBeginAllowThreads();
30293 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30294
30295 wxPyEndAllowThreads(__tstate);
30296 if (PyErr_Occurred()) SWIG_fail;
30297 }
30298 resultobj = SWIG_From_int((result));
30299 return resultobj;
30300 fail:
30301 return NULL;
30302 }
30303
30304
30305 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30306 int argc;
30307 PyObject *argv[3];
30308 int ii;
30309
30310 argc = PyObject_Length(args);
30311 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30312 argv[ii] = PyTuple_GetItem(args,ii);
30313 }
30314 if (argc == 1) {
30315 int _v;
30316 {
30317 void *ptr;
30318 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30319 _v = 0;
30320 PyErr_Clear();
30321 } else {
30322 _v = 1;
30323 }
30324 }
30325 if (_v) {
30326 return _wrap_Window_GetBorder__SWIG_1(self,args);
30327 }
30328 }
30329 if (argc == 2) {
30330 int _v;
30331 {
30332 void *ptr;
30333 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30334 _v = 0;
30335 PyErr_Clear();
30336 } else {
30337 _v = 1;
30338 }
30339 }
30340 if (_v) {
30341 _v = SWIG_Check_long(argv[1]);
30342 if (_v) {
30343 return _wrap_Window_GetBorder__SWIG_0(self,args);
30344 }
30345 }
30346 }
30347
30348 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30349 return NULL;
30350 }
30351
30352
30353 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30354 PyObject *resultobj;
30355 wxWindow *arg1 = (wxWindow *) 0 ;
30356 long arg2 = (long) wxUPDATE_UI_NONE ;
30357 PyObject * obj0 = 0 ;
30358 PyObject * obj1 = 0 ;
30359 char *kwnames[] = {
30360 (char *) "self",(char *) "flags", NULL
30361 };
30362
30363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30365 if (SWIG_arg_fail(1)) SWIG_fail;
30366 if (obj1) {
30367 {
30368 arg2 = (long)(SWIG_As_long(obj1));
30369 if (SWIG_arg_fail(2)) SWIG_fail;
30370 }
30371 }
30372 {
30373 PyThreadState* __tstate = wxPyBeginAllowThreads();
30374 (arg1)->UpdateWindowUI(arg2);
30375
30376 wxPyEndAllowThreads(__tstate);
30377 if (PyErr_Occurred()) SWIG_fail;
30378 }
30379 Py_INCREF(Py_None); resultobj = Py_None;
30380 return resultobj;
30381 fail:
30382 return NULL;
30383 }
30384
30385
30386 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30387 PyObject *resultobj;
30388 wxWindow *arg1 = (wxWindow *) 0 ;
30389 wxMenu *arg2 = (wxMenu *) 0 ;
30390 int arg3 = (int) -1 ;
30391 int arg4 = (int) -1 ;
30392 bool result;
30393 PyObject * obj0 = 0 ;
30394 PyObject * obj1 = 0 ;
30395 PyObject * obj2 = 0 ;
30396 PyObject * obj3 = 0 ;
30397 char *kwnames[] = {
30398 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30399 };
30400
30401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30403 if (SWIG_arg_fail(1)) SWIG_fail;
30404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30405 if (SWIG_arg_fail(2)) SWIG_fail;
30406 if (obj2) {
30407 {
30408 arg3 = (int)(SWIG_As_int(obj2));
30409 if (SWIG_arg_fail(3)) SWIG_fail;
30410 }
30411 }
30412 if (obj3) {
30413 {
30414 arg4 = (int)(SWIG_As_int(obj3));
30415 if (SWIG_arg_fail(4)) SWIG_fail;
30416 }
30417 }
30418 {
30419 PyThreadState* __tstate = wxPyBeginAllowThreads();
30420 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30421
30422 wxPyEndAllowThreads(__tstate);
30423 if (PyErr_Occurred()) SWIG_fail;
30424 }
30425 {
30426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30427 }
30428 return resultobj;
30429 fail:
30430 return NULL;
30431 }
30432
30433
30434 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30435 PyObject *resultobj;
30436 wxWindow *arg1 = (wxWindow *) 0 ;
30437 wxMenu *arg2 = (wxMenu *) 0 ;
30438 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30439 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30440 bool result;
30441 wxPoint temp3 ;
30442 PyObject * obj0 = 0 ;
30443 PyObject * obj1 = 0 ;
30444 PyObject * obj2 = 0 ;
30445 char *kwnames[] = {
30446 (char *) "self",(char *) "menu",(char *) "pos", NULL
30447 };
30448
30449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30451 if (SWIG_arg_fail(1)) SWIG_fail;
30452 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30453 if (SWIG_arg_fail(2)) SWIG_fail;
30454 if (obj2) {
30455 {
30456 arg3 = &temp3;
30457 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30458 }
30459 }
30460 {
30461 PyThreadState* __tstate = wxPyBeginAllowThreads();
30462 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30463
30464 wxPyEndAllowThreads(__tstate);
30465 if (PyErr_Occurred()) SWIG_fail;
30466 }
30467 {
30468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30469 }
30470 return resultobj;
30471 fail:
30472 return NULL;
30473 }
30474
30475
30476 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30477 PyObject *resultobj;
30478 wxWindow *arg1 = (wxWindow *) 0 ;
30479 long result;
30480 PyObject * obj0 = 0 ;
30481 char *kwnames[] = {
30482 (char *) "self", NULL
30483 };
30484
30485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30487 if (SWIG_arg_fail(1)) SWIG_fail;
30488 {
30489 PyThreadState* __tstate = wxPyBeginAllowThreads();
30490 result = (long)wxWindow_GetHandle(arg1);
30491
30492 wxPyEndAllowThreads(__tstate);
30493 if (PyErr_Occurred()) SWIG_fail;
30494 }
30495 {
30496 resultobj = SWIG_From_long((long)(result));
30497 }
30498 return resultobj;
30499 fail:
30500 return NULL;
30501 }
30502
30503
30504 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30505 PyObject *resultobj;
30506 wxWindow *arg1 = (wxWindow *) 0 ;
30507 long arg2 ;
30508 PyObject * obj0 = 0 ;
30509 PyObject * obj1 = 0 ;
30510 char *kwnames[] = {
30511 (char *) "self",(char *) "handle", NULL
30512 };
30513
30514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30516 if (SWIG_arg_fail(1)) SWIG_fail;
30517 {
30518 arg2 = (long)(SWIG_As_long(obj1));
30519 if (SWIG_arg_fail(2)) SWIG_fail;
30520 }
30521 {
30522 PyThreadState* __tstate = wxPyBeginAllowThreads();
30523 wxWindow_AssociateHandle(arg1,arg2);
30524
30525 wxPyEndAllowThreads(__tstate);
30526 if (PyErr_Occurred()) SWIG_fail;
30527 }
30528 Py_INCREF(Py_None); resultobj = Py_None;
30529 return resultobj;
30530 fail:
30531 return NULL;
30532 }
30533
30534
30535 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30536 PyObject *resultobj;
30537 wxWindow *arg1 = (wxWindow *) 0 ;
30538 PyObject * obj0 = 0 ;
30539 char *kwnames[] = {
30540 (char *) "self", NULL
30541 };
30542
30543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30545 if (SWIG_arg_fail(1)) SWIG_fail;
30546 {
30547 PyThreadState* __tstate = wxPyBeginAllowThreads();
30548 (arg1)->DissociateHandle();
30549
30550 wxPyEndAllowThreads(__tstate);
30551 if (PyErr_Occurred()) SWIG_fail;
30552 }
30553 Py_INCREF(Py_None); resultobj = Py_None;
30554 return resultobj;
30555 fail:
30556 return NULL;
30557 }
30558
30559
30560 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30561 PyObject *resultobj;
30562 wxWindow *arg1 = (wxWindow *) 0 ;
30563 int arg2 ;
30564 bool result;
30565 PyObject * obj0 = 0 ;
30566 PyObject * obj1 = 0 ;
30567 char *kwnames[] = {
30568 (char *) "self",(char *) "orient", NULL
30569 };
30570
30571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30573 if (SWIG_arg_fail(1)) SWIG_fail;
30574 {
30575 arg2 = (int)(SWIG_As_int(obj1));
30576 if (SWIG_arg_fail(2)) SWIG_fail;
30577 }
30578 {
30579 PyThreadState* __tstate = wxPyBeginAllowThreads();
30580 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30581
30582 wxPyEndAllowThreads(__tstate);
30583 if (PyErr_Occurred()) SWIG_fail;
30584 }
30585 {
30586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30587 }
30588 return resultobj;
30589 fail:
30590 return NULL;
30591 }
30592
30593
30594 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30595 PyObject *resultobj;
30596 wxWindow *arg1 = (wxWindow *) 0 ;
30597 int arg2 ;
30598 int arg3 ;
30599 int arg4 ;
30600 int arg5 ;
30601 bool arg6 = (bool) true ;
30602 PyObject * obj0 = 0 ;
30603 PyObject * obj1 = 0 ;
30604 PyObject * obj2 = 0 ;
30605 PyObject * obj3 = 0 ;
30606 PyObject * obj4 = 0 ;
30607 PyObject * obj5 = 0 ;
30608 char *kwnames[] = {
30609 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30610 };
30611
30612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30614 if (SWIG_arg_fail(1)) SWIG_fail;
30615 {
30616 arg2 = (int)(SWIG_As_int(obj1));
30617 if (SWIG_arg_fail(2)) SWIG_fail;
30618 }
30619 {
30620 arg3 = (int)(SWIG_As_int(obj2));
30621 if (SWIG_arg_fail(3)) SWIG_fail;
30622 }
30623 {
30624 arg4 = (int)(SWIG_As_int(obj3));
30625 if (SWIG_arg_fail(4)) SWIG_fail;
30626 }
30627 {
30628 arg5 = (int)(SWIG_As_int(obj4));
30629 if (SWIG_arg_fail(5)) SWIG_fail;
30630 }
30631 if (obj5) {
30632 {
30633 arg6 = (bool)(SWIG_As_bool(obj5));
30634 if (SWIG_arg_fail(6)) SWIG_fail;
30635 }
30636 }
30637 {
30638 PyThreadState* __tstate = wxPyBeginAllowThreads();
30639 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30640
30641 wxPyEndAllowThreads(__tstate);
30642 if (PyErr_Occurred()) SWIG_fail;
30643 }
30644 Py_INCREF(Py_None); resultobj = Py_None;
30645 return resultobj;
30646 fail:
30647 return NULL;
30648 }
30649
30650
30651 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30652 PyObject *resultobj;
30653 wxWindow *arg1 = (wxWindow *) 0 ;
30654 int arg2 ;
30655 int arg3 ;
30656 bool arg4 = (bool) true ;
30657 PyObject * obj0 = 0 ;
30658 PyObject * obj1 = 0 ;
30659 PyObject * obj2 = 0 ;
30660 PyObject * obj3 = 0 ;
30661 char *kwnames[] = {
30662 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30663 };
30664
30665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30667 if (SWIG_arg_fail(1)) SWIG_fail;
30668 {
30669 arg2 = (int)(SWIG_As_int(obj1));
30670 if (SWIG_arg_fail(2)) SWIG_fail;
30671 }
30672 {
30673 arg3 = (int)(SWIG_As_int(obj2));
30674 if (SWIG_arg_fail(3)) SWIG_fail;
30675 }
30676 if (obj3) {
30677 {
30678 arg4 = (bool)(SWIG_As_bool(obj3));
30679 if (SWIG_arg_fail(4)) SWIG_fail;
30680 }
30681 }
30682 {
30683 PyThreadState* __tstate = wxPyBeginAllowThreads();
30684 (arg1)->SetScrollPos(arg2,arg3,arg4);
30685
30686 wxPyEndAllowThreads(__tstate);
30687 if (PyErr_Occurred()) SWIG_fail;
30688 }
30689 Py_INCREF(Py_None); resultobj = Py_None;
30690 return resultobj;
30691 fail:
30692 return NULL;
30693 }
30694
30695
30696 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30697 PyObject *resultobj;
30698 wxWindow *arg1 = (wxWindow *) 0 ;
30699 int arg2 ;
30700 int result;
30701 PyObject * obj0 = 0 ;
30702 PyObject * obj1 = 0 ;
30703 char *kwnames[] = {
30704 (char *) "self",(char *) "orientation", NULL
30705 };
30706
30707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30709 if (SWIG_arg_fail(1)) SWIG_fail;
30710 {
30711 arg2 = (int)(SWIG_As_int(obj1));
30712 if (SWIG_arg_fail(2)) SWIG_fail;
30713 }
30714 {
30715 PyThreadState* __tstate = wxPyBeginAllowThreads();
30716 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30717
30718 wxPyEndAllowThreads(__tstate);
30719 if (PyErr_Occurred()) SWIG_fail;
30720 }
30721 {
30722 resultobj = SWIG_From_int((int)(result));
30723 }
30724 return resultobj;
30725 fail:
30726 return NULL;
30727 }
30728
30729
30730 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30731 PyObject *resultobj;
30732 wxWindow *arg1 = (wxWindow *) 0 ;
30733 int arg2 ;
30734 int result;
30735 PyObject * obj0 = 0 ;
30736 PyObject * obj1 = 0 ;
30737 char *kwnames[] = {
30738 (char *) "self",(char *) "orientation", NULL
30739 };
30740
30741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30743 if (SWIG_arg_fail(1)) SWIG_fail;
30744 {
30745 arg2 = (int)(SWIG_As_int(obj1));
30746 if (SWIG_arg_fail(2)) SWIG_fail;
30747 }
30748 {
30749 PyThreadState* __tstate = wxPyBeginAllowThreads();
30750 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30751
30752 wxPyEndAllowThreads(__tstate);
30753 if (PyErr_Occurred()) SWIG_fail;
30754 }
30755 {
30756 resultobj = SWIG_From_int((int)(result));
30757 }
30758 return resultobj;
30759 fail:
30760 return NULL;
30761 }
30762
30763
30764 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30765 PyObject *resultobj;
30766 wxWindow *arg1 = (wxWindow *) 0 ;
30767 int arg2 ;
30768 int result;
30769 PyObject * obj0 = 0 ;
30770 PyObject * obj1 = 0 ;
30771 char *kwnames[] = {
30772 (char *) "self",(char *) "orientation", NULL
30773 };
30774
30775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30777 if (SWIG_arg_fail(1)) SWIG_fail;
30778 {
30779 arg2 = (int)(SWIG_As_int(obj1));
30780 if (SWIG_arg_fail(2)) SWIG_fail;
30781 }
30782 {
30783 PyThreadState* __tstate = wxPyBeginAllowThreads();
30784 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30785
30786 wxPyEndAllowThreads(__tstate);
30787 if (PyErr_Occurred()) SWIG_fail;
30788 }
30789 {
30790 resultobj = SWIG_From_int((int)(result));
30791 }
30792 return resultobj;
30793 fail:
30794 return NULL;
30795 }
30796
30797
30798 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30799 PyObject *resultobj;
30800 wxWindow *arg1 = (wxWindow *) 0 ;
30801 int arg2 ;
30802 int arg3 ;
30803 wxRect *arg4 = (wxRect *) NULL ;
30804 PyObject * obj0 = 0 ;
30805 PyObject * obj1 = 0 ;
30806 PyObject * obj2 = 0 ;
30807 PyObject * obj3 = 0 ;
30808 char *kwnames[] = {
30809 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30810 };
30811
30812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30814 if (SWIG_arg_fail(1)) SWIG_fail;
30815 {
30816 arg2 = (int)(SWIG_As_int(obj1));
30817 if (SWIG_arg_fail(2)) SWIG_fail;
30818 }
30819 {
30820 arg3 = (int)(SWIG_As_int(obj2));
30821 if (SWIG_arg_fail(3)) SWIG_fail;
30822 }
30823 if (obj3) {
30824 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30825 if (SWIG_arg_fail(4)) SWIG_fail;
30826 }
30827 {
30828 PyThreadState* __tstate = wxPyBeginAllowThreads();
30829 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30830
30831 wxPyEndAllowThreads(__tstate);
30832 if (PyErr_Occurred()) SWIG_fail;
30833 }
30834 Py_INCREF(Py_None); resultobj = Py_None;
30835 return resultobj;
30836 fail:
30837 return NULL;
30838 }
30839
30840
30841 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30842 PyObject *resultobj;
30843 wxWindow *arg1 = (wxWindow *) 0 ;
30844 int arg2 ;
30845 bool result;
30846 PyObject * obj0 = 0 ;
30847 PyObject * obj1 = 0 ;
30848 char *kwnames[] = {
30849 (char *) "self",(char *) "lines", NULL
30850 };
30851
30852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30854 if (SWIG_arg_fail(1)) SWIG_fail;
30855 {
30856 arg2 = (int)(SWIG_As_int(obj1));
30857 if (SWIG_arg_fail(2)) SWIG_fail;
30858 }
30859 {
30860 PyThreadState* __tstate = wxPyBeginAllowThreads();
30861 result = (bool)(arg1)->ScrollLines(arg2);
30862
30863 wxPyEndAllowThreads(__tstate);
30864 if (PyErr_Occurred()) SWIG_fail;
30865 }
30866 {
30867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30868 }
30869 return resultobj;
30870 fail:
30871 return NULL;
30872 }
30873
30874
30875 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30876 PyObject *resultobj;
30877 wxWindow *arg1 = (wxWindow *) 0 ;
30878 int arg2 ;
30879 bool result;
30880 PyObject * obj0 = 0 ;
30881 PyObject * obj1 = 0 ;
30882 char *kwnames[] = {
30883 (char *) "self",(char *) "pages", NULL
30884 };
30885
30886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
30891 if (SWIG_arg_fail(2)) SWIG_fail;
30892 }
30893 {
30894 PyThreadState* __tstate = wxPyBeginAllowThreads();
30895 result = (bool)(arg1)->ScrollPages(arg2);
30896
30897 wxPyEndAllowThreads(__tstate);
30898 if (PyErr_Occurred()) SWIG_fail;
30899 }
30900 {
30901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30902 }
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30910 PyObject *resultobj;
30911 wxWindow *arg1 = (wxWindow *) 0 ;
30912 bool result;
30913 PyObject * obj0 = 0 ;
30914 char *kwnames[] = {
30915 (char *) "self", NULL
30916 };
30917
30918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30920 if (SWIG_arg_fail(1)) SWIG_fail;
30921 {
30922 PyThreadState* __tstate = wxPyBeginAllowThreads();
30923 result = (bool)(arg1)->LineUp();
30924
30925 wxPyEndAllowThreads(__tstate);
30926 if (PyErr_Occurred()) SWIG_fail;
30927 }
30928 {
30929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30930 }
30931 return resultobj;
30932 fail:
30933 return NULL;
30934 }
30935
30936
30937 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30938 PyObject *resultobj;
30939 wxWindow *arg1 = (wxWindow *) 0 ;
30940 bool result;
30941 PyObject * obj0 = 0 ;
30942 char *kwnames[] = {
30943 (char *) "self", NULL
30944 };
30945
30946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30948 if (SWIG_arg_fail(1)) SWIG_fail;
30949 {
30950 PyThreadState* __tstate = wxPyBeginAllowThreads();
30951 result = (bool)(arg1)->LineDown();
30952
30953 wxPyEndAllowThreads(__tstate);
30954 if (PyErr_Occurred()) SWIG_fail;
30955 }
30956 {
30957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30958 }
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30966 PyObject *resultobj;
30967 wxWindow *arg1 = (wxWindow *) 0 ;
30968 bool result;
30969 PyObject * obj0 = 0 ;
30970 char *kwnames[] = {
30971 (char *) "self", NULL
30972 };
30973
30974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30976 if (SWIG_arg_fail(1)) SWIG_fail;
30977 {
30978 PyThreadState* __tstate = wxPyBeginAllowThreads();
30979 result = (bool)(arg1)->PageUp();
30980
30981 wxPyEndAllowThreads(__tstate);
30982 if (PyErr_Occurred()) SWIG_fail;
30983 }
30984 {
30985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30986 }
30987 return resultobj;
30988 fail:
30989 return NULL;
30990 }
30991
30992
30993 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30994 PyObject *resultobj;
30995 wxWindow *arg1 = (wxWindow *) 0 ;
30996 bool result;
30997 PyObject * obj0 = 0 ;
30998 char *kwnames[] = {
30999 (char *) "self", NULL
31000 };
31001
31002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31004 if (SWIG_arg_fail(1)) SWIG_fail;
31005 {
31006 PyThreadState* __tstate = wxPyBeginAllowThreads();
31007 result = (bool)(arg1)->PageDown();
31008
31009 wxPyEndAllowThreads(__tstate);
31010 if (PyErr_Occurred()) SWIG_fail;
31011 }
31012 {
31013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31014 }
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31022 PyObject *resultobj;
31023 wxWindow *arg1 = (wxWindow *) 0 ;
31024 wxString *arg2 = 0 ;
31025 bool temp2 = false ;
31026 PyObject * obj0 = 0 ;
31027 PyObject * obj1 = 0 ;
31028 char *kwnames[] = {
31029 (char *) "self",(char *) "text", NULL
31030 };
31031
31032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31034 if (SWIG_arg_fail(1)) SWIG_fail;
31035 {
31036 arg2 = wxString_in_helper(obj1);
31037 if (arg2 == NULL) SWIG_fail;
31038 temp2 = true;
31039 }
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 (arg1)->SetHelpText((wxString const &)*arg2);
31043
31044 wxPyEndAllowThreads(__tstate);
31045 if (PyErr_Occurred()) SWIG_fail;
31046 }
31047 Py_INCREF(Py_None); resultobj = Py_None;
31048 {
31049 if (temp2)
31050 delete arg2;
31051 }
31052 return resultobj;
31053 fail:
31054 {
31055 if (temp2)
31056 delete arg2;
31057 }
31058 return NULL;
31059 }
31060
31061
31062 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31063 PyObject *resultobj;
31064 wxWindow *arg1 = (wxWindow *) 0 ;
31065 wxString *arg2 = 0 ;
31066 bool temp2 = false ;
31067 PyObject * obj0 = 0 ;
31068 PyObject * obj1 = 0 ;
31069 char *kwnames[] = {
31070 (char *) "self",(char *) "text", NULL
31071 };
31072
31073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31075 if (SWIG_arg_fail(1)) SWIG_fail;
31076 {
31077 arg2 = wxString_in_helper(obj1);
31078 if (arg2 == NULL) SWIG_fail;
31079 temp2 = true;
31080 }
31081 {
31082 PyThreadState* __tstate = wxPyBeginAllowThreads();
31083 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31084
31085 wxPyEndAllowThreads(__tstate);
31086 if (PyErr_Occurred()) SWIG_fail;
31087 }
31088 Py_INCREF(Py_None); resultobj = Py_None;
31089 {
31090 if (temp2)
31091 delete arg2;
31092 }
31093 return resultobj;
31094 fail:
31095 {
31096 if (temp2)
31097 delete arg2;
31098 }
31099 return NULL;
31100 }
31101
31102
31103 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31104 PyObject *resultobj;
31105 wxWindow *arg1 = (wxWindow *) 0 ;
31106 wxString result;
31107 PyObject * obj0 = 0 ;
31108 char *kwnames[] = {
31109 (char *) "self", NULL
31110 };
31111
31112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31114 if (SWIG_arg_fail(1)) SWIG_fail;
31115 {
31116 PyThreadState* __tstate = wxPyBeginAllowThreads();
31117 result = ((wxWindow const *)arg1)->GetHelpText();
31118
31119 wxPyEndAllowThreads(__tstate);
31120 if (PyErr_Occurred()) SWIG_fail;
31121 }
31122 {
31123 #if wxUSE_UNICODE
31124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31125 #else
31126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31127 #endif
31128 }
31129 return resultobj;
31130 fail:
31131 return NULL;
31132 }
31133
31134
31135 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31136 PyObject *resultobj;
31137 wxWindow *arg1 = (wxWindow *) 0 ;
31138 wxString *arg2 = 0 ;
31139 bool temp2 = false ;
31140 PyObject * obj0 = 0 ;
31141 PyObject * obj1 = 0 ;
31142 char *kwnames[] = {
31143 (char *) "self",(char *) "tip", NULL
31144 };
31145
31146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31148 if (SWIG_arg_fail(1)) SWIG_fail;
31149 {
31150 arg2 = wxString_in_helper(obj1);
31151 if (arg2 == NULL) SWIG_fail;
31152 temp2 = true;
31153 }
31154 {
31155 PyThreadState* __tstate = wxPyBeginAllowThreads();
31156 (arg1)->SetToolTip((wxString const &)*arg2);
31157
31158 wxPyEndAllowThreads(__tstate);
31159 if (PyErr_Occurred()) SWIG_fail;
31160 }
31161 Py_INCREF(Py_None); resultobj = Py_None;
31162 {
31163 if (temp2)
31164 delete arg2;
31165 }
31166 return resultobj;
31167 fail:
31168 {
31169 if (temp2)
31170 delete arg2;
31171 }
31172 return NULL;
31173 }
31174
31175
31176 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31177 PyObject *resultobj;
31178 wxWindow *arg1 = (wxWindow *) 0 ;
31179 wxToolTip *arg2 = (wxToolTip *) 0 ;
31180 PyObject * obj0 = 0 ;
31181 PyObject * obj1 = 0 ;
31182 char *kwnames[] = {
31183 (char *) "self",(char *) "tip", NULL
31184 };
31185
31186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31188 if (SWIG_arg_fail(1)) SWIG_fail;
31189 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31190 if (SWIG_arg_fail(2)) SWIG_fail;
31191 {
31192 PyThreadState* __tstate = wxPyBeginAllowThreads();
31193 (arg1)->SetToolTip(arg2);
31194
31195 wxPyEndAllowThreads(__tstate);
31196 if (PyErr_Occurred()) SWIG_fail;
31197 }
31198 Py_INCREF(Py_None); resultobj = Py_None;
31199 return resultobj;
31200 fail:
31201 return NULL;
31202 }
31203
31204
31205 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31206 PyObject *resultobj;
31207 wxWindow *arg1 = (wxWindow *) 0 ;
31208 wxToolTip *result;
31209 PyObject * obj0 = 0 ;
31210 char *kwnames[] = {
31211 (char *) "self", NULL
31212 };
31213
31214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31216 if (SWIG_arg_fail(1)) SWIG_fail;
31217 {
31218 PyThreadState* __tstate = wxPyBeginAllowThreads();
31219 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31220
31221 wxPyEndAllowThreads(__tstate);
31222 if (PyErr_Occurred()) SWIG_fail;
31223 }
31224 {
31225 resultobj = wxPyMake_wxObject(result, 0);
31226 }
31227 return resultobj;
31228 fail:
31229 return NULL;
31230 }
31231
31232
31233 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31234 PyObject *resultobj;
31235 wxWindow *arg1 = (wxWindow *) 0 ;
31236 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31237 PyObject * obj0 = 0 ;
31238 PyObject * obj1 = 0 ;
31239 char *kwnames[] = {
31240 (char *) "self",(char *) "dropTarget", NULL
31241 };
31242
31243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31247 if (SWIG_arg_fail(2)) SWIG_fail;
31248 {
31249 PyThreadState* __tstate = wxPyBeginAllowThreads();
31250 (arg1)->SetDropTarget(arg2);
31251
31252 wxPyEndAllowThreads(__tstate);
31253 if (PyErr_Occurred()) SWIG_fail;
31254 }
31255 Py_INCREF(Py_None); resultobj = Py_None;
31256 return resultobj;
31257 fail:
31258 return NULL;
31259 }
31260
31261
31262 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31263 PyObject *resultobj;
31264 wxWindow *arg1 = (wxWindow *) 0 ;
31265 wxPyDropTarget *result;
31266 PyObject * obj0 = 0 ;
31267 char *kwnames[] = {
31268 (char *) "self", NULL
31269 };
31270
31271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31273 if (SWIG_arg_fail(1)) SWIG_fail;
31274 {
31275 PyThreadState* __tstate = wxPyBeginAllowThreads();
31276 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31277
31278 wxPyEndAllowThreads(__tstate);
31279 if (PyErr_Occurred()) SWIG_fail;
31280 }
31281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31282 return resultobj;
31283 fail:
31284 return NULL;
31285 }
31286
31287
31288 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31289 PyObject *resultobj;
31290 wxWindow *arg1 = (wxWindow *) 0 ;
31291 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31292 PyObject * obj0 = 0 ;
31293 PyObject * obj1 = 0 ;
31294 char *kwnames[] = {
31295 (char *) "self",(char *) "constraints", NULL
31296 };
31297
31298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31300 if (SWIG_arg_fail(1)) SWIG_fail;
31301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31302 if (SWIG_arg_fail(2)) SWIG_fail;
31303 {
31304 PyThreadState* __tstate = wxPyBeginAllowThreads();
31305 (arg1)->SetConstraints(arg2);
31306
31307 wxPyEndAllowThreads(__tstate);
31308 if (PyErr_Occurred()) SWIG_fail;
31309 }
31310 Py_INCREF(Py_None); resultobj = Py_None;
31311 return resultobj;
31312 fail:
31313 return NULL;
31314 }
31315
31316
31317 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31318 PyObject *resultobj;
31319 wxWindow *arg1 = (wxWindow *) 0 ;
31320 wxLayoutConstraints *result;
31321 PyObject * obj0 = 0 ;
31322 char *kwnames[] = {
31323 (char *) "self", NULL
31324 };
31325
31326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31328 if (SWIG_arg_fail(1)) SWIG_fail;
31329 {
31330 PyThreadState* __tstate = wxPyBeginAllowThreads();
31331 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31332
31333 wxPyEndAllowThreads(__tstate);
31334 if (PyErr_Occurred()) SWIG_fail;
31335 }
31336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31337 return resultobj;
31338 fail:
31339 return NULL;
31340 }
31341
31342
31343 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31344 PyObject *resultobj;
31345 wxWindow *arg1 = (wxWindow *) 0 ;
31346 bool arg2 ;
31347 PyObject * obj0 = 0 ;
31348 PyObject * obj1 = 0 ;
31349 char *kwnames[] = {
31350 (char *) "self",(char *) "autoLayout", NULL
31351 };
31352
31353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31355 if (SWIG_arg_fail(1)) SWIG_fail;
31356 {
31357 arg2 = (bool)(SWIG_As_bool(obj1));
31358 if (SWIG_arg_fail(2)) SWIG_fail;
31359 }
31360 {
31361 PyThreadState* __tstate = wxPyBeginAllowThreads();
31362 (arg1)->SetAutoLayout(arg2);
31363
31364 wxPyEndAllowThreads(__tstate);
31365 if (PyErr_Occurred()) SWIG_fail;
31366 }
31367 Py_INCREF(Py_None); resultobj = Py_None;
31368 return resultobj;
31369 fail:
31370 return NULL;
31371 }
31372
31373
31374 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31375 PyObject *resultobj;
31376 wxWindow *arg1 = (wxWindow *) 0 ;
31377 bool result;
31378 PyObject * obj0 = 0 ;
31379 char *kwnames[] = {
31380 (char *) "self", NULL
31381 };
31382
31383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31385 if (SWIG_arg_fail(1)) SWIG_fail;
31386 {
31387 PyThreadState* __tstate = wxPyBeginAllowThreads();
31388 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31389
31390 wxPyEndAllowThreads(__tstate);
31391 if (PyErr_Occurred()) SWIG_fail;
31392 }
31393 {
31394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31395 }
31396 return resultobj;
31397 fail:
31398 return NULL;
31399 }
31400
31401
31402 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31403 PyObject *resultobj;
31404 wxWindow *arg1 = (wxWindow *) 0 ;
31405 bool result;
31406 PyObject * obj0 = 0 ;
31407 char *kwnames[] = {
31408 (char *) "self", NULL
31409 };
31410
31411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31413 if (SWIG_arg_fail(1)) SWIG_fail;
31414 {
31415 PyThreadState* __tstate = wxPyBeginAllowThreads();
31416 result = (bool)(arg1)->Layout();
31417
31418 wxPyEndAllowThreads(__tstate);
31419 if (PyErr_Occurred()) SWIG_fail;
31420 }
31421 {
31422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31423 }
31424 return resultobj;
31425 fail:
31426 return NULL;
31427 }
31428
31429
31430 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31431 PyObject *resultobj;
31432 wxWindow *arg1 = (wxWindow *) 0 ;
31433 wxSizer *arg2 = (wxSizer *) 0 ;
31434 bool arg3 = (bool) true ;
31435 PyObject * obj0 = 0 ;
31436 PyObject * obj1 = 0 ;
31437 PyObject * obj2 = 0 ;
31438 char *kwnames[] = {
31439 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31440 };
31441
31442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31444 if (SWIG_arg_fail(1)) SWIG_fail;
31445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31446 if (SWIG_arg_fail(2)) SWIG_fail;
31447 if (obj2) {
31448 {
31449 arg3 = (bool)(SWIG_As_bool(obj2));
31450 if (SWIG_arg_fail(3)) SWIG_fail;
31451 }
31452 }
31453 {
31454 PyThreadState* __tstate = wxPyBeginAllowThreads();
31455 (arg1)->SetSizer(arg2,arg3);
31456
31457 wxPyEndAllowThreads(__tstate);
31458 if (PyErr_Occurred()) SWIG_fail;
31459 }
31460 Py_INCREF(Py_None); resultobj = Py_None;
31461 return resultobj;
31462 fail:
31463 return NULL;
31464 }
31465
31466
31467 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31468 PyObject *resultobj;
31469 wxWindow *arg1 = (wxWindow *) 0 ;
31470 wxSizer *arg2 = (wxSizer *) 0 ;
31471 bool arg3 = (bool) true ;
31472 PyObject * obj0 = 0 ;
31473 PyObject * obj1 = 0 ;
31474 PyObject * obj2 = 0 ;
31475 char *kwnames[] = {
31476 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31477 };
31478
31479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31481 if (SWIG_arg_fail(1)) SWIG_fail;
31482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31483 if (SWIG_arg_fail(2)) SWIG_fail;
31484 if (obj2) {
31485 {
31486 arg3 = (bool)(SWIG_As_bool(obj2));
31487 if (SWIG_arg_fail(3)) SWIG_fail;
31488 }
31489 }
31490 {
31491 PyThreadState* __tstate = wxPyBeginAllowThreads();
31492 (arg1)->SetSizerAndFit(arg2,arg3);
31493
31494 wxPyEndAllowThreads(__tstate);
31495 if (PyErr_Occurred()) SWIG_fail;
31496 }
31497 Py_INCREF(Py_None); resultobj = Py_None;
31498 return resultobj;
31499 fail:
31500 return NULL;
31501 }
31502
31503
31504 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31505 PyObject *resultobj;
31506 wxWindow *arg1 = (wxWindow *) 0 ;
31507 wxSizer *result;
31508 PyObject * obj0 = 0 ;
31509 char *kwnames[] = {
31510 (char *) "self", NULL
31511 };
31512
31513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31515 if (SWIG_arg_fail(1)) SWIG_fail;
31516 {
31517 PyThreadState* __tstate = wxPyBeginAllowThreads();
31518 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31519
31520 wxPyEndAllowThreads(__tstate);
31521 if (PyErr_Occurred()) SWIG_fail;
31522 }
31523 {
31524 resultobj = wxPyMake_wxSizer(result, 0);
31525 }
31526 return resultobj;
31527 fail:
31528 return NULL;
31529 }
31530
31531
31532 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31533 PyObject *resultobj;
31534 wxWindow *arg1 = (wxWindow *) 0 ;
31535 wxSizer *arg2 = (wxSizer *) 0 ;
31536 PyObject * obj0 = 0 ;
31537 PyObject * obj1 = 0 ;
31538 char *kwnames[] = {
31539 (char *) "self",(char *) "sizer", NULL
31540 };
31541
31542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31544 if (SWIG_arg_fail(1)) SWIG_fail;
31545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31546 if (SWIG_arg_fail(2)) SWIG_fail;
31547 {
31548 PyThreadState* __tstate = wxPyBeginAllowThreads();
31549 (arg1)->SetContainingSizer(arg2);
31550
31551 wxPyEndAllowThreads(__tstate);
31552 if (PyErr_Occurred()) SWIG_fail;
31553 }
31554 Py_INCREF(Py_None); resultobj = Py_None;
31555 return resultobj;
31556 fail:
31557 return NULL;
31558 }
31559
31560
31561 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31562 PyObject *resultobj;
31563 wxWindow *arg1 = (wxWindow *) 0 ;
31564 wxSizer *result;
31565 PyObject * obj0 = 0 ;
31566 char *kwnames[] = {
31567 (char *) "self", NULL
31568 };
31569
31570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31572 if (SWIG_arg_fail(1)) SWIG_fail;
31573 {
31574 PyThreadState* __tstate = wxPyBeginAllowThreads();
31575 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31576
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 {
31581 resultobj = wxPyMake_wxSizer(result, 0);
31582 }
31583 return resultobj;
31584 fail:
31585 return NULL;
31586 }
31587
31588
31589 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31590 PyObject *resultobj;
31591 wxWindow *arg1 = (wxWindow *) 0 ;
31592 PyObject * obj0 = 0 ;
31593 char *kwnames[] = {
31594 (char *) "self", NULL
31595 };
31596
31597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31599 if (SWIG_arg_fail(1)) SWIG_fail;
31600 {
31601 PyThreadState* __tstate = wxPyBeginAllowThreads();
31602 (arg1)->InheritAttributes();
31603
31604 wxPyEndAllowThreads(__tstate);
31605 if (PyErr_Occurred()) SWIG_fail;
31606 }
31607 Py_INCREF(Py_None); resultobj = Py_None;
31608 return resultobj;
31609 fail:
31610 return NULL;
31611 }
31612
31613
31614 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31615 PyObject *resultobj;
31616 wxWindow *arg1 = (wxWindow *) 0 ;
31617 bool result;
31618 PyObject * obj0 = 0 ;
31619 char *kwnames[] = {
31620 (char *) "self", NULL
31621 };
31622
31623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31625 if (SWIG_arg_fail(1)) SWIG_fail;
31626 {
31627 PyThreadState* __tstate = wxPyBeginAllowThreads();
31628 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31629
31630 wxPyEndAllowThreads(__tstate);
31631 if (PyErr_Occurred()) SWIG_fail;
31632 }
31633 {
31634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31635 }
31636 return resultobj;
31637 fail:
31638 return NULL;
31639 }
31640
31641
31642 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31643 PyObject *obj;
31644 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31645 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31646 Py_INCREF(obj);
31647 return Py_BuildValue((char *)"");
31648 }
31649 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31650 PyObject *resultobj;
31651 long arg1 ;
31652 wxWindow *arg2 = (wxWindow *) NULL ;
31653 wxWindow *result;
31654 PyObject * obj0 = 0 ;
31655 PyObject * obj1 = 0 ;
31656 char *kwnames[] = {
31657 (char *) "id",(char *) "parent", NULL
31658 };
31659
31660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31661 {
31662 arg1 = (long)(SWIG_As_long(obj0));
31663 if (SWIG_arg_fail(1)) SWIG_fail;
31664 }
31665 if (obj1) {
31666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31667 if (SWIG_arg_fail(2)) SWIG_fail;
31668 }
31669 {
31670 if (!wxPyCheckForApp()) SWIG_fail;
31671 PyThreadState* __tstate = wxPyBeginAllowThreads();
31672 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31673
31674 wxPyEndAllowThreads(__tstate);
31675 if (PyErr_Occurred()) SWIG_fail;
31676 }
31677 {
31678 resultobj = wxPyMake_wxObject(result, 0);
31679 }
31680 return resultobj;
31681 fail:
31682 return NULL;
31683 }
31684
31685
31686 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31687 PyObject *resultobj;
31688 wxString *arg1 = 0 ;
31689 wxWindow *arg2 = (wxWindow *) NULL ;
31690 wxWindow *result;
31691 bool temp1 = false ;
31692 PyObject * obj0 = 0 ;
31693 PyObject * obj1 = 0 ;
31694 char *kwnames[] = {
31695 (char *) "name",(char *) "parent", NULL
31696 };
31697
31698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31699 {
31700 arg1 = wxString_in_helper(obj0);
31701 if (arg1 == NULL) SWIG_fail;
31702 temp1 = true;
31703 }
31704 if (obj1) {
31705 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31706 if (SWIG_arg_fail(2)) SWIG_fail;
31707 }
31708 {
31709 if (!wxPyCheckForApp()) SWIG_fail;
31710 PyThreadState* __tstate = wxPyBeginAllowThreads();
31711 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31712
31713 wxPyEndAllowThreads(__tstate);
31714 if (PyErr_Occurred()) SWIG_fail;
31715 }
31716 {
31717 resultobj = wxPyMake_wxObject(result, 0);
31718 }
31719 {
31720 if (temp1)
31721 delete arg1;
31722 }
31723 return resultobj;
31724 fail:
31725 {
31726 if (temp1)
31727 delete arg1;
31728 }
31729 return NULL;
31730 }
31731
31732
31733 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31734 PyObject *resultobj;
31735 wxString *arg1 = 0 ;
31736 wxWindow *arg2 = (wxWindow *) NULL ;
31737 wxWindow *result;
31738 bool temp1 = false ;
31739 PyObject * obj0 = 0 ;
31740 PyObject * obj1 = 0 ;
31741 char *kwnames[] = {
31742 (char *) "label",(char *) "parent", NULL
31743 };
31744
31745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31746 {
31747 arg1 = wxString_in_helper(obj0);
31748 if (arg1 == NULL) SWIG_fail;
31749 temp1 = true;
31750 }
31751 if (obj1) {
31752 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31753 if (SWIG_arg_fail(2)) SWIG_fail;
31754 }
31755 {
31756 if (!wxPyCheckForApp()) SWIG_fail;
31757 PyThreadState* __tstate = wxPyBeginAllowThreads();
31758 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31759
31760 wxPyEndAllowThreads(__tstate);
31761 if (PyErr_Occurred()) SWIG_fail;
31762 }
31763 {
31764 resultobj = wxPyMake_wxObject(result, 0);
31765 }
31766 {
31767 if (temp1)
31768 delete arg1;
31769 }
31770 return resultobj;
31771 fail:
31772 {
31773 if (temp1)
31774 delete arg1;
31775 }
31776 return NULL;
31777 }
31778
31779
31780 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31781 PyObject *resultobj;
31782 wxWindow *arg1 = (wxWindow *) 0 ;
31783 unsigned long arg2 ;
31784 wxWindow *result;
31785 PyObject * obj0 = 0 ;
31786 PyObject * obj1 = 0 ;
31787 char *kwnames[] = {
31788 (char *) "parent",(char *) "_hWnd", NULL
31789 };
31790
31791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31793 if (SWIG_arg_fail(1)) SWIG_fail;
31794 {
31795 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31796 if (SWIG_arg_fail(2)) SWIG_fail;
31797 }
31798 {
31799 PyThreadState* __tstate = wxPyBeginAllowThreads();
31800 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31801
31802 wxPyEndAllowThreads(__tstate);
31803 if (PyErr_Occurred()) SWIG_fail;
31804 }
31805 {
31806 resultobj = wxPyMake_wxObject(result, 0);
31807 }
31808 return resultobj;
31809 fail:
31810 return NULL;
31811 }
31812
31813
31814 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31815 PyObject *resultobj;
31816 wxValidator *result;
31817 char *kwnames[] = {
31818 NULL
31819 };
31820
31821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31822 {
31823 PyThreadState* __tstate = wxPyBeginAllowThreads();
31824 result = (wxValidator *)new wxValidator();
31825
31826 wxPyEndAllowThreads(__tstate);
31827 if (PyErr_Occurred()) SWIG_fail;
31828 }
31829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31830 return resultobj;
31831 fail:
31832 return NULL;
31833 }
31834
31835
31836 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31837 PyObject *resultobj;
31838 wxValidator *arg1 = (wxValidator *) 0 ;
31839 wxValidator *result;
31840 PyObject * obj0 = 0 ;
31841 char *kwnames[] = {
31842 (char *) "self", NULL
31843 };
31844
31845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31847 if (SWIG_arg_fail(1)) SWIG_fail;
31848 {
31849 PyThreadState* __tstate = wxPyBeginAllowThreads();
31850 result = (wxValidator *)(arg1)->Clone();
31851
31852 wxPyEndAllowThreads(__tstate);
31853 if (PyErr_Occurred()) SWIG_fail;
31854 }
31855 {
31856 resultobj = wxPyMake_wxObject(result, 0);
31857 }
31858 return resultobj;
31859 fail:
31860 return NULL;
31861 }
31862
31863
31864 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31865 PyObject *resultobj;
31866 wxValidator *arg1 = (wxValidator *) 0 ;
31867 wxWindow *arg2 = (wxWindow *) 0 ;
31868 bool result;
31869 PyObject * obj0 = 0 ;
31870 PyObject * obj1 = 0 ;
31871 char *kwnames[] = {
31872 (char *) "self",(char *) "parent", NULL
31873 };
31874
31875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31877 if (SWIG_arg_fail(1)) SWIG_fail;
31878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31879 if (SWIG_arg_fail(2)) SWIG_fail;
31880 {
31881 PyThreadState* __tstate = wxPyBeginAllowThreads();
31882 result = (bool)(arg1)->Validate(arg2);
31883
31884 wxPyEndAllowThreads(__tstate);
31885 if (PyErr_Occurred()) SWIG_fail;
31886 }
31887 {
31888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31889 }
31890 return resultobj;
31891 fail:
31892 return NULL;
31893 }
31894
31895
31896 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31897 PyObject *resultobj;
31898 wxValidator *arg1 = (wxValidator *) 0 ;
31899 bool result;
31900 PyObject * obj0 = 0 ;
31901 char *kwnames[] = {
31902 (char *) "self", NULL
31903 };
31904
31905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31907 if (SWIG_arg_fail(1)) SWIG_fail;
31908 {
31909 PyThreadState* __tstate = wxPyBeginAllowThreads();
31910 result = (bool)(arg1)->TransferToWindow();
31911
31912 wxPyEndAllowThreads(__tstate);
31913 if (PyErr_Occurred()) SWIG_fail;
31914 }
31915 {
31916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31917 }
31918 return resultobj;
31919 fail:
31920 return NULL;
31921 }
31922
31923
31924 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31925 PyObject *resultobj;
31926 wxValidator *arg1 = (wxValidator *) 0 ;
31927 bool result;
31928 PyObject * obj0 = 0 ;
31929 char *kwnames[] = {
31930 (char *) "self", NULL
31931 };
31932
31933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31935 if (SWIG_arg_fail(1)) SWIG_fail;
31936 {
31937 PyThreadState* __tstate = wxPyBeginAllowThreads();
31938 result = (bool)(arg1)->TransferFromWindow();
31939
31940 wxPyEndAllowThreads(__tstate);
31941 if (PyErr_Occurred()) SWIG_fail;
31942 }
31943 {
31944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31945 }
31946 return resultobj;
31947 fail:
31948 return NULL;
31949 }
31950
31951
31952 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31953 PyObject *resultobj;
31954 wxValidator *arg1 = (wxValidator *) 0 ;
31955 wxWindow *result;
31956 PyObject * obj0 = 0 ;
31957 char *kwnames[] = {
31958 (char *) "self", NULL
31959 };
31960
31961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31963 if (SWIG_arg_fail(1)) SWIG_fail;
31964 {
31965 PyThreadState* __tstate = wxPyBeginAllowThreads();
31966 result = (wxWindow *)(arg1)->GetWindow();
31967
31968 wxPyEndAllowThreads(__tstate);
31969 if (PyErr_Occurred()) SWIG_fail;
31970 }
31971 {
31972 resultobj = wxPyMake_wxObject(result, 0);
31973 }
31974 return resultobj;
31975 fail:
31976 return NULL;
31977 }
31978
31979
31980 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31981 PyObject *resultobj;
31982 wxValidator *arg1 = (wxValidator *) 0 ;
31983 wxWindow *arg2 = (wxWindow *) 0 ;
31984 PyObject * obj0 = 0 ;
31985 PyObject * obj1 = 0 ;
31986 char *kwnames[] = {
31987 (char *) "self",(char *) "window", NULL
31988 };
31989
31990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31992 if (SWIG_arg_fail(1)) SWIG_fail;
31993 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31994 if (SWIG_arg_fail(2)) SWIG_fail;
31995 {
31996 PyThreadState* __tstate = wxPyBeginAllowThreads();
31997 (arg1)->SetWindow(arg2);
31998
31999 wxPyEndAllowThreads(__tstate);
32000 if (PyErr_Occurred()) SWIG_fail;
32001 }
32002 Py_INCREF(Py_None); resultobj = Py_None;
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32010 PyObject *resultobj;
32011 bool result;
32012 char *kwnames[] = {
32013 NULL
32014 };
32015
32016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 result = (bool)wxValidator::IsSilent();
32020
32021 wxPyEndAllowThreads(__tstate);
32022 if (PyErr_Occurred()) SWIG_fail;
32023 }
32024 {
32025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32026 }
32027 return resultobj;
32028 fail:
32029 return NULL;
32030 }
32031
32032
32033 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32034 PyObject *resultobj;
32035 int arg1 = (int) true ;
32036 PyObject * obj0 = 0 ;
32037 char *kwnames[] = {
32038 (char *) "doIt", NULL
32039 };
32040
32041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32042 if (obj0) {
32043 {
32044 arg1 = (int)(SWIG_As_int(obj0));
32045 if (SWIG_arg_fail(1)) SWIG_fail;
32046 }
32047 }
32048 {
32049 PyThreadState* __tstate = wxPyBeginAllowThreads();
32050 wxValidator::SetBellOnError(arg1);
32051
32052 wxPyEndAllowThreads(__tstate);
32053 if (PyErr_Occurred()) SWIG_fail;
32054 }
32055 Py_INCREF(Py_None); resultobj = Py_None;
32056 return resultobj;
32057 fail:
32058 return NULL;
32059 }
32060
32061
32062 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32063 PyObject *obj;
32064 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32065 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32066 Py_INCREF(obj);
32067 return Py_BuildValue((char *)"");
32068 }
32069 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32070 PyObject *resultobj;
32071 wxPyValidator *result;
32072 char *kwnames[] = {
32073 NULL
32074 };
32075
32076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32077 {
32078 PyThreadState* __tstate = wxPyBeginAllowThreads();
32079 result = (wxPyValidator *)new wxPyValidator();
32080
32081 wxPyEndAllowThreads(__tstate);
32082 if (PyErr_Occurred()) SWIG_fail;
32083 }
32084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32085 return resultobj;
32086 fail:
32087 return NULL;
32088 }
32089
32090
32091 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32092 PyObject *resultobj;
32093 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32094 PyObject *arg2 = (PyObject *) 0 ;
32095 PyObject *arg3 = (PyObject *) 0 ;
32096 int arg4 = (int) true ;
32097 PyObject * obj0 = 0 ;
32098 PyObject * obj1 = 0 ;
32099 PyObject * obj2 = 0 ;
32100 PyObject * obj3 = 0 ;
32101 char *kwnames[] = {
32102 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32103 };
32104
32105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32107 if (SWIG_arg_fail(1)) SWIG_fail;
32108 arg2 = obj1;
32109 arg3 = obj2;
32110 if (obj3) {
32111 {
32112 arg4 = (int)(SWIG_As_int(obj3));
32113 if (SWIG_arg_fail(4)) SWIG_fail;
32114 }
32115 }
32116 {
32117 PyThreadState* __tstate = wxPyBeginAllowThreads();
32118 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32119
32120 wxPyEndAllowThreads(__tstate);
32121 if (PyErr_Occurred()) SWIG_fail;
32122 }
32123 Py_INCREF(Py_None); resultobj = Py_None;
32124 return resultobj;
32125 fail:
32126 return NULL;
32127 }
32128
32129
32130 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32131 PyObject *obj;
32132 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32133 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32134 Py_INCREF(obj);
32135 return Py_BuildValue((char *)"");
32136 }
32137 static int _wrap_DefaultValidator_set(PyObject *) {
32138 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32139 return 1;
32140 }
32141
32142
32143 static PyObject *_wrap_DefaultValidator_get(void) {
32144 PyObject *pyobj;
32145
32146 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32147 return pyobj;
32148 }
32149
32150
32151 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32152 PyObject *resultobj;
32153 wxString const &arg1_defvalue = wxPyEmptyString ;
32154 wxString *arg1 = (wxString *) &arg1_defvalue ;
32155 long arg2 = (long) 0 ;
32156 wxMenu *result;
32157 bool temp1 = false ;
32158 PyObject * obj0 = 0 ;
32159 PyObject * obj1 = 0 ;
32160 char *kwnames[] = {
32161 (char *) "title",(char *) "style", NULL
32162 };
32163
32164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32165 if (obj0) {
32166 {
32167 arg1 = wxString_in_helper(obj0);
32168 if (arg1 == NULL) SWIG_fail;
32169 temp1 = true;
32170 }
32171 }
32172 if (obj1) {
32173 {
32174 arg2 = (long)(SWIG_As_long(obj1));
32175 if (SWIG_arg_fail(2)) SWIG_fail;
32176 }
32177 }
32178 {
32179 if (!wxPyCheckForApp()) SWIG_fail;
32180 PyThreadState* __tstate = wxPyBeginAllowThreads();
32181 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32182
32183 wxPyEndAllowThreads(__tstate);
32184 if (PyErr_Occurred()) SWIG_fail;
32185 }
32186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32187 {
32188 if (temp1)
32189 delete arg1;
32190 }
32191 return resultobj;
32192 fail:
32193 {
32194 if (temp1)
32195 delete arg1;
32196 }
32197 return NULL;
32198 }
32199
32200
32201 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32202 PyObject *resultobj;
32203 wxMenu *arg1 = (wxMenu *) 0 ;
32204 int arg2 ;
32205 wxString *arg3 = 0 ;
32206 wxString const &arg4_defvalue = wxPyEmptyString ;
32207 wxString *arg4 = (wxString *) &arg4_defvalue ;
32208 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32209 wxMenuItem *result;
32210 bool temp3 = false ;
32211 bool temp4 = false ;
32212 PyObject * obj0 = 0 ;
32213 PyObject * obj1 = 0 ;
32214 PyObject * obj2 = 0 ;
32215 PyObject * obj3 = 0 ;
32216 PyObject * obj4 = 0 ;
32217 char *kwnames[] = {
32218 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32219 };
32220
32221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32223 if (SWIG_arg_fail(1)) SWIG_fail;
32224 {
32225 arg2 = (int)(SWIG_As_int(obj1));
32226 if (SWIG_arg_fail(2)) SWIG_fail;
32227 }
32228 {
32229 arg3 = wxString_in_helper(obj2);
32230 if (arg3 == NULL) SWIG_fail;
32231 temp3 = true;
32232 }
32233 if (obj3) {
32234 {
32235 arg4 = wxString_in_helper(obj3);
32236 if (arg4 == NULL) SWIG_fail;
32237 temp4 = true;
32238 }
32239 }
32240 if (obj4) {
32241 {
32242 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32243 if (SWIG_arg_fail(5)) SWIG_fail;
32244 }
32245 }
32246 {
32247 PyThreadState* __tstate = wxPyBeginAllowThreads();
32248 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32249
32250 wxPyEndAllowThreads(__tstate);
32251 if (PyErr_Occurred()) SWIG_fail;
32252 }
32253 {
32254 resultobj = wxPyMake_wxObject(result, 0);
32255 }
32256 {
32257 if (temp3)
32258 delete arg3;
32259 }
32260 {
32261 if (temp4)
32262 delete arg4;
32263 }
32264 return resultobj;
32265 fail:
32266 {
32267 if (temp3)
32268 delete arg3;
32269 }
32270 {
32271 if (temp4)
32272 delete arg4;
32273 }
32274 return NULL;
32275 }
32276
32277
32278 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32279 PyObject *resultobj;
32280 wxMenu *arg1 = (wxMenu *) 0 ;
32281 wxMenuItem *result;
32282 PyObject * obj0 = 0 ;
32283 char *kwnames[] = {
32284 (char *) "self", NULL
32285 };
32286
32287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32289 if (SWIG_arg_fail(1)) SWIG_fail;
32290 {
32291 PyThreadState* __tstate = wxPyBeginAllowThreads();
32292 result = (wxMenuItem *)(arg1)->AppendSeparator();
32293
32294 wxPyEndAllowThreads(__tstate);
32295 if (PyErr_Occurred()) SWIG_fail;
32296 }
32297 {
32298 resultobj = wxPyMake_wxObject(result, 0);
32299 }
32300 return resultobj;
32301 fail:
32302 return NULL;
32303 }
32304
32305
32306 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32307 PyObject *resultobj;
32308 wxMenu *arg1 = (wxMenu *) 0 ;
32309 int arg2 ;
32310 wxString *arg3 = 0 ;
32311 wxString const &arg4_defvalue = wxPyEmptyString ;
32312 wxString *arg4 = (wxString *) &arg4_defvalue ;
32313 wxMenuItem *result;
32314 bool temp3 = false ;
32315 bool temp4 = false ;
32316 PyObject * obj0 = 0 ;
32317 PyObject * obj1 = 0 ;
32318 PyObject * obj2 = 0 ;
32319 PyObject * obj3 = 0 ;
32320 char *kwnames[] = {
32321 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32322 };
32323
32324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32326 if (SWIG_arg_fail(1)) SWIG_fail;
32327 {
32328 arg2 = (int)(SWIG_As_int(obj1));
32329 if (SWIG_arg_fail(2)) SWIG_fail;
32330 }
32331 {
32332 arg3 = wxString_in_helper(obj2);
32333 if (arg3 == NULL) SWIG_fail;
32334 temp3 = true;
32335 }
32336 if (obj3) {
32337 {
32338 arg4 = wxString_in_helper(obj3);
32339 if (arg4 == NULL) SWIG_fail;
32340 temp4 = true;
32341 }
32342 }
32343 {
32344 PyThreadState* __tstate = wxPyBeginAllowThreads();
32345 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32346
32347 wxPyEndAllowThreads(__tstate);
32348 if (PyErr_Occurred()) SWIG_fail;
32349 }
32350 {
32351 resultobj = wxPyMake_wxObject(result, 0);
32352 }
32353 {
32354 if (temp3)
32355 delete arg3;
32356 }
32357 {
32358 if (temp4)
32359 delete arg4;
32360 }
32361 return resultobj;
32362 fail:
32363 {
32364 if (temp3)
32365 delete arg3;
32366 }
32367 {
32368 if (temp4)
32369 delete arg4;
32370 }
32371 return NULL;
32372 }
32373
32374
32375 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32376 PyObject *resultobj;
32377 wxMenu *arg1 = (wxMenu *) 0 ;
32378 int arg2 ;
32379 wxString *arg3 = 0 ;
32380 wxString const &arg4_defvalue = wxPyEmptyString ;
32381 wxString *arg4 = (wxString *) &arg4_defvalue ;
32382 wxMenuItem *result;
32383 bool temp3 = false ;
32384 bool temp4 = false ;
32385 PyObject * obj0 = 0 ;
32386 PyObject * obj1 = 0 ;
32387 PyObject * obj2 = 0 ;
32388 PyObject * obj3 = 0 ;
32389 char *kwnames[] = {
32390 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32391 };
32392
32393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32395 if (SWIG_arg_fail(1)) SWIG_fail;
32396 {
32397 arg2 = (int)(SWIG_As_int(obj1));
32398 if (SWIG_arg_fail(2)) SWIG_fail;
32399 }
32400 {
32401 arg3 = wxString_in_helper(obj2);
32402 if (arg3 == NULL) SWIG_fail;
32403 temp3 = true;
32404 }
32405 if (obj3) {
32406 {
32407 arg4 = wxString_in_helper(obj3);
32408 if (arg4 == NULL) SWIG_fail;
32409 temp4 = true;
32410 }
32411 }
32412 {
32413 PyThreadState* __tstate = wxPyBeginAllowThreads();
32414 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32415
32416 wxPyEndAllowThreads(__tstate);
32417 if (PyErr_Occurred()) SWIG_fail;
32418 }
32419 {
32420 resultobj = wxPyMake_wxObject(result, 0);
32421 }
32422 {
32423 if (temp3)
32424 delete arg3;
32425 }
32426 {
32427 if (temp4)
32428 delete arg4;
32429 }
32430 return resultobj;
32431 fail:
32432 {
32433 if (temp3)
32434 delete arg3;
32435 }
32436 {
32437 if (temp4)
32438 delete arg4;
32439 }
32440 return NULL;
32441 }
32442
32443
32444 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32445 PyObject *resultobj;
32446 wxMenu *arg1 = (wxMenu *) 0 ;
32447 int arg2 ;
32448 wxString *arg3 = 0 ;
32449 wxMenu *arg4 = (wxMenu *) 0 ;
32450 wxString const &arg5_defvalue = wxPyEmptyString ;
32451 wxString *arg5 = (wxString *) &arg5_defvalue ;
32452 wxMenuItem *result;
32453 bool temp3 = false ;
32454 bool temp5 = false ;
32455 PyObject * obj0 = 0 ;
32456 PyObject * obj1 = 0 ;
32457 PyObject * obj2 = 0 ;
32458 PyObject * obj3 = 0 ;
32459 PyObject * obj4 = 0 ;
32460 char *kwnames[] = {
32461 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32462 };
32463
32464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32466 if (SWIG_arg_fail(1)) SWIG_fail;
32467 {
32468 arg2 = (int)(SWIG_As_int(obj1));
32469 if (SWIG_arg_fail(2)) SWIG_fail;
32470 }
32471 {
32472 arg3 = wxString_in_helper(obj2);
32473 if (arg3 == NULL) SWIG_fail;
32474 temp3 = true;
32475 }
32476 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32477 if (SWIG_arg_fail(4)) SWIG_fail;
32478 if (obj4) {
32479 {
32480 arg5 = wxString_in_helper(obj4);
32481 if (arg5 == NULL) SWIG_fail;
32482 temp5 = true;
32483 }
32484 }
32485 {
32486 PyThreadState* __tstate = wxPyBeginAllowThreads();
32487 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32488
32489 wxPyEndAllowThreads(__tstate);
32490 if (PyErr_Occurred()) SWIG_fail;
32491 }
32492 {
32493 resultobj = wxPyMake_wxObject(result, 0);
32494 }
32495 {
32496 if (temp3)
32497 delete arg3;
32498 }
32499 {
32500 if (temp5)
32501 delete arg5;
32502 }
32503 return resultobj;
32504 fail:
32505 {
32506 if (temp3)
32507 delete arg3;
32508 }
32509 {
32510 if (temp5)
32511 delete arg5;
32512 }
32513 return NULL;
32514 }
32515
32516
32517 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32518 PyObject *resultobj;
32519 wxMenu *arg1 = (wxMenu *) 0 ;
32520 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32521 wxMenuItem *result;
32522 PyObject * obj0 = 0 ;
32523 PyObject * obj1 = 0 ;
32524 char *kwnames[] = {
32525 (char *) "self",(char *) "item", NULL
32526 };
32527
32528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32530 if (SWIG_arg_fail(1)) SWIG_fail;
32531 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32532 if (SWIG_arg_fail(2)) SWIG_fail;
32533 {
32534 PyThreadState* __tstate = wxPyBeginAllowThreads();
32535 result = (wxMenuItem *)(arg1)->Append(arg2);
32536
32537 wxPyEndAllowThreads(__tstate);
32538 if (PyErr_Occurred()) SWIG_fail;
32539 }
32540 {
32541 resultobj = wxPyMake_wxObject(result, 0);
32542 }
32543 return resultobj;
32544 fail:
32545 return NULL;
32546 }
32547
32548
32549 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32550 PyObject *resultobj;
32551 wxMenu *arg1 = (wxMenu *) 0 ;
32552 PyObject * obj0 = 0 ;
32553 char *kwnames[] = {
32554 (char *) "self", NULL
32555 };
32556
32557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32559 if (SWIG_arg_fail(1)) SWIG_fail;
32560 {
32561 PyThreadState* __tstate = wxPyBeginAllowThreads();
32562 (arg1)->Break();
32563
32564 wxPyEndAllowThreads(__tstate);
32565 if (PyErr_Occurred()) SWIG_fail;
32566 }
32567 Py_INCREF(Py_None); resultobj = Py_None;
32568 return resultobj;
32569 fail:
32570 return NULL;
32571 }
32572
32573
32574 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32575 PyObject *resultobj;
32576 wxMenu *arg1 = (wxMenu *) 0 ;
32577 size_t arg2 ;
32578 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32579 wxMenuItem *result;
32580 PyObject * obj0 = 0 ;
32581 PyObject * obj1 = 0 ;
32582 PyObject * obj2 = 0 ;
32583 char *kwnames[] = {
32584 (char *) "self",(char *) "pos",(char *) "item", NULL
32585 };
32586
32587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32589 if (SWIG_arg_fail(1)) SWIG_fail;
32590 {
32591 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32592 if (SWIG_arg_fail(2)) SWIG_fail;
32593 }
32594 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32595 if (SWIG_arg_fail(3)) SWIG_fail;
32596 {
32597 PyThreadState* __tstate = wxPyBeginAllowThreads();
32598 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32599
32600 wxPyEndAllowThreads(__tstate);
32601 if (PyErr_Occurred()) SWIG_fail;
32602 }
32603 {
32604 resultobj = wxPyMake_wxObject(result, 0);
32605 }
32606 return resultobj;
32607 fail:
32608 return NULL;
32609 }
32610
32611
32612 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32613 PyObject *resultobj;
32614 wxMenu *arg1 = (wxMenu *) 0 ;
32615 size_t arg2 ;
32616 int arg3 ;
32617 wxString *arg4 = 0 ;
32618 wxString const &arg5_defvalue = wxPyEmptyString ;
32619 wxString *arg5 = (wxString *) &arg5_defvalue ;
32620 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32621 wxMenuItem *result;
32622 bool temp4 = false ;
32623 bool temp5 = false ;
32624 PyObject * obj0 = 0 ;
32625 PyObject * obj1 = 0 ;
32626 PyObject * obj2 = 0 ;
32627 PyObject * obj3 = 0 ;
32628 PyObject * obj4 = 0 ;
32629 PyObject * obj5 = 0 ;
32630 char *kwnames[] = {
32631 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32632 };
32633
32634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32636 if (SWIG_arg_fail(1)) SWIG_fail;
32637 {
32638 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32639 if (SWIG_arg_fail(2)) SWIG_fail;
32640 }
32641 {
32642 arg3 = (int)(SWIG_As_int(obj2));
32643 if (SWIG_arg_fail(3)) SWIG_fail;
32644 }
32645 {
32646 arg4 = wxString_in_helper(obj3);
32647 if (arg4 == NULL) SWIG_fail;
32648 temp4 = true;
32649 }
32650 if (obj4) {
32651 {
32652 arg5 = wxString_in_helper(obj4);
32653 if (arg5 == NULL) SWIG_fail;
32654 temp5 = true;
32655 }
32656 }
32657 if (obj5) {
32658 {
32659 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32660 if (SWIG_arg_fail(6)) SWIG_fail;
32661 }
32662 }
32663 {
32664 PyThreadState* __tstate = wxPyBeginAllowThreads();
32665 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32666
32667 wxPyEndAllowThreads(__tstate);
32668 if (PyErr_Occurred()) SWIG_fail;
32669 }
32670 {
32671 resultobj = wxPyMake_wxObject(result, 0);
32672 }
32673 {
32674 if (temp4)
32675 delete arg4;
32676 }
32677 {
32678 if (temp5)
32679 delete arg5;
32680 }
32681 return resultobj;
32682 fail:
32683 {
32684 if (temp4)
32685 delete arg4;
32686 }
32687 {
32688 if (temp5)
32689 delete arg5;
32690 }
32691 return NULL;
32692 }
32693
32694
32695 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32696 PyObject *resultobj;
32697 wxMenu *arg1 = (wxMenu *) 0 ;
32698 size_t arg2 ;
32699 wxMenuItem *result;
32700 PyObject * obj0 = 0 ;
32701 PyObject * obj1 = 0 ;
32702 char *kwnames[] = {
32703 (char *) "self",(char *) "pos", NULL
32704 };
32705
32706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32708 if (SWIG_arg_fail(1)) SWIG_fail;
32709 {
32710 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32711 if (SWIG_arg_fail(2)) SWIG_fail;
32712 }
32713 {
32714 PyThreadState* __tstate = wxPyBeginAllowThreads();
32715 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32716
32717 wxPyEndAllowThreads(__tstate);
32718 if (PyErr_Occurred()) SWIG_fail;
32719 }
32720 {
32721 resultobj = wxPyMake_wxObject(result, 0);
32722 }
32723 return resultobj;
32724 fail:
32725 return NULL;
32726 }
32727
32728
32729 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32730 PyObject *resultobj;
32731 wxMenu *arg1 = (wxMenu *) 0 ;
32732 size_t arg2 ;
32733 int arg3 ;
32734 wxString *arg4 = 0 ;
32735 wxString const &arg5_defvalue = wxPyEmptyString ;
32736 wxString *arg5 = (wxString *) &arg5_defvalue ;
32737 wxMenuItem *result;
32738 bool temp4 = false ;
32739 bool temp5 = false ;
32740 PyObject * obj0 = 0 ;
32741 PyObject * obj1 = 0 ;
32742 PyObject * obj2 = 0 ;
32743 PyObject * obj3 = 0 ;
32744 PyObject * obj4 = 0 ;
32745 char *kwnames[] = {
32746 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32747 };
32748
32749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32751 if (SWIG_arg_fail(1)) SWIG_fail;
32752 {
32753 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32754 if (SWIG_arg_fail(2)) SWIG_fail;
32755 }
32756 {
32757 arg3 = (int)(SWIG_As_int(obj2));
32758 if (SWIG_arg_fail(3)) SWIG_fail;
32759 }
32760 {
32761 arg4 = wxString_in_helper(obj3);
32762 if (arg4 == NULL) SWIG_fail;
32763 temp4 = true;
32764 }
32765 if (obj4) {
32766 {
32767 arg5 = wxString_in_helper(obj4);
32768 if (arg5 == NULL) SWIG_fail;
32769 temp5 = true;
32770 }
32771 }
32772 {
32773 PyThreadState* __tstate = wxPyBeginAllowThreads();
32774 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32775
32776 wxPyEndAllowThreads(__tstate);
32777 if (PyErr_Occurred()) SWIG_fail;
32778 }
32779 {
32780 resultobj = wxPyMake_wxObject(result, 0);
32781 }
32782 {
32783 if (temp4)
32784 delete arg4;
32785 }
32786 {
32787 if (temp5)
32788 delete arg5;
32789 }
32790 return resultobj;
32791 fail:
32792 {
32793 if (temp4)
32794 delete arg4;
32795 }
32796 {
32797 if (temp5)
32798 delete arg5;
32799 }
32800 return NULL;
32801 }
32802
32803
32804 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32805 PyObject *resultobj;
32806 wxMenu *arg1 = (wxMenu *) 0 ;
32807 size_t arg2 ;
32808 int arg3 ;
32809 wxString *arg4 = 0 ;
32810 wxString const &arg5_defvalue = wxPyEmptyString ;
32811 wxString *arg5 = (wxString *) &arg5_defvalue ;
32812 wxMenuItem *result;
32813 bool temp4 = false ;
32814 bool temp5 = false ;
32815 PyObject * obj0 = 0 ;
32816 PyObject * obj1 = 0 ;
32817 PyObject * obj2 = 0 ;
32818 PyObject * obj3 = 0 ;
32819 PyObject * obj4 = 0 ;
32820 char *kwnames[] = {
32821 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32822 };
32823
32824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32826 if (SWIG_arg_fail(1)) SWIG_fail;
32827 {
32828 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32829 if (SWIG_arg_fail(2)) SWIG_fail;
32830 }
32831 {
32832 arg3 = (int)(SWIG_As_int(obj2));
32833 if (SWIG_arg_fail(3)) SWIG_fail;
32834 }
32835 {
32836 arg4 = wxString_in_helper(obj3);
32837 if (arg4 == NULL) SWIG_fail;
32838 temp4 = true;
32839 }
32840 if (obj4) {
32841 {
32842 arg5 = wxString_in_helper(obj4);
32843 if (arg5 == NULL) SWIG_fail;
32844 temp5 = true;
32845 }
32846 }
32847 {
32848 PyThreadState* __tstate = wxPyBeginAllowThreads();
32849 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32850
32851 wxPyEndAllowThreads(__tstate);
32852 if (PyErr_Occurred()) SWIG_fail;
32853 }
32854 {
32855 resultobj = wxPyMake_wxObject(result, 0);
32856 }
32857 {
32858 if (temp4)
32859 delete arg4;
32860 }
32861 {
32862 if (temp5)
32863 delete arg5;
32864 }
32865 return resultobj;
32866 fail:
32867 {
32868 if (temp4)
32869 delete arg4;
32870 }
32871 {
32872 if (temp5)
32873 delete arg5;
32874 }
32875 return NULL;
32876 }
32877
32878
32879 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32880 PyObject *resultobj;
32881 wxMenu *arg1 = (wxMenu *) 0 ;
32882 size_t arg2 ;
32883 int arg3 ;
32884 wxString *arg4 = 0 ;
32885 wxMenu *arg5 = (wxMenu *) 0 ;
32886 wxString const &arg6_defvalue = wxPyEmptyString ;
32887 wxString *arg6 = (wxString *) &arg6_defvalue ;
32888 wxMenuItem *result;
32889 bool temp4 = false ;
32890 bool temp6 = false ;
32891 PyObject * obj0 = 0 ;
32892 PyObject * obj1 = 0 ;
32893 PyObject * obj2 = 0 ;
32894 PyObject * obj3 = 0 ;
32895 PyObject * obj4 = 0 ;
32896 PyObject * obj5 = 0 ;
32897 char *kwnames[] = {
32898 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32899 };
32900
32901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32903 if (SWIG_arg_fail(1)) SWIG_fail;
32904 {
32905 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32906 if (SWIG_arg_fail(2)) SWIG_fail;
32907 }
32908 {
32909 arg3 = (int)(SWIG_As_int(obj2));
32910 if (SWIG_arg_fail(3)) SWIG_fail;
32911 }
32912 {
32913 arg4 = wxString_in_helper(obj3);
32914 if (arg4 == NULL) SWIG_fail;
32915 temp4 = true;
32916 }
32917 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32918 if (SWIG_arg_fail(5)) SWIG_fail;
32919 if (obj5) {
32920 {
32921 arg6 = wxString_in_helper(obj5);
32922 if (arg6 == NULL) SWIG_fail;
32923 temp6 = true;
32924 }
32925 }
32926 {
32927 PyThreadState* __tstate = wxPyBeginAllowThreads();
32928 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32929
32930 wxPyEndAllowThreads(__tstate);
32931 if (PyErr_Occurred()) SWIG_fail;
32932 }
32933 {
32934 resultobj = wxPyMake_wxObject(result, 0);
32935 }
32936 {
32937 if (temp4)
32938 delete arg4;
32939 }
32940 {
32941 if (temp6)
32942 delete arg6;
32943 }
32944 return resultobj;
32945 fail:
32946 {
32947 if (temp4)
32948 delete arg4;
32949 }
32950 {
32951 if (temp6)
32952 delete arg6;
32953 }
32954 return NULL;
32955 }
32956
32957
32958 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32959 PyObject *resultobj;
32960 wxMenu *arg1 = (wxMenu *) 0 ;
32961 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32962 wxMenuItem *result;
32963 PyObject * obj0 = 0 ;
32964 PyObject * obj1 = 0 ;
32965 char *kwnames[] = {
32966 (char *) "self",(char *) "item", NULL
32967 };
32968
32969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32971 if (SWIG_arg_fail(1)) SWIG_fail;
32972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32973 if (SWIG_arg_fail(2)) SWIG_fail;
32974 {
32975 PyThreadState* __tstate = wxPyBeginAllowThreads();
32976 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32977
32978 wxPyEndAllowThreads(__tstate);
32979 if (PyErr_Occurred()) SWIG_fail;
32980 }
32981 {
32982 resultobj = wxPyMake_wxObject(result, 0);
32983 }
32984 return resultobj;
32985 fail:
32986 return NULL;
32987 }
32988
32989
32990 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32991 PyObject *resultobj;
32992 wxMenu *arg1 = (wxMenu *) 0 ;
32993 int arg2 ;
32994 wxString *arg3 = 0 ;
32995 wxString const &arg4_defvalue = wxPyEmptyString ;
32996 wxString *arg4 = (wxString *) &arg4_defvalue ;
32997 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32998 wxMenuItem *result;
32999 bool temp3 = false ;
33000 bool temp4 = false ;
33001 PyObject * obj0 = 0 ;
33002 PyObject * obj1 = 0 ;
33003 PyObject * obj2 = 0 ;
33004 PyObject * obj3 = 0 ;
33005 PyObject * obj4 = 0 ;
33006 char *kwnames[] = {
33007 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33008 };
33009
33010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33012 if (SWIG_arg_fail(1)) SWIG_fail;
33013 {
33014 arg2 = (int)(SWIG_As_int(obj1));
33015 if (SWIG_arg_fail(2)) SWIG_fail;
33016 }
33017 {
33018 arg3 = wxString_in_helper(obj2);
33019 if (arg3 == NULL) SWIG_fail;
33020 temp3 = true;
33021 }
33022 if (obj3) {
33023 {
33024 arg4 = wxString_in_helper(obj3);
33025 if (arg4 == NULL) SWIG_fail;
33026 temp4 = true;
33027 }
33028 }
33029 if (obj4) {
33030 {
33031 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33032 if (SWIG_arg_fail(5)) SWIG_fail;
33033 }
33034 }
33035 {
33036 PyThreadState* __tstate = wxPyBeginAllowThreads();
33037 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33038
33039 wxPyEndAllowThreads(__tstate);
33040 if (PyErr_Occurred()) SWIG_fail;
33041 }
33042 {
33043 resultobj = wxPyMake_wxObject(result, 0);
33044 }
33045 {
33046 if (temp3)
33047 delete arg3;
33048 }
33049 {
33050 if (temp4)
33051 delete arg4;
33052 }
33053 return resultobj;
33054 fail:
33055 {
33056 if (temp3)
33057 delete arg3;
33058 }
33059 {
33060 if (temp4)
33061 delete arg4;
33062 }
33063 return NULL;
33064 }
33065
33066
33067 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33068 PyObject *resultobj;
33069 wxMenu *arg1 = (wxMenu *) 0 ;
33070 wxMenuItem *result;
33071 PyObject * obj0 = 0 ;
33072 char *kwnames[] = {
33073 (char *) "self", NULL
33074 };
33075
33076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33078 if (SWIG_arg_fail(1)) SWIG_fail;
33079 {
33080 PyThreadState* __tstate = wxPyBeginAllowThreads();
33081 result = (wxMenuItem *)(arg1)->PrependSeparator();
33082
33083 wxPyEndAllowThreads(__tstate);
33084 if (PyErr_Occurred()) SWIG_fail;
33085 }
33086 {
33087 resultobj = wxPyMake_wxObject(result, 0);
33088 }
33089 return resultobj;
33090 fail:
33091 return NULL;
33092 }
33093
33094
33095 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33096 PyObject *resultobj;
33097 wxMenu *arg1 = (wxMenu *) 0 ;
33098 int arg2 ;
33099 wxString *arg3 = 0 ;
33100 wxString const &arg4_defvalue = wxPyEmptyString ;
33101 wxString *arg4 = (wxString *) &arg4_defvalue ;
33102 wxMenuItem *result;
33103 bool temp3 = false ;
33104 bool temp4 = false ;
33105 PyObject * obj0 = 0 ;
33106 PyObject * obj1 = 0 ;
33107 PyObject * obj2 = 0 ;
33108 PyObject * obj3 = 0 ;
33109 char *kwnames[] = {
33110 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33111 };
33112
33113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33115 if (SWIG_arg_fail(1)) SWIG_fail;
33116 {
33117 arg2 = (int)(SWIG_As_int(obj1));
33118 if (SWIG_arg_fail(2)) SWIG_fail;
33119 }
33120 {
33121 arg3 = wxString_in_helper(obj2);
33122 if (arg3 == NULL) SWIG_fail;
33123 temp3 = true;
33124 }
33125 if (obj3) {
33126 {
33127 arg4 = wxString_in_helper(obj3);
33128 if (arg4 == NULL) SWIG_fail;
33129 temp4 = true;
33130 }
33131 }
33132 {
33133 PyThreadState* __tstate = wxPyBeginAllowThreads();
33134 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33135
33136 wxPyEndAllowThreads(__tstate);
33137 if (PyErr_Occurred()) SWIG_fail;
33138 }
33139 {
33140 resultobj = wxPyMake_wxObject(result, 0);
33141 }
33142 {
33143 if (temp3)
33144 delete arg3;
33145 }
33146 {
33147 if (temp4)
33148 delete arg4;
33149 }
33150 return resultobj;
33151 fail:
33152 {
33153 if (temp3)
33154 delete arg3;
33155 }
33156 {
33157 if (temp4)
33158 delete arg4;
33159 }
33160 return NULL;
33161 }
33162
33163
33164 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33165 PyObject *resultobj;
33166 wxMenu *arg1 = (wxMenu *) 0 ;
33167 int arg2 ;
33168 wxString *arg3 = 0 ;
33169 wxString const &arg4_defvalue = wxPyEmptyString ;
33170 wxString *arg4 = (wxString *) &arg4_defvalue ;
33171 wxMenuItem *result;
33172 bool temp3 = false ;
33173 bool temp4 = false ;
33174 PyObject * obj0 = 0 ;
33175 PyObject * obj1 = 0 ;
33176 PyObject * obj2 = 0 ;
33177 PyObject * obj3 = 0 ;
33178 char *kwnames[] = {
33179 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33180 };
33181
33182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33184 if (SWIG_arg_fail(1)) SWIG_fail;
33185 {
33186 arg2 = (int)(SWIG_As_int(obj1));
33187 if (SWIG_arg_fail(2)) SWIG_fail;
33188 }
33189 {
33190 arg3 = wxString_in_helper(obj2);
33191 if (arg3 == NULL) SWIG_fail;
33192 temp3 = true;
33193 }
33194 if (obj3) {
33195 {
33196 arg4 = wxString_in_helper(obj3);
33197 if (arg4 == NULL) SWIG_fail;
33198 temp4 = true;
33199 }
33200 }
33201 {
33202 PyThreadState* __tstate = wxPyBeginAllowThreads();
33203 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33204
33205 wxPyEndAllowThreads(__tstate);
33206 if (PyErr_Occurred()) SWIG_fail;
33207 }
33208 {
33209 resultobj = wxPyMake_wxObject(result, 0);
33210 }
33211 {
33212 if (temp3)
33213 delete arg3;
33214 }
33215 {
33216 if (temp4)
33217 delete arg4;
33218 }
33219 return resultobj;
33220 fail:
33221 {
33222 if (temp3)
33223 delete arg3;
33224 }
33225 {
33226 if (temp4)
33227 delete arg4;
33228 }
33229 return NULL;
33230 }
33231
33232
33233 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33234 PyObject *resultobj;
33235 wxMenu *arg1 = (wxMenu *) 0 ;
33236 int arg2 ;
33237 wxString *arg3 = 0 ;
33238 wxMenu *arg4 = (wxMenu *) 0 ;
33239 wxString const &arg5_defvalue = wxPyEmptyString ;
33240 wxString *arg5 = (wxString *) &arg5_defvalue ;
33241 wxMenuItem *result;
33242 bool temp3 = false ;
33243 bool temp5 = false ;
33244 PyObject * obj0 = 0 ;
33245 PyObject * obj1 = 0 ;
33246 PyObject * obj2 = 0 ;
33247 PyObject * obj3 = 0 ;
33248 PyObject * obj4 = 0 ;
33249 char *kwnames[] = {
33250 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33251 };
33252
33253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33255 if (SWIG_arg_fail(1)) SWIG_fail;
33256 {
33257 arg2 = (int)(SWIG_As_int(obj1));
33258 if (SWIG_arg_fail(2)) SWIG_fail;
33259 }
33260 {
33261 arg3 = wxString_in_helper(obj2);
33262 if (arg3 == NULL) SWIG_fail;
33263 temp3 = true;
33264 }
33265 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33266 if (SWIG_arg_fail(4)) SWIG_fail;
33267 if (obj4) {
33268 {
33269 arg5 = wxString_in_helper(obj4);
33270 if (arg5 == NULL) SWIG_fail;
33271 temp5 = true;
33272 }
33273 }
33274 {
33275 PyThreadState* __tstate = wxPyBeginAllowThreads();
33276 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33277
33278 wxPyEndAllowThreads(__tstate);
33279 if (PyErr_Occurred()) SWIG_fail;
33280 }
33281 {
33282 resultobj = wxPyMake_wxObject(result, 0);
33283 }
33284 {
33285 if (temp3)
33286 delete arg3;
33287 }
33288 {
33289 if (temp5)
33290 delete arg5;
33291 }
33292 return resultobj;
33293 fail:
33294 {
33295 if (temp3)
33296 delete arg3;
33297 }
33298 {
33299 if (temp5)
33300 delete arg5;
33301 }
33302 return NULL;
33303 }
33304
33305
33306 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33307 PyObject *resultobj;
33308 wxMenu *arg1 = (wxMenu *) 0 ;
33309 int arg2 ;
33310 wxMenuItem *result;
33311 PyObject * obj0 = 0 ;
33312 PyObject * obj1 = 0 ;
33313 char *kwnames[] = {
33314 (char *) "self",(char *) "id", NULL
33315 };
33316
33317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33319 if (SWIG_arg_fail(1)) SWIG_fail;
33320 {
33321 arg2 = (int)(SWIG_As_int(obj1));
33322 if (SWIG_arg_fail(2)) SWIG_fail;
33323 }
33324 {
33325 PyThreadState* __tstate = wxPyBeginAllowThreads();
33326 result = (wxMenuItem *)(arg1)->Remove(arg2);
33327
33328 wxPyEndAllowThreads(__tstate);
33329 if (PyErr_Occurred()) SWIG_fail;
33330 }
33331 {
33332 resultobj = wxPyMake_wxObject(result, 0);
33333 }
33334 return resultobj;
33335 fail:
33336 return NULL;
33337 }
33338
33339
33340 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33341 PyObject *resultobj;
33342 wxMenu *arg1 = (wxMenu *) 0 ;
33343 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33344 wxMenuItem *result;
33345 PyObject * obj0 = 0 ;
33346 PyObject * obj1 = 0 ;
33347 char *kwnames[] = {
33348 (char *) "self",(char *) "item", NULL
33349 };
33350
33351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33353 if (SWIG_arg_fail(1)) SWIG_fail;
33354 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33355 if (SWIG_arg_fail(2)) SWIG_fail;
33356 {
33357 PyThreadState* __tstate = wxPyBeginAllowThreads();
33358 result = (wxMenuItem *)(arg1)->Remove(arg2);
33359
33360 wxPyEndAllowThreads(__tstate);
33361 if (PyErr_Occurred()) SWIG_fail;
33362 }
33363 {
33364 resultobj = wxPyMake_wxObject(result, 0);
33365 }
33366 return resultobj;
33367 fail:
33368 return NULL;
33369 }
33370
33371
33372 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33373 PyObject *resultobj;
33374 wxMenu *arg1 = (wxMenu *) 0 ;
33375 int arg2 ;
33376 bool result;
33377 PyObject * obj0 = 0 ;
33378 PyObject * obj1 = 0 ;
33379 char *kwnames[] = {
33380 (char *) "self",(char *) "id", NULL
33381 };
33382
33383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33385 if (SWIG_arg_fail(1)) SWIG_fail;
33386 {
33387 arg2 = (int)(SWIG_As_int(obj1));
33388 if (SWIG_arg_fail(2)) SWIG_fail;
33389 }
33390 {
33391 PyThreadState* __tstate = wxPyBeginAllowThreads();
33392 result = (bool)(arg1)->Delete(arg2);
33393
33394 wxPyEndAllowThreads(__tstate);
33395 if (PyErr_Occurred()) SWIG_fail;
33396 }
33397 {
33398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33399 }
33400 return resultobj;
33401 fail:
33402 return NULL;
33403 }
33404
33405
33406 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33407 PyObject *resultobj;
33408 wxMenu *arg1 = (wxMenu *) 0 ;
33409 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33410 bool result;
33411 PyObject * obj0 = 0 ;
33412 PyObject * obj1 = 0 ;
33413 char *kwnames[] = {
33414 (char *) "self",(char *) "item", NULL
33415 };
33416
33417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33419 if (SWIG_arg_fail(1)) SWIG_fail;
33420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33421 if (SWIG_arg_fail(2)) SWIG_fail;
33422 {
33423 PyThreadState* __tstate = wxPyBeginAllowThreads();
33424 result = (bool)(arg1)->Delete(arg2);
33425
33426 wxPyEndAllowThreads(__tstate);
33427 if (PyErr_Occurred()) SWIG_fail;
33428 }
33429 {
33430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33431 }
33432 return resultobj;
33433 fail:
33434 return NULL;
33435 }
33436
33437
33438 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33439 PyObject *resultobj;
33440 wxMenu *arg1 = (wxMenu *) 0 ;
33441 PyObject * obj0 = 0 ;
33442 char *kwnames[] = {
33443 (char *) "self", NULL
33444 };
33445
33446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33448 if (SWIG_arg_fail(1)) SWIG_fail;
33449 {
33450 PyThreadState* __tstate = wxPyBeginAllowThreads();
33451 wxMenu_Destroy(arg1);
33452
33453 wxPyEndAllowThreads(__tstate);
33454 if (PyErr_Occurred()) SWIG_fail;
33455 }
33456 Py_INCREF(Py_None); resultobj = Py_None;
33457 return resultobj;
33458 fail:
33459 return NULL;
33460 }
33461
33462
33463 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33464 PyObject *resultobj;
33465 wxMenu *arg1 = (wxMenu *) 0 ;
33466 int arg2 ;
33467 bool result;
33468 PyObject * obj0 = 0 ;
33469 PyObject * obj1 = 0 ;
33470 char *kwnames[] = {
33471 (char *) "self",(char *) "id", NULL
33472 };
33473
33474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33476 if (SWIG_arg_fail(1)) SWIG_fail;
33477 {
33478 arg2 = (int)(SWIG_As_int(obj1));
33479 if (SWIG_arg_fail(2)) SWIG_fail;
33480 }
33481 {
33482 PyThreadState* __tstate = wxPyBeginAllowThreads();
33483 result = (bool)(arg1)->Destroy(arg2);
33484
33485 wxPyEndAllowThreads(__tstate);
33486 if (PyErr_Occurred()) SWIG_fail;
33487 }
33488 {
33489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33490 }
33491 return resultobj;
33492 fail:
33493 return NULL;
33494 }
33495
33496
33497 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33498 PyObject *resultobj;
33499 wxMenu *arg1 = (wxMenu *) 0 ;
33500 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33501 bool result;
33502 PyObject * obj0 = 0 ;
33503 PyObject * obj1 = 0 ;
33504 char *kwnames[] = {
33505 (char *) "self",(char *) "item", NULL
33506 };
33507
33508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33510 if (SWIG_arg_fail(1)) SWIG_fail;
33511 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33512 if (SWIG_arg_fail(2)) SWIG_fail;
33513 {
33514 PyThreadState* __tstate = wxPyBeginAllowThreads();
33515 result = (bool)(arg1)->Destroy(arg2);
33516
33517 wxPyEndAllowThreads(__tstate);
33518 if (PyErr_Occurred()) SWIG_fail;
33519 }
33520 {
33521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33522 }
33523 return resultobj;
33524 fail:
33525 return NULL;
33526 }
33527
33528
33529 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33530 PyObject *resultobj;
33531 wxMenu *arg1 = (wxMenu *) 0 ;
33532 size_t result;
33533 PyObject * obj0 = 0 ;
33534 char *kwnames[] = {
33535 (char *) "self", NULL
33536 };
33537
33538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33540 if (SWIG_arg_fail(1)) SWIG_fail;
33541 {
33542 PyThreadState* __tstate = wxPyBeginAllowThreads();
33543 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33544
33545 wxPyEndAllowThreads(__tstate);
33546 if (PyErr_Occurred()) SWIG_fail;
33547 }
33548 {
33549 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33550 }
33551 return resultobj;
33552 fail:
33553 return NULL;
33554 }
33555
33556
33557 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33558 PyObject *resultobj;
33559 wxMenu *arg1 = (wxMenu *) 0 ;
33560 PyObject *result;
33561 PyObject * obj0 = 0 ;
33562 char *kwnames[] = {
33563 (char *) "self", NULL
33564 };
33565
33566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33568 if (SWIG_arg_fail(1)) SWIG_fail;
33569 {
33570 PyThreadState* __tstate = wxPyBeginAllowThreads();
33571 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33572
33573 wxPyEndAllowThreads(__tstate);
33574 if (PyErr_Occurred()) SWIG_fail;
33575 }
33576 resultobj = result;
33577 return resultobj;
33578 fail:
33579 return NULL;
33580 }
33581
33582
33583 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33584 PyObject *resultobj;
33585 wxMenu *arg1 = (wxMenu *) 0 ;
33586 wxString *arg2 = 0 ;
33587 int result;
33588 bool temp2 = false ;
33589 PyObject * obj0 = 0 ;
33590 PyObject * obj1 = 0 ;
33591 char *kwnames[] = {
33592 (char *) "self",(char *) "item", NULL
33593 };
33594
33595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33597 if (SWIG_arg_fail(1)) SWIG_fail;
33598 {
33599 arg2 = wxString_in_helper(obj1);
33600 if (arg2 == NULL) SWIG_fail;
33601 temp2 = true;
33602 }
33603 {
33604 PyThreadState* __tstate = wxPyBeginAllowThreads();
33605 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33606
33607 wxPyEndAllowThreads(__tstate);
33608 if (PyErr_Occurred()) SWIG_fail;
33609 }
33610 {
33611 resultobj = SWIG_From_int((int)(result));
33612 }
33613 {
33614 if (temp2)
33615 delete arg2;
33616 }
33617 return resultobj;
33618 fail:
33619 {
33620 if (temp2)
33621 delete arg2;
33622 }
33623 return NULL;
33624 }
33625
33626
33627 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33628 PyObject *resultobj;
33629 wxMenu *arg1 = (wxMenu *) 0 ;
33630 int arg2 ;
33631 wxMenuItem *result;
33632 PyObject * obj0 = 0 ;
33633 PyObject * obj1 = 0 ;
33634 char *kwnames[] = {
33635 (char *) "self",(char *) "id", NULL
33636 };
33637
33638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33640 if (SWIG_arg_fail(1)) SWIG_fail;
33641 {
33642 arg2 = (int)(SWIG_As_int(obj1));
33643 if (SWIG_arg_fail(2)) SWIG_fail;
33644 }
33645 {
33646 PyThreadState* __tstate = wxPyBeginAllowThreads();
33647 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33648
33649 wxPyEndAllowThreads(__tstate);
33650 if (PyErr_Occurred()) SWIG_fail;
33651 }
33652 {
33653 resultobj = wxPyMake_wxObject(result, 0);
33654 }
33655 return resultobj;
33656 fail:
33657 return NULL;
33658 }
33659
33660
33661 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33662 PyObject *resultobj;
33663 wxMenu *arg1 = (wxMenu *) 0 ;
33664 size_t arg2 ;
33665 wxMenuItem *result;
33666 PyObject * obj0 = 0 ;
33667 PyObject * obj1 = 0 ;
33668 char *kwnames[] = {
33669 (char *) "self",(char *) "position", NULL
33670 };
33671
33672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33674 if (SWIG_arg_fail(1)) SWIG_fail;
33675 {
33676 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33677 if (SWIG_arg_fail(2)) SWIG_fail;
33678 }
33679 {
33680 PyThreadState* __tstate = wxPyBeginAllowThreads();
33681 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33682
33683 wxPyEndAllowThreads(__tstate);
33684 if (PyErr_Occurred()) SWIG_fail;
33685 }
33686 {
33687 resultobj = wxPyMake_wxObject(result, 0);
33688 }
33689 return resultobj;
33690 fail:
33691 return NULL;
33692 }
33693
33694
33695 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33696 PyObject *resultobj;
33697 wxMenu *arg1 = (wxMenu *) 0 ;
33698 int arg2 ;
33699 bool arg3 ;
33700 PyObject * obj0 = 0 ;
33701 PyObject * obj1 = 0 ;
33702 PyObject * obj2 = 0 ;
33703 char *kwnames[] = {
33704 (char *) "self",(char *) "id",(char *) "enable", NULL
33705 };
33706
33707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33709 if (SWIG_arg_fail(1)) SWIG_fail;
33710 {
33711 arg2 = (int)(SWIG_As_int(obj1));
33712 if (SWIG_arg_fail(2)) SWIG_fail;
33713 }
33714 {
33715 arg3 = (bool)(SWIG_As_bool(obj2));
33716 if (SWIG_arg_fail(3)) SWIG_fail;
33717 }
33718 {
33719 PyThreadState* __tstate = wxPyBeginAllowThreads();
33720 (arg1)->Enable(arg2,arg3);
33721
33722 wxPyEndAllowThreads(__tstate);
33723 if (PyErr_Occurred()) SWIG_fail;
33724 }
33725 Py_INCREF(Py_None); resultobj = Py_None;
33726 return resultobj;
33727 fail:
33728 return NULL;
33729 }
33730
33731
33732 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33733 PyObject *resultobj;
33734 wxMenu *arg1 = (wxMenu *) 0 ;
33735 int arg2 ;
33736 bool result;
33737 PyObject * obj0 = 0 ;
33738 PyObject * obj1 = 0 ;
33739 char *kwnames[] = {
33740 (char *) "self",(char *) "id", NULL
33741 };
33742
33743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33745 if (SWIG_arg_fail(1)) SWIG_fail;
33746 {
33747 arg2 = (int)(SWIG_As_int(obj1));
33748 if (SWIG_arg_fail(2)) SWIG_fail;
33749 }
33750 {
33751 PyThreadState* __tstate = wxPyBeginAllowThreads();
33752 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33753
33754 wxPyEndAllowThreads(__tstate);
33755 if (PyErr_Occurred()) SWIG_fail;
33756 }
33757 {
33758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33759 }
33760 return resultobj;
33761 fail:
33762 return NULL;
33763 }
33764
33765
33766 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33767 PyObject *resultobj;
33768 wxMenu *arg1 = (wxMenu *) 0 ;
33769 int arg2 ;
33770 bool arg3 ;
33771 PyObject * obj0 = 0 ;
33772 PyObject * obj1 = 0 ;
33773 PyObject * obj2 = 0 ;
33774 char *kwnames[] = {
33775 (char *) "self",(char *) "id",(char *) "check", NULL
33776 };
33777
33778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33780 if (SWIG_arg_fail(1)) SWIG_fail;
33781 {
33782 arg2 = (int)(SWIG_As_int(obj1));
33783 if (SWIG_arg_fail(2)) SWIG_fail;
33784 }
33785 {
33786 arg3 = (bool)(SWIG_As_bool(obj2));
33787 if (SWIG_arg_fail(3)) SWIG_fail;
33788 }
33789 {
33790 PyThreadState* __tstate = wxPyBeginAllowThreads();
33791 (arg1)->Check(arg2,arg3);
33792
33793 wxPyEndAllowThreads(__tstate);
33794 if (PyErr_Occurred()) SWIG_fail;
33795 }
33796 Py_INCREF(Py_None); resultobj = Py_None;
33797 return resultobj;
33798 fail:
33799 return NULL;
33800 }
33801
33802
33803 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33804 PyObject *resultobj;
33805 wxMenu *arg1 = (wxMenu *) 0 ;
33806 int arg2 ;
33807 bool result;
33808 PyObject * obj0 = 0 ;
33809 PyObject * obj1 = 0 ;
33810 char *kwnames[] = {
33811 (char *) "self",(char *) "id", NULL
33812 };
33813
33814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33816 if (SWIG_arg_fail(1)) SWIG_fail;
33817 {
33818 arg2 = (int)(SWIG_As_int(obj1));
33819 if (SWIG_arg_fail(2)) SWIG_fail;
33820 }
33821 {
33822 PyThreadState* __tstate = wxPyBeginAllowThreads();
33823 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33824
33825 wxPyEndAllowThreads(__tstate);
33826 if (PyErr_Occurred()) SWIG_fail;
33827 }
33828 {
33829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33830 }
33831 return resultobj;
33832 fail:
33833 return NULL;
33834 }
33835
33836
33837 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33838 PyObject *resultobj;
33839 wxMenu *arg1 = (wxMenu *) 0 ;
33840 int arg2 ;
33841 wxString *arg3 = 0 ;
33842 bool temp3 = false ;
33843 PyObject * obj0 = 0 ;
33844 PyObject * obj1 = 0 ;
33845 PyObject * obj2 = 0 ;
33846 char *kwnames[] = {
33847 (char *) "self",(char *) "id",(char *) "label", NULL
33848 };
33849
33850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33852 if (SWIG_arg_fail(1)) SWIG_fail;
33853 {
33854 arg2 = (int)(SWIG_As_int(obj1));
33855 if (SWIG_arg_fail(2)) SWIG_fail;
33856 }
33857 {
33858 arg3 = wxString_in_helper(obj2);
33859 if (arg3 == NULL) SWIG_fail;
33860 temp3 = true;
33861 }
33862 {
33863 PyThreadState* __tstate = wxPyBeginAllowThreads();
33864 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33865
33866 wxPyEndAllowThreads(__tstate);
33867 if (PyErr_Occurred()) SWIG_fail;
33868 }
33869 Py_INCREF(Py_None); resultobj = Py_None;
33870 {
33871 if (temp3)
33872 delete arg3;
33873 }
33874 return resultobj;
33875 fail:
33876 {
33877 if (temp3)
33878 delete arg3;
33879 }
33880 return NULL;
33881 }
33882
33883
33884 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33885 PyObject *resultobj;
33886 wxMenu *arg1 = (wxMenu *) 0 ;
33887 int arg2 ;
33888 wxString result;
33889 PyObject * obj0 = 0 ;
33890 PyObject * obj1 = 0 ;
33891 char *kwnames[] = {
33892 (char *) "self",(char *) "id", NULL
33893 };
33894
33895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33897 if (SWIG_arg_fail(1)) SWIG_fail;
33898 {
33899 arg2 = (int)(SWIG_As_int(obj1));
33900 if (SWIG_arg_fail(2)) SWIG_fail;
33901 }
33902 {
33903 PyThreadState* __tstate = wxPyBeginAllowThreads();
33904 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33905
33906 wxPyEndAllowThreads(__tstate);
33907 if (PyErr_Occurred()) SWIG_fail;
33908 }
33909 {
33910 #if wxUSE_UNICODE
33911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33912 #else
33913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33914 #endif
33915 }
33916 return resultobj;
33917 fail:
33918 return NULL;
33919 }
33920
33921
33922 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33923 PyObject *resultobj;
33924 wxMenu *arg1 = (wxMenu *) 0 ;
33925 int arg2 ;
33926 wxString *arg3 = 0 ;
33927 bool temp3 = false ;
33928 PyObject * obj0 = 0 ;
33929 PyObject * obj1 = 0 ;
33930 PyObject * obj2 = 0 ;
33931 char *kwnames[] = {
33932 (char *) "self",(char *) "id",(char *) "helpString", NULL
33933 };
33934
33935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33937 if (SWIG_arg_fail(1)) SWIG_fail;
33938 {
33939 arg2 = (int)(SWIG_As_int(obj1));
33940 if (SWIG_arg_fail(2)) SWIG_fail;
33941 }
33942 {
33943 arg3 = wxString_in_helper(obj2);
33944 if (arg3 == NULL) SWIG_fail;
33945 temp3 = true;
33946 }
33947 {
33948 PyThreadState* __tstate = wxPyBeginAllowThreads();
33949 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33950
33951 wxPyEndAllowThreads(__tstate);
33952 if (PyErr_Occurred()) SWIG_fail;
33953 }
33954 Py_INCREF(Py_None); resultobj = Py_None;
33955 {
33956 if (temp3)
33957 delete arg3;
33958 }
33959 return resultobj;
33960 fail:
33961 {
33962 if (temp3)
33963 delete arg3;
33964 }
33965 return NULL;
33966 }
33967
33968
33969 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33970 PyObject *resultobj;
33971 wxMenu *arg1 = (wxMenu *) 0 ;
33972 int arg2 ;
33973 wxString result;
33974 PyObject * obj0 = 0 ;
33975 PyObject * obj1 = 0 ;
33976 char *kwnames[] = {
33977 (char *) "self",(char *) "id", NULL
33978 };
33979
33980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33982 if (SWIG_arg_fail(1)) SWIG_fail;
33983 {
33984 arg2 = (int)(SWIG_As_int(obj1));
33985 if (SWIG_arg_fail(2)) SWIG_fail;
33986 }
33987 {
33988 PyThreadState* __tstate = wxPyBeginAllowThreads();
33989 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33990
33991 wxPyEndAllowThreads(__tstate);
33992 if (PyErr_Occurred()) SWIG_fail;
33993 }
33994 {
33995 #if wxUSE_UNICODE
33996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33997 #else
33998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33999 #endif
34000 }
34001 return resultobj;
34002 fail:
34003 return NULL;
34004 }
34005
34006
34007 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34008 PyObject *resultobj;
34009 wxMenu *arg1 = (wxMenu *) 0 ;
34010 wxString *arg2 = 0 ;
34011 bool temp2 = false ;
34012 PyObject * obj0 = 0 ;
34013 PyObject * obj1 = 0 ;
34014 char *kwnames[] = {
34015 (char *) "self",(char *) "title", NULL
34016 };
34017
34018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34020 if (SWIG_arg_fail(1)) SWIG_fail;
34021 {
34022 arg2 = wxString_in_helper(obj1);
34023 if (arg2 == NULL) SWIG_fail;
34024 temp2 = true;
34025 }
34026 {
34027 PyThreadState* __tstate = wxPyBeginAllowThreads();
34028 (arg1)->SetTitle((wxString const &)*arg2);
34029
34030 wxPyEndAllowThreads(__tstate);
34031 if (PyErr_Occurred()) SWIG_fail;
34032 }
34033 Py_INCREF(Py_None); resultobj = Py_None;
34034 {
34035 if (temp2)
34036 delete arg2;
34037 }
34038 return resultobj;
34039 fail:
34040 {
34041 if (temp2)
34042 delete arg2;
34043 }
34044 return NULL;
34045 }
34046
34047
34048 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34049 PyObject *resultobj;
34050 wxMenu *arg1 = (wxMenu *) 0 ;
34051 wxString result;
34052 PyObject * obj0 = 0 ;
34053 char *kwnames[] = {
34054 (char *) "self", NULL
34055 };
34056
34057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34059 if (SWIG_arg_fail(1)) SWIG_fail;
34060 {
34061 PyThreadState* __tstate = wxPyBeginAllowThreads();
34062 result = ((wxMenu const *)arg1)->GetTitle();
34063
34064 wxPyEndAllowThreads(__tstate);
34065 if (PyErr_Occurred()) SWIG_fail;
34066 }
34067 {
34068 #if wxUSE_UNICODE
34069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34070 #else
34071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34072 #endif
34073 }
34074 return resultobj;
34075 fail:
34076 return NULL;
34077 }
34078
34079
34080 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34081 PyObject *resultobj;
34082 wxMenu *arg1 = (wxMenu *) 0 ;
34083 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34084 PyObject * obj0 = 0 ;
34085 PyObject * obj1 = 0 ;
34086 char *kwnames[] = {
34087 (char *) "self",(char *) "handler", NULL
34088 };
34089
34090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34092 if (SWIG_arg_fail(1)) SWIG_fail;
34093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34094 if (SWIG_arg_fail(2)) SWIG_fail;
34095 {
34096 PyThreadState* __tstate = wxPyBeginAllowThreads();
34097 (arg1)->SetEventHandler(arg2);
34098
34099 wxPyEndAllowThreads(__tstate);
34100 if (PyErr_Occurred()) SWIG_fail;
34101 }
34102 Py_INCREF(Py_None); resultobj = Py_None;
34103 return resultobj;
34104 fail:
34105 return NULL;
34106 }
34107
34108
34109 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34110 PyObject *resultobj;
34111 wxMenu *arg1 = (wxMenu *) 0 ;
34112 wxEvtHandler *result;
34113 PyObject * obj0 = 0 ;
34114 char *kwnames[] = {
34115 (char *) "self", NULL
34116 };
34117
34118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34120 if (SWIG_arg_fail(1)) SWIG_fail;
34121 {
34122 PyThreadState* __tstate = wxPyBeginAllowThreads();
34123 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34124
34125 wxPyEndAllowThreads(__tstate);
34126 if (PyErr_Occurred()) SWIG_fail;
34127 }
34128 {
34129 resultobj = wxPyMake_wxObject(result, 0);
34130 }
34131 return resultobj;
34132 fail:
34133 return NULL;
34134 }
34135
34136
34137 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34138 PyObject *resultobj;
34139 wxMenu *arg1 = (wxMenu *) 0 ;
34140 wxWindow *arg2 = (wxWindow *) 0 ;
34141 PyObject * obj0 = 0 ;
34142 PyObject * obj1 = 0 ;
34143 char *kwnames[] = {
34144 (char *) "self",(char *) "win", NULL
34145 };
34146
34147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34149 if (SWIG_arg_fail(1)) SWIG_fail;
34150 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34151 if (SWIG_arg_fail(2)) SWIG_fail;
34152 {
34153 PyThreadState* __tstate = wxPyBeginAllowThreads();
34154 (arg1)->SetInvokingWindow(arg2);
34155
34156 wxPyEndAllowThreads(__tstate);
34157 if (PyErr_Occurred()) SWIG_fail;
34158 }
34159 Py_INCREF(Py_None); resultobj = Py_None;
34160 return resultobj;
34161 fail:
34162 return NULL;
34163 }
34164
34165
34166 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34167 PyObject *resultobj;
34168 wxMenu *arg1 = (wxMenu *) 0 ;
34169 wxWindow *result;
34170 PyObject * obj0 = 0 ;
34171 char *kwnames[] = {
34172 (char *) "self", NULL
34173 };
34174
34175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34177 if (SWIG_arg_fail(1)) SWIG_fail;
34178 {
34179 PyThreadState* __tstate = wxPyBeginAllowThreads();
34180 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34181
34182 wxPyEndAllowThreads(__tstate);
34183 if (PyErr_Occurred()) SWIG_fail;
34184 }
34185 {
34186 resultobj = wxPyMake_wxObject(result, 0);
34187 }
34188 return resultobj;
34189 fail:
34190 return NULL;
34191 }
34192
34193
34194 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34195 PyObject *resultobj;
34196 wxMenu *arg1 = (wxMenu *) 0 ;
34197 long result;
34198 PyObject * obj0 = 0 ;
34199 char *kwnames[] = {
34200 (char *) "self", NULL
34201 };
34202
34203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34205 if (SWIG_arg_fail(1)) SWIG_fail;
34206 {
34207 PyThreadState* __tstate = wxPyBeginAllowThreads();
34208 result = (long)((wxMenu const *)arg1)->GetStyle();
34209
34210 wxPyEndAllowThreads(__tstate);
34211 if (PyErr_Occurred()) SWIG_fail;
34212 }
34213 {
34214 resultobj = SWIG_From_long((long)(result));
34215 }
34216 return resultobj;
34217 fail:
34218 return NULL;
34219 }
34220
34221
34222 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34223 PyObject *resultobj;
34224 wxMenu *arg1 = (wxMenu *) 0 ;
34225 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34226 PyObject * obj0 = 0 ;
34227 PyObject * obj1 = 0 ;
34228 char *kwnames[] = {
34229 (char *) "self",(char *) "source", NULL
34230 };
34231
34232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34234 if (SWIG_arg_fail(1)) SWIG_fail;
34235 if (obj1) {
34236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34237 if (SWIG_arg_fail(2)) SWIG_fail;
34238 }
34239 {
34240 PyThreadState* __tstate = wxPyBeginAllowThreads();
34241 (arg1)->UpdateUI(arg2);
34242
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 Py_INCREF(Py_None); resultobj = Py_None;
34247 return resultobj;
34248 fail:
34249 return NULL;
34250 }
34251
34252
34253 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34254 PyObject *resultobj;
34255 wxMenu *arg1 = (wxMenu *) 0 ;
34256 wxMenuBar *result;
34257 PyObject * obj0 = 0 ;
34258 char *kwnames[] = {
34259 (char *) "self", NULL
34260 };
34261
34262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34264 if (SWIG_arg_fail(1)) SWIG_fail;
34265 {
34266 PyThreadState* __tstate = wxPyBeginAllowThreads();
34267 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34268
34269 wxPyEndAllowThreads(__tstate);
34270 if (PyErr_Occurred()) SWIG_fail;
34271 }
34272 {
34273 resultobj = wxPyMake_wxObject(result, 0);
34274 }
34275 return resultobj;
34276 fail:
34277 return NULL;
34278 }
34279
34280
34281 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34282 PyObject *resultobj;
34283 wxMenu *arg1 = (wxMenu *) 0 ;
34284 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34285 PyObject * obj0 = 0 ;
34286 PyObject * obj1 = 0 ;
34287 char *kwnames[] = {
34288 (char *) "self",(char *) "menubar", NULL
34289 };
34290
34291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34293 if (SWIG_arg_fail(1)) SWIG_fail;
34294 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34295 if (SWIG_arg_fail(2)) SWIG_fail;
34296 {
34297 PyThreadState* __tstate = wxPyBeginAllowThreads();
34298 (arg1)->Attach(arg2);
34299
34300 wxPyEndAllowThreads(__tstate);
34301 if (PyErr_Occurred()) SWIG_fail;
34302 }
34303 Py_INCREF(Py_None); resultobj = Py_None;
34304 return resultobj;
34305 fail:
34306 return NULL;
34307 }
34308
34309
34310 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34311 PyObject *resultobj;
34312 wxMenu *arg1 = (wxMenu *) 0 ;
34313 PyObject * obj0 = 0 ;
34314 char *kwnames[] = {
34315 (char *) "self", NULL
34316 };
34317
34318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34320 if (SWIG_arg_fail(1)) SWIG_fail;
34321 {
34322 PyThreadState* __tstate = wxPyBeginAllowThreads();
34323 (arg1)->Detach();
34324
34325 wxPyEndAllowThreads(__tstate);
34326 if (PyErr_Occurred()) SWIG_fail;
34327 }
34328 Py_INCREF(Py_None); resultobj = Py_None;
34329 return resultobj;
34330 fail:
34331 return NULL;
34332 }
34333
34334
34335 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34336 PyObject *resultobj;
34337 wxMenu *arg1 = (wxMenu *) 0 ;
34338 bool result;
34339 PyObject * obj0 = 0 ;
34340 char *kwnames[] = {
34341 (char *) "self", NULL
34342 };
34343
34344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34346 if (SWIG_arg_fail(1)) SWIG_fail;
34347 {
34348 PyThreadState* __tstate = wxPyBeginAllowThreads();
34349 result = (bool)((wxMenu const *)arg1)->IsAttached();
34350
34351 wxPyEndAllowThreads(__tstate);
34352 if (PyErr_Occurred()) SWIG_fail;
34353 }
34354 {
34355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34356 }
34357 return resultobj;
34358 fail:
34359 return NULL;
34360 }
34361
34362
34363 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34364 PyObject *resultobj;
34365 wxMenu *arg1 = (wxMenu *) 0 ;
34366 wxMenu *arg2 = (wxMenu *) 0 ;
34367 PyObject * obj0 = 0 ;
34368 PyObject * obj1 = 0 ;
34369 char *kwnames[] = {
34370 (char *) "self",(char *) "parent", NULL
34371 };
34372
34373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34375 if (SWIG_arg_fail(1)) SWIG_fail;
34376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34377 if (SWIG_arg_fail(2)) SWIG_fail;
34378 {
34379 PyThreadState* __tstate = wxPyBeginAllowThreads();
34380 (arg1)->SetParent(arg2);
34381
34382 wxPyEndAllowThreads(__tstate);
34383 if (PyErr_Occurred()) SWIG_fail;
34384 }
34385 Py_INCREF(Py_None); resultobj = Py_None;
34386 return resultobj;
34387 fail:
34388 return NULL;
34389 }
34390
34391
34392 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34393 PyObject *resultobj;
34394 wxMenu *arg1 = (wxMenu *) 0 ;
34395 wxMenu *result;
34396 PyObject * obj0 = 0 ;
34397 char *kwnames[] = {
34398 (char *) "self", NULL
34399 };
34400
34401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34403 if (SWIG_arg_fail(1)) SWIG_fail;
34404 {
34405 PyThreadState* __tstate = wxPyBeginAllowThreads();
34406 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34407
34408 wxPyEndAllowThreads(__tstate);
34409 if (PyErr_Occurred()) SWIG_fail;
34410 }
34411 {
34412 resultobj = wxPyMake_wxObject(result, 0);
34413 }
34414 return resultobj;
34415 fail:
34416 return NULL;
34417 }
34418
34419
34420 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34421 PyObject *obj;
34422 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34423 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34424 Py_INCREF(obj);
34425 return Py_BuildValue((char *)"");
34426 }
34427 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34428 PyObject *resultobj;
34429 long arg1 = (long) 0 ;
34430 wxMenuBar *result;
34431 PyObject * obj0 = 0 ;
34432 char *kwnames[] = {
34433 (char *) "style", NULL
34434 };
34435
34436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34437 if (obj0) {
34438 {
34439 arg1 = (long)(SWIG_As_long(obj0));
34440 if (SWIG_arg_fail(1)) SWIG_fail;
34441 }
34442 }
34443 {
34444 if (!wxPyCheckForApp()) SWIG_fail;
34445 PyThreadState* __tstate = wxPyBeginAllowThreads();
34446 result = (wxMenuBar *)new wxMenuBar(arg1);
34447
34448 wxPyEndAllowThreads(__tstate);
34449 if (PyErr_Occurred()) SWIG_fail;
34450 }
34451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34452 return resultobj;
34453 fail:
34454 return NULL;
34455 }
34456
34457
34458 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34459 PyObject *resultobj;
34460 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34461 wxMenu *arg2 = (wxMenu *) 0 ;
34462 wxString *arg3 = 0 ;
34463 bool result;
34464 bool temp3 = false ;
34465 PyObject * obj0 = 0 ;
34466 PyObject * obj1 = 0 ;
34467 PyObject * obj2 = 0 ;
34468 char *kwnames[] = {
34469 (char *) "self",(char *) "menu",(char *) "title", NULL
34470 };
34471
34472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34474 if (SWIG_arg_fail(1)) SWIG_fail;
34475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34476 if (SWIG_arg_fail(2)) SWIG_fail;
34477 {
34478 arg3 = wxString_in_helper(obj2);
34479 if (arg3 == NULL) SWIG_fail;
34480 temp3 = true;
34481 }
34482 {
34483 PyThreadState* __tstate = wxPyBeginAllowThreads();
34484 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34485
34486 wxPyEndAllowThreads(__tstate);
34487 if (PyErr_Occurred()) SWIG_fail;
34488 }
34489 {
34490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34491 }
34492 {
34493 if (temp3)
34494 delete arg3;
34495 }
34496 return resultobj;
34497 fail:
34498 {
34499 if (temp3)
34500 delete arg3;
34501 }
34502 return NULL;
34503 }
34504
34505
34506 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34507 PyObject *resultobj;
34508 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34509 size_t arg2 ;
34510 wxMenu *arg3 = (wxMenu *) 0 ;
34511 wxString *arg4 = 0 ;
34512 bool result;
34513 bool temp4 = false ;
34514 PyObject * obj0 = 0 ;
34515 PyObject * obj1 = 0 ;
34516 PyObject * obj2 = 0 ;
34517 PyObject * obj3 = 0 ;
34518 char *kwnames[] = {
34519 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34520 };
34521
34522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34524 if (SWIG_arg_fail(1)) SWIG_fail;
34525 {
34526 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34527 if (SWIG_arg_fail(2)) SWIG_fail;
34528 }
34529 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34530 if (SWIG_arg_fail(3)) SWIG_fail;
34531 {
34532 arg4 = wxString_in_helper(obj3);
34533 if (arg4 == NULL) SWIG_fail;
34534 temp4 = true;
34535 }
34536 {
34537 PyThreadState* __tstate = wxPyBeginAllowThreads();
34538 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34539
34540 wxPyEndAllowThreads(__tstate);
34541 if (PyErr_Occurred()) SWIG_fail;
34542 }
34543 {
34544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34545 }
34546 {
34547 if (temp4)
34548 delete arg4;
34549 }
34550 return resultobj;
34551 fail:
34552 {
34553 if (temp4)
34554 delete arg4;
34555 }
34556 return NULL;
34557 }
34558
34559
34560 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34561 PyObject *resultobj;
34562 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34563 size_t result;
34564 PyObject * obj0 = 0 ;
34565 char *kwnames[] = {
34566 (char *) "self", NULL
34567 };
34568
34569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34571 if (SWIG_arg_fail(1)) SWIG_fail;
34572 {
34573 PyThreadState* __tstate = wxPyBeginAllowThreads();
34574 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34575
34576 wxPyEndAllowThreads(__tstate);
34577 if (PyErr_Occurred()) SWIG_fail;
34578 }
34579 {
34580 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34581 }
34582 return resultobj;
34583 fail:
34584 return NULL;
34585 }
34586
34587
34588 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34589 PyObject *resultobj;
34590 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34591 size_t arg2 ;
34592 wxMenu *result;
34593 PyObject * obj0 = 0 ;
34594 PyObject * obj1 = 0 ;
34595 char *kwnames[] = {
34596 (char *) "self",(char *) "pos", NULL
34597 };
34598
34599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34601 if (SWIG_arg_fail(1)) SWIG_fail;
34602 {
34603 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34604 if (SWIG_arg_fail(2)) SWIG_fail;
34605 }
34606 {
34607 PyThreadState* __tstate = wxPyBeginAllowThreads();
34608 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34609
34610 wxPyEndAllowThreads(__tstate);
34611 if (PyErr_Occurred()) SWIG_fail;
34612 }
34613 {
34614 resultobj = wxPyMake_wxObject(result, 0);
34615 }
34616 return resultobj;
34617 fail:
34618 return NULL;
34619 }
34620
34621
34622 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34623 PyObject *resultobj;
34624 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34625 size_t arg2 ;
34626 wxMenu *arg3 = (wxMenu *) 0 ;
34627 wxString *arg4 = 0 ;
34628 wxMenu *result;
34629 bool temp4 = false ;
34630 PyObject * obj0 = 0 ;
34631 PyObject * obj1 = 0 ;
34632 PyObject * obj2 = 0 ;
34633 PyObject * obj3 = 0 ;
34634 char *kwnames[] = {
34635 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34636 };
34637
34638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34640 if (SWIG_arg_fail(1)) SWIG_fail;
34641 {
34642 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34643 if (SWIG_arg_fail(2)) SWIG_fail;
34644 }
34645 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34646 if (SWIG_arg_fail(3)) SWIG_fail;
34647 {
34648 arg4 = wxString_in_helper(obj3);
34649 if (arg4 == NULL) SWIG_fail;
34650 temp4 = true;
34651 }
34652 {
34653 PyThreadState* __tstate = wxPyBeginAllowThreads();
34654 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34655
34656 wxPyEndAllowThreads(__tstate);
34657 if (PyErr_Occurred()) SWIG_fail;
34658 }
34659 {
34660 resultobj = wxPyMake_wxObject(result, 0);
34661 }
34662 {
34663 if (temp4)
34664 delete arg4;
34665 }
34666 return resultobj;
34667 fail:
34668 {
34669 if (temp4)
34670 delete arg4;
34671 }
34672 return NULL;
34673 }
34674
34675
34676 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34677 PyObject *resultobj;
34678 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34679 size_t arg2 ;
34680 wxMenu *result;
34681 PyObject * obj0 = 0 ;
34682 PyObject * obj1 = 0 ;
34683 char *kwnames[] = {
34684 (char *) "self",(char *) "pos", NULL
34685 };
34686
34687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34689 if (SWIG_arg_fail(1)) SWIG_fail;
34690 {
34691 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34692 if (SWIG_arg_fail(2)) SWIG_fail;
34693 }
34694 {
34695 PyThreadState* __tstate = wxPyBeginAllowThreads();
34696 result = (wxMenu *)(arg1)->Remove(arg2);
34697
34698 wxPyEndAllowThreads(__tstate);
34699 if (PyErr_Occurred()) SWIG_fail;
34700 }
34701 {
34702 resultobj = wxPyMake_wxObject(result, 0);
34703 }
34704 return resultobj;
34705 fail:
34706 return NULL;
34707 }
34708
34709
34710 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34711 PyObject *resultobj;
34712 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34713 size_t arg2 ;
34714 bool arg3 ;
34715 PyObject * obj0 = 0 ;
34716 PyObject * obj1 = 0 ;
34717 PyObject * obj2 = 0 ;
34718 char *kwnames[] = {
34719 (char *) "self",(char *) "pos",(char *) "enable", NULL
34720 };
34721
34722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34724 if (SWIG_arg_fail(1)) SWIG_fail;
34725 {
34726 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34727 if (SWIG_arg_fail(2)) SWIG_fail;
34728 }
34729 {
34730 arg3 = (bool)(SWIG_As_bool(obj2));
34731 if (SWIG_arg_fail(3)) SWIG_fail;
34732 }
34733 {
34734 PyThreadState* __tstate = wxPyBeginAllowThreads();
34735 (arg1)->EnableTop(arg2,arg3);
34736
34737 wxPyEndAllowThreads(__tstate);
34738 if (PyErr_Occurred()) SWIG_fail;
34739 }
34740 Py_INCREF(Py_None); resultobj = Py_None;
34741 return resultobj;
34742 fail:
34743 return NULL;
34744 }
34745
34746
34747 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34748 PyObject *resultobj;
34749 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34750 size_t arg2 ;
34751 bool result;
34752 PyObject * obj0 = 0 ;
34753 PyObject * obj1 = 0 ;
34754 char *kwnames[] = {
34755 (char *) "self",(char *) "pos", NULL
34756 };
34757
34758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34760 if (SWIG_arg_fail(1)) SWIG_fail;
34761 {
34762 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34763 if (SWIG_arg_fail(2)) SWIG_fail;
34764 }
34765 {
34766 PyThreadState* __tstate = wxPyBeginAllowThreads();
34767 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34768
34769 wxPyEndAllowThreads(__tstate);
34770 if (PyErr_Occurred()) SWIG_fail;
34771 }
34772 {
34773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34774 }
34775 return resultobj;
34776 fail:
34777 return NULL;
34778 }
34779
34780
34781 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34782 PyObject *resultobj;
34783 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34784 size_t arg2 ;
34785 wxString *arg3 = 0 ;
34786 bool temp3 = false ;
34787 PyObject * obj0 = 0 ;
34788 PyObject * obj1 = 0 ;
34789 PyObject * obj2 = 0 ;
34790 char *kwnames[] = {
34791 (char *) "self",(char *) "pos",(char *) "label", NULL
34792 };
34793
34794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34796 if (SWIG_arg_fail(1)) SWIG_fail;
34797 {
34798 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34799 if (SWIG_arg_fail(2)) SWIG_fail;
34800 }
34801 {
34802 arg3 = wxString_in_helper(obj2);
34803 if (arg3 == NULL) SWIG_fail;
34804 temp3 = true;
34805 }
34806 {
34807 PyThreadState* __tstate = wxPyBeginAllowThreads();
34808 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34809
34810 wxPyEndAllowThreads(__tstate);
34811 if (PyErr_Occurred()) SWIG_fail;
34812 }
34813 Py_INCREF(Py_None); resultobj = Py_None;
34814 {
34815 if (temp3)
34816 delete arg3;
34817 }
34818 return resultobj;
34819 fail:
34820 {
34821 if (temp3)
34822 delete arg3;
34823 }
34824 return NULL;
34825 }
34826
34827
34828 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34829 PyObject *resultobj;
34830 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34831 size_t arg2 ;
34832 wxString result;
34833 PyObject * obj0 = 0 ;
34834 PyObject * obj1 = 0 ;
34835 char *kwnames[] = {
34836 (char *) "self",(char *) "pos", NULL
34837 };
34838
34839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34841 if (SWIG_arg_fail(1)) SWIG_fail;
34842 {
34843 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34844 if (SWIG_arg_fail(2)) SWIG_fail;
34845 }
34846 {
34847 PyThreadState* __tstate = wxPyBeginAllowThreads();
34848 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34849
34850 wxPyEndAllowThreads(__tstate);
34851 if (PyErr_Occurred()) SWIG_fail;
34852 }
34853 {
34854 #if wxUSE_UNICODE
34855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34856 #else
34857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34858 #endif
34859 }
34860 return resultobj;
34861 fail:
34862 return NULL;
34863 }
34864
34865
34866 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34867 PyObject *resultobj;
34868 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34869 wxString *arg2 = 0 ;
34870 wxString *arg3 = 0 ;
34871 int result;
34872 bool temp2 = false ;
34873 bool temp3 = false ;
34874 PyObject * obj0 = 0 ;
34875 PyObject * obj1 = 0 ;
34876 PyObject * obj2 = 0 ;
34877 char *kwnames[] = {
34878 (char *) "self",(char *) "menu",(char *) "item", NULL
34879 };
34880
34881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34883 if (SWIG_arg_fail(1)) SWIG_fail;
34884 {
34885 arg2 = wxString_in_helper(obj1);
34886 if (arg2 == NULL) SWIG_fail;
34887 temp2 = true;
34888 }
34889 {
34890 arg3 = wxString_in_helper(obj2);
34891 if (arg3 == NULL) SWIG_fail;
34892 temp3 = true;
34893 }
34894 {
34895 PyThreadState* __tstate = wxPyBeginAllowThreads();
34896 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34897
34898 wxPyEndAllowThreads(__tstate);
34899 if (PyErr_Occurred()) SWIG_fail;
34900 }
34901 {
34902 resultobj = SWIG_From_int((int)(result));
34903 }
34904 {
34905 if (temp2)
34906 delete arg2;
34907 }
34908 {
34909 if (temp3)
34910 delete arg3;
34911 }
34912 return resultobj;
34913 fail:
34914 {
34915 if (temp2)
34916 delete arg2;
34917 }
34918 {
34919 if (temp3)
34920 delete arg3;
34921 }
34922 return NULL;
34923 }
34924
34925
34926 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34927 PyObject *resultobj;
34928 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34929 int arg2 ;
34930 wxMenuItem *result;
34931 PyObject * obj0 = 0 ;
34932 PyObject * obj1 = 0 ;
34933 char *kwnames[] = {
34934 (char *) "self",(char *) "id", NULL
34935 };
34936
34937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34939 if (SWIG_arg_fail(1)) SWIG_fail;
34940 {
34941 arg2 = (int)(SWIG_As_int(obj1));
34942 if (SWIG_arg_fail(2)) SWIG_fail;
34943 }
34944 {
34945 PyThreadState* __tstate = wxPyBeginAllowThreads();
34946 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34947
34948 wxPyEndAllowThreads(__tstate);
34949 if (PyErr_Occurred()) SWIG_fail;
34950 }
34951 {
34952 resultobj = wxPyMake_wxObject(result, 0);
34953 }
34954 return resultobj;
34955 fail:
34956 return NULL;
34957 }
34958
34959
34960 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34961 PyObject *resultobj;
34962 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34963 wxString *arg2 = 0 ;
34964 int result;
34965 bool temp2 = false ;
34966 PyObject * obj0 = 0 ;
34967 PyObject * obj1 = 0 ;
34968 char *kwnames[] = {
34969 (char *) "self",(char *) "title", NULL
34970 };
34971
34972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34974 if (SWIG_arg_fail(1)) SWIG_fail;
34975 {
34976 arg2 = wxString_in_helper(obj1);
34977 if (arg2 == NULL) SWIG_fail;
34978 temp2 = true;
34979 }
34980 {
34981 PyThreadState* __tstate = wxPyBeginAllowThreads();
34982 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34983
34984 wxPyEndAllowThreads(__tstate);
34985 if (PyErr_Occurred()) SWIG_fail;
34986 }
34987 {
34988 resultobj = SWIG_From_int((int)(result));
34989 }
34990 {
34991 if (temp2)
34992 delete arg2;
34993 }
34994 return resultobj;
34995 fail:
34996 {
34997 if (temp2)
34998 delete arg2;
34999 }
35000 return NULL;
35001 }
35002
35003
35004 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35005 PyObject *resultobj;
35006 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35007 int arg2 ;
35008 bool arg3 ;
35009 PyObject * obj0 = 0 ;
35010 PyObject * obj1 = 0 ;
35011 PyObject * obj2 = 0 ;
35012 char *kwnames[] = {
35013 (char *) "self",(char *) "id",(char *) "enable", NULL
35014 };
35015
35016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35018 if (SWIG_arg_fail(1)) SWIG_fail;
35019 {
35020 arg2 = (int)(SWIG_As_int(obj1));
35021 if (SWIG_arg_fail(2)) SWIG_fail;
35022 }
35023 {
35024 arg3 = (bool)(SWIG_As_bool(obj2));
35025 if (SWIG_arg_fail(3)) SWIG_fail;
35026 }
35027 {
35028 PyThreadState* __tstate = wxPyBeginAllowThreads();
35029 (arg1)->Enable(arg2,arg3);
35030
35031 wxPyEndAllowThreads(__tstate);
35032 if (PyErr_Occurred()) SWIG_fail;
35033 }
35034 Py_INCREF(Py_None); resultobj = Py_None;
35035 return resultobj;
35036 fail:
35037 return NULL;
35038 }
35039
35040
35041 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35042 PyObject *resultobj;
35043 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35044 int arg2 ;
35045 bool arg3 ;
35046 PyObject * obj0 = 0 ;
35047 PyObject * obj1 = 0 ;
35048 PyObject * obj2 = 0 ;
35049 char *kwnames[] = {
35050 (char *) "self",(char *) "id",(char *) "check", NULL
35051 };
35052
35053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35055 if (SWIG_arg_fail(1)) SWIG_fail;
35056 {
35057 arg2 = (int)(SWIG_As_int(obj1));
35058 if (SWIG_arg_fail(2)) SWIG_fail;
35059 }
35060 {
35061 arg3 = (bool)(SWIG_As_bool(obj2));
35062 if (SWIG_arg_fail(3)) SWIG_fail;
35063 }
35064 {
35065 PyThreadState* __tstate = wxPyBeginAllowThreads();
35066 (arg1)->Check(arg2,arg3);
35067
35068 wxPyEndAllowThreads(__tstate);
35069 if (PyErr_Occurred()) SWIG_fail;
35070 }
35071 Py_INCREF(Py_None); resultobj = Py_None;
35072 return resultobj;
35073 fail:
35074 return NULL;
35075 }
35076
35077
35078 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35079 PyObject *resultobj;
35080 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35081 int arg2 ;
35082 bool result;
35083 PyObject * obj0 = 0 ;
35084 PyObject * obj1 = 0 ;
35085 char *kwnames[] = {
35086 (char *) "self",(char *) "id", NULL
35087 };
35088
35089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35091 if (SWIG_arg_fail(1)) SWIG_fail;
35092 {
35093 arg2 = (int)(SWIG_As_int(obj1));
35094 if (SWIG_arg_fail(2)) SWIG_fail;
35095 }
35096 {
35097 PyThreadState* __tstate = wxPyBeginAllowThreads();
35098 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35099
35100 wxPyEndAllowThreads(__tstate);
35101 if (PyErr_Occurred()) SWIG_fail;
35102 }
35103 {
35104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35105 }
35106 return resultobj;
35107 fail:
35108 return NULL;
35109 }
35110
35111
35112 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35113 PyObject *resultobj;
35114 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35115 int arg2 ;
35116 bool result;
35117 PyObject * obj0 = 0 ;
35118 PyObject * obj1 = 0 ;
35119 char *kwnames[] = {
35120 (char *) "self",(char *) "id", NULL
35121 };
35122
35123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35125 if (SWIG_arg_fail(1)) SWIG_fail;
35126 {
35127 arg2 = (int)(SWIG_As_int(obj1));
35128 if (SWIG_arg_fail(2)) SWIG_fail;
35129 }
35130 {
35131 PyThreadState* __tstate = wxPyBeginAllowThreads();
35132 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35133
35134 wxPyEndAllowThreads(__tstate);
35135 if (PyErr_Occurred()) SWIG_fail;
35136 }
35137 {
35138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35139 }
35140 return resultobj;
35141 fail:
35142 return NULL;
35143 }
35144
35145
35146 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35147 PyObject *resultobj;
35148 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35149 int arg2 ;
35150 wxString *arg3 = 0 ;
35151 bool temp3 = false ;
35152 PyObject * obj0 = 0 ;
35153 PyObject * obj1 = 0 ;
35154 PyObject * obj2 = 0 ;
35155 char *kwnames[] = {
35156 (char *) "self",(char *) "id",(char *) "label", NULL
35157 };
35158
35159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35161 if (SWIG_arg_fail(1)) SWIG_fail;
35162 {
35163 arg2 = (int)(SWIG_As_int(obj1));
35164 if (SWIG_arg_fail(2)) SWIG_fail;
35165 }
35166 {
35167 arg3 = wxString_in_helper(obj2);
35168 if (arg3 == NULL) SWIG_fail;
35169 temp3 = true;
35170 }
35171 {
35172 PyThreadState* __tstate = wxPyBeginAllowThreads();
35173 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35174
35175 wxPyEndAllowThreads(__tstate);
35176 if (PyErr_Occurred()) SWIG_fail;
35177 }
35178 Py_INCREF(Py_None); resultobj = Py_None;
35179 {
35180 if (temp3)
35181 delete arg3;
35182 }
35183 return resultobj;
35184 fail:
35185 {
35186 if (temp3)
35187 delete arg3;
35188 }
35189 return NULL;
35190 }
35191
35192
35193 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35194 PyObject *resultobj;
35195 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35196 int arg2 ;
35197 wxString result;
35198 PyObject * obj0 = 0 ;
35199 PyObject * obj1 = 0 ;
35200 char *kwnames[] = {
35201 (char *) "self",(char *) "id", NULL
35202 };
35203
35204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35206 if (SWIG_arg_fail(1)) SWIG_fail;
35207 {
35208 arg2 = (int)(SWIG_As_int(obj1));
35209 if (SWIG_arg_fail(2)) SWIG_fail;
35210 }
35211 {
35212 PyThreadState* __tstate = wxPyBeginAllowThreads();
35213 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35214
35215 wxPyEndAllowThreads(__tstate);
35216 if (PyErr_Occurred()) SWIG_fail;
35217 }
35218 {
35219 #if wxUSE_UNICODE
35220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35221 #else
35222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35223 #endif
35224 }
35225 return resultobj;
35226 fail:
35227 return NULL;
35228 }
35229
35230
35231 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35232 PyObject *resultobj;
35233 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35234 int arg2 ;
35235 wxString *arg3 = 0 ;
35236 bool temp3 = false ;
35237 PyObject * obj0 = 0 ;
35238 PyObject * obj1 = 0 ;
35239 PyObject * obj2 = 0 ;
35240 char *kwnames[] = {
35241 (char *) "self",(char *) "id",(char *) "helpString", NULL
35242 };
35243
35244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35246 if (SWIG_arg_fail(1)) SWIG_fail;
35247 {
35248 arg2 = (int)(SWIG_As_int(obj1));
35249 if (SWIG_arg_fail(2)) SWIG_fail;
35250 }
35251 {
35252 arg3 = wxString_in_helper(obj2);
35253 if (arg3 == NULL) SWIG_fail;
35254 temp3 = true;
35255 }
35256 {
35257 PyThreadState* __tstate = wxPyBeginAllowThreads();
35258 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35259
35260 wxPyEndAllowThreads(__tstate);
35261 if (PyErr_Occurred()) SWIG_fail;
35262 }
35263 Py_INCREF(Py_None); resultobj = Py_None;
35264 {
35265 if (temp3)
35266 delete arg3;
35267 }
35268 return resultobj;
35269 fail:
35270 {
35271 if (temp3)
35272 delete arg3;
35273 }
35274 return NULL;
35275 }
35276
35277
35278 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35279 PyObject *resultobj;
35280 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35281 int arg2 ;
35282 wxString result;
35283 PyObject * obj0 = 0 ;
35284 PyObject * obj1 = 0 ;
35285 char *kwnames[] = {
35286 (char *) "self",(char *) "id", NULL
35287 };
35288
35289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35291 if (SWIG_arg_fail(1)) SWIG_fail;
35292 {
35293 arg2 = (int)(SWIG_As_int(obj1));
35294 if (SWIG_arg_fail(2)) SWIG_fail;
35295 }
35296 {
35297 PyThreadState* __tstate = wxPyBeginAllowThreads();
35298 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35299
35300 wxPyEndAllowThreads(__tstate);
35301 if (PyErr_Occurred()) SWIG_fail;
35302 }
35303 {
35304 #if wxUSE_UNICODE
35305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35306 #else
35307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35308 #endif
35309 }
35310 return resultobj;
35311 fail:
35312 return NULL;
35313 }
35314
35315
35316 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35317 PyObject *resultobj;
35318 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35319 wxFrame *result;
35320 PyObject * obj0 = 0 ;
35321 char *kwnames[] = {
35322 (char *) "self", NULL
35323 };
35324
35325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35327 if (SWIG_arg_fail(1)) SWIG_fail;
35328 {
35329 PyThreadState* __tstate = wxPyBeginAllowThreads();
35330 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35331
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 {
35336 resultobj = wxPyMake_wxObject(result, 0);
35337 }
35338 return resultobj;
35339 fail:
35340 return NULL;
35341 }
35342
35343
35344 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35345 PyObject *resultobj;
35346 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35347 bool result;
35348 PyObject * obj0 = 0 ;
35349 char *kwnames[] = {
35350 (char *) "self", NULL
35351 };
35352
35353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35355 if (SWIG_arg_fail(1)) SWIG_fail;
35356 {
35357 PyThreadState* __tstate = wxPyBeginAllowThreads();
35358 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35359
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 {
35364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35365 }
35366 return resultobj;
35367 fail:
35368 return NULL;
35369 }
35370
35371
35372 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35373 PyObject *resultobj;
35374 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35375 wxFrame *arg2 = (wxFrame *) 0 ;
35376 PyObject * obj0 = 0 ;
35377 PyObject * obj1 = 0 ;
35378 char *kwnames[] = {
35379 (char *) "self",(char *) "frame", NULL
35380 };
35381
35382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35384 if (SWIG_arg_fail(1)) SWIG_fail;
35385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35386 if (SWIG_arg_fail(2)) SWIG_fail;
35387 {
35388 PyThreadState* __tstate = wxPyBeginAllowThreads();
35389 (arg1)->Attach(arg2);
35390
35391 wxPyEndAllowThreads(__tstate);
35392 if (PyErr_Occurred()) SWIG_fail;
35393 }
35394 Py_INCREF(Py_None); resultobj = Py_None;
35395 return resultobj;
35396 fail:
35397 return NULL;
35398 }
35399
35400
35401 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35402 PyObject *resultobj;
35403 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35404 PyObject * obj0 = 0 ;
35405 char *kwnames[] = {
35406 (char *) "self", NULL
35407 };
35408
35409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35411 if (SWIG_arg_fail(1)) SWIG_fail;
35412 {
35413 PyThreadState* __tstate = wxPyBeginAllowThreads();
35414 (arg1)->Detach();
35415
35416 wxPyEndAllowThreads(__tstate);
35417 if (PyErr_Occurred()) SWIG_fail;
35418 }
35419 Py_INCREF(Py_None); resultobj = Py_None;
35420 return resultobj;
35421 fail:
35422 return NULL;
35423 }
35424
35425
35426 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35427 PyObject *obj;
35428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35429 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35430 Py_INCREF(obj);
35431 return Py_BuildValue((char *)"");
35432 }
35433 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35434 PyObject *resultobj;
35435 wxMenu *arg1 = (wxMenu *) NULL ;
35436 int arg2 = (int) wxID_ANY ;
35437 wxString const &arg3_defvalue = wxPyEmptyString ;
35438 wxString *arg3 = (wxString *) &arg3_defvalue ;
35439 wxString const &arg4_defvalue = wxPyEmptyString ;
35440 wxString *arg4 = (wxString *) &arg4_defvalue ;
35441 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35442 wxMenu *arg6 = (wxMenu *) NULL ;
35443 wxMenuItem *result;
35444 bool temp3 = false ;
35445 bool temp4 = false ;
35446 PyObject * obj0 = 0 ;
35447 PyObject * obj1 = 0 ;
35448 PyObject * obj2 = 0 ;
35449 PyObject * obj3 = 0 ;
35450 PyObject * obj4 = 0 ;
35451 PyObject * obj5 = 0 ;
35452 char *kwnames[] = {
35453 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35454 };
35455
35456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35457 if (obj0) {
35458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35459 if (SWIG_arg_fail(1)) SWIG_fail;
35460 }
35461 if (obj1) {
35462 {
35463 arg2 = (int)(SWIG_As_int(obj1));
35464 if (SWIG_arg_fail(2)) SWIG_fail;
35465 }
35466 }
35467 if (obj2) {
35468 {
35469 arg3 = wxString_in_helper(obj2);
35470 if (arg3 == NULL) SWIG_fail;
35471 temp3 = true;
35472 }
35473 }
35474 if (obj3) {
35475 {
35476 arg4 = wxString_in_helper(obj3);
35477 if (arg4 == NULL) SWIG_fail;
35478 temp4 = true;
35479 }
35480 }
35481 if (obj4) {
35482 {
35483 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35484 if (SWIG_arg_fail(5)) SWIG_fail;
35485 }
35486 }
35487 if (obj5) {
35488 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35489 if (SWIG_arg_fail(6)) SWIG_fail;
35490 }
35491 {
35492 PyThreadState* __tstate = wxPyBeginAllowThreads();
35493 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35494
35495 wxPyEndAllowThreads(__tstate);
35496 if (PyErr_Occurred()) SWIG_fail;
35497 }
35498 {
35499 resultobj = wxPyMake_wxObject(result, 1);
35500 }
35501 {
35502 if (temp3)
35503 delete arg3;
35504 }
35505 {
35506 if (temp4)
35507 delete arg4;
35508 }
35509 return resultobj;
35510 fail:
35511 {
35512 if (temp3)
35513 delete arg3;
35514 }
35515 {
35516 if (temp4)
35517 delete arg4;
35518 }
35519 return NULL;
35520 }
35521
35522
35523 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35524 PyObject *resultobj;
35525 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35526 wxMenu *result;
35527 PyObject * obj0 = 0 ;
35528 char *kwnames[] = {
35529 (char *) "self", NULL
35530 };
35531
35532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
35537 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35538
35539 wxPyEndAllowThreads(__tstate);
35540 if (PyErr_Occurred()) SWIG_fail;
35541 }
35542 {
35543 resultobj = wxPyMake_wxObject(result, 0);
35544 }
35545 return resultobj;
35546 fail:
35547 return NULL;
35548 }
35549
35550
35551 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35552 PyObject *resultobj;
35553 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35554 wxMenu *arg2 = (wxMenu *) 0 ;
35555 PyObject * obj0 = 0 ;
35556 PyObject * obj1 = 0 ;
35557 char *kwnames[] = {
35558 (char *) "self",(char *) "menu", NULL
35559 };
35560
35561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35563 if (SWIG_arg_fail(1)) SWIG_fail;
35564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35565 if (SWIG_arg_fail(2)) SWIG_fail;
35566 {
35567 PyThreadState* __tstate = wxPyBeginAllowThreads();
35568 (arg1)->SetMenu(arg2);
35569
35570 wxPyEndAllowThreads(__tstate);
35571 if (PyErr_Occurred()) SWIG_fail;
35572 }
35573 Py_INCREF(Py_None); resultobj = Py_None;
35574 return resultobj;
35575 fail:
35576 return NULL;
35577 }
35578
35579
35580 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35581 PyObject *resultobj;
35582 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35583 int arg2 ;
35584 PyObject * obj0 = 0 ;
35585 PyObject * obj1 = 0 ;
35586 char *kwnames[] = {
35587 (char *) "self",(char *) "id", NULL
35588 };
35589
35590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
35595 if (SWIG_arg_fail(2)) SWIG_fail;
35596 }
35597 {
35598 PyThreadState* __tstate = wxPyBeginAllowThreads();
35599 (arg1)->SetId(arg2);
35600
35601 wxPyEndAllowThreads(__tstate);
35602 if (PyErr_Occurred()) SWIG_fail;
35603 }
35604 Py_INCREF(Py_None); resultobj = Py_None;
35605 return resultobj;
35606 fail:
35607 return NULL;
35608 }
35609
35610
35611 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35612 PyObject *resultobj;
35613 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35614 int result;
35615 PyObject * obj0 = 0 ;
35616 char *kwnames[] = {
35617 (char *) "self", NULL
35618 };
35619
35620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35622 if (SWIG_arg_fail(1)) SWIG_fail;
35623 {
35624 PyThreadState* __tstate = wxPyBeginAllowThreads();
35625 result = (int)((wxMenuItem const *)arg1)->GetId();
35626
35627 wxPyEndAllowThreads(__tstate);
35628 if (PyErr_Occurred()) SWIG_fail;
35629 }
35630 {
35631 resultobj = SWIG_From_int((int)(result));
35632 }
35633 return resultobj;
35634 fail:
35635 return NULL;
35636 }
35637
35638
35639 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35640 PyObject *resultobj;
35641 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35642 bool result;
35643 PyObject * obj0 = 0 ;
35644 char *kwnames[] = {
35645 (char *) "self", NULL
35646 };
35647
35648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35650 if (SWIG_arg_fail(1)) SWIG_fail;
35651 {
35652 PyThreadState* __tstate = wxPyBeginAllowThreads();
35653 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35654
35655 wxPyEndAllowThreads(__tstate);
35656 if (PyErr_Occurred()) SWIG_fail;
35657 }
35658 {
35659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35660 }
35661 return resultobj;
35662 fail:
35663 return NULL;
35664 }
35665
35666
35667 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35668 PyObject *resultobj;
35669 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35670 wxString *arg2 = 0 ;
35671 bool temp2 = false ;
35672 PyObject * obj0 = 0 ;
35673 PyObject * obj1 = 0 ;
35674 char *kwnames[] = {
35675 (char *) "self",(char *) "str", NULL
35676 };
35677
35678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35680 if (SWIG_arg_fail(1)) SWIG_fail;
35681 {
35682 arg2 = wxString_in_helper(obj1);
35683 if (arg2 == NULL) SWIG_fail;
35684 temp2 = true;
35685 }
35686 {
35687 PyThreadState* __tstate = wxPyBeginAllowThreads();
35688 (arg1)->SetText((wxString const &)*arg2);
35689
35690 wxPyEndAllowThreads(__tstate);
35691 if (PyErr_Occurred()) SWIG_fail;
35692 }
35693 Py_INCREF(Py_None); resultobj = Py_None;
35694 {
35695 if (temp2)
35696 delete arg2;
35697 }
35698 return resultobj;
35699 fail:
35700 {
35701 if (temp2)
35702 delete arg2;
35703 }
35704 return NULL;
35705 }
35706
35707
35708 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35709 PyObject *resultobj;
35710 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35711 wxString result;
35712 PyObject * obj0 = 0 ;
35713 char *kwnames[] = {
35714 (char *) "self", NULL
35715 };
35716
35717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35719 if (SWIG_arg_fail(1)) SWIG_fail;
35720 {
35721 PyThreadState* __tstate = wxPyBeginAllowThreads();
35722 result = ((wxMenuItem const *)arg1)->GetLabel();
35723
35724 wxPyEndAllowThreads(__tstate);
35725 if (PyErr_Occurred()) SWIG_fail;
35726 }
35727 {
35728 #if wxUSE_UNICODE
35729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35730 #else
35731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35732 #endif
35733 }
35734 return resultobj;
35735 fail:
35736 return NULL;
35737 }
35738
35739
35740 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35741 PyObject *resultobj;
35742 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35743 wxString *result;
35744 PyObject * obj0 = 0 ;
35745 char *kwnames[] = {
35746 (char *) "self", NULL
35747 };
35748
35749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35751 if (SWIG_arg_fail(1)) SWIG_fail;
35752 {
35753 PyThreadState* __tstate = wxPyBeginAllowThreads();
35754 {
35755 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35756 result = (wxString *) &_result_ref;
35757 }
35758
35759 wxPyEndAllowThreads(__tstate);
35760 if (PyErr_Occurred()) SWIG_fail;
35761 }
35762 {
35763 #if wxUSE_UNICODE
35764 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35765 #else
35766 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35767 #endif
35768 }
35769 return resultobj;
35770 fail:
35771 return NULL;
35772 }
35773
35774
35775 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35776 PyObject *resultobj;
35777 wxString *arg1 = 0 ;
35778 wxString result;
35779 bool temp1 = false ;
35780 PyObject * obj0 = 0 ;
35781 char *kwnames[] = {
35782 (char *) "text", NULL
35783 };
35784
35785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35786 {
35787 arg1 = wxString_in_helper(obj0);
35788 if (arg1 == NULL) SWIG_fail;
35789 temp1 = true;
35790 }
35791 {
35792 PyThreadState* __tstate = wxPyBeginAllowThreads();
35793 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35794
35795 wxPyEndAllowThreads(__tstate);
35796 if (PyErr_Occurred()) SWIG_fail;
35797 }
35798 {
35799 #if wxUSE_UNICODE
35800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35801 #else
35802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35803 #endif
35804 }
35805 {
35806 if (temp1)
35807 delete arg1;
35808 }
35809 return resultobj;
35810 fail:
35811 {
35812 if (temp1)
35813 delete arg1;
35814 }
35815 return NULL;
35816 }
35817
35818
35819 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35820 PyObject *resultobj;
35821 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35822 wxItemKind result;
35823 PyObject * obj0 = 0 ;
35824 char *kwnames[] = {
35825 (char *) "self", NULL
35826 };
35827
35828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35830 if (SWIG_arg_fail(1)) SWIG_fail;
35831 {
35832 PyThreadState* __tstate = wxPyBeginAllowThreads();
35833 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35834
35835 wxPyEndAllowThreads(__tstate);
35836 if (PyErr_Occurred()) SWIG_fail;
35837 }
35838 resultobj = SWIG_From_int((result));
35839 return resultobj;
35840 fail:
35841 return NULL;
35842 }
35843
35844
35845 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35846 PyObject *resultobj;
35847 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35848 wxItemKind arg2 ;
35849 PyObject * obj0 = 0 ;
35850 PyObject * obj1 = 0 ;
35851 char *kwnames[] = {
35852 (char *) "self",(char *) "kind", NULL
35853 };
35854
35855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35857 if (SWIG_arg_fail(1)) SWIG_fail;
35858 {
35859 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35860 if (SWIG_arg_fail(2)) SWIG_fail;
35861 }
35862 {
35863 PyThreadState* __tstate = wxPyBeginAllowThreads();
35864 (arg1)->SetKind((wxItemKind )arg2);
35865
35866 wxPyEndAllowThreads(__tstate);
35867 if (PyErr_Occurred()) SWIG_fail;
35868 }
35869 Py_INCREF(Py_None); resultobj = Py_None;
35870 return resultobj;
35871 fail:
35872 return NULL;
35873 }
35874
35875
35876 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35877 PyObject *resultobj;
35878 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35879 bool arg2 ;
35880 PyObject * obj0 = 0 ;
35881 PyObject * obj1 = 0 ;
35882 char *kwnames[] = {
35883 (char *) "self",(char *) "checkable", NULL
35884 };
35885
35886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35888 if (SWIG_arg_fail(1)) SWIG_fail;
35889 {
35890 arg2 = (bool)(SWIG_As_bool(obj1));
35891 if (SWIG_arg_fail(2)) SWIG_fail;
35892 }
35893 {
35894 PyThreadState* __tstate = wxPyBeginAllowThreads();
35895 (arg1)->SetCheckable(arg2);
35896
35897 wxPyEndAllowThreads(__tstate);
35898 if (PyErr_Occurred()) SWIG_fail;
35899 }
35900 Py_INCREF(Py_None); resultobj = Py_None;
35901 return resultobj;
35902 fail:
35903 return NULL;
35904 }
35905
35906
35907 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35908 PyObject *resultobj;
35909 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35910 bool result;
35911 PyObject * obj0 = 0 ;
35912 char *kwnames[] = {
35913 (char *) "self", NULL
35914 };
35915
35916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35918 if (SWIG_arg_fail(1)) SWIG_fail;
35919 {
35920 PyThreadState* __tstate = wxPyBeginAllowThreads();
35921 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35922
35923 wxPyEndAllowThreads(__tstate);
35924 if (PyErr_Occurred()) SWIG_fail;
35925 }
35926 {
35927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35928 }
35929 return resultobj;
35930 fail:
35931 return NULL;
35932 }
35933
35934
35935 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35936 PyObject *resultobj;
35937 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35938 bool result;
35939 PyObject * obj0 = 0 ;
35940 char *kwnames[] = {
35941 (char *) "self", NULL
35942 };
35943
35944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35946 if (SWIG_arg_fail(1)) SWIG_fail;
35947 {
35948 PyThreadState* __tstate = wxPyBeginAllowThreads();
35949 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35950
35951 wxPyEndAllowThreads(__tstate);
35952 if (PyErr_Occurred()) SWIG_fail;
35953 }
35954 {
35955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35956 }
35957 return resultobj;
35958 fail:
35959 return NULL;
35960 }
35961
35962
35963 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35964 PyObject *resultobj;
35965 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35966 wxMenu *arg2 = (wxMenu *) 0 ;
35967 PyObject * obj0 = 0 ;
35968 PyObject * obj1 = 0 ;
35969 char *kwnames[] = {
35970 (char *) "self",(char *) "menu", NULL
35971 };
35972
35973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35975 if (SWIG_arg_fail(1)) SWIG_fail;
35976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35977 if (SWIG_arg_fail(2)) SWIG_fail;
35978 {
35979 PyThreadState* __tstate = wxPyBeginAllowThreads();
35980 (arg1)->SetSubMenu(arg2);
35981
35982 wxPyEndAllowThreads(__tstate);
35983 if (PyErr_Occurred()) SWIG_fail;
35984 }
35985 Py_INCREF(Py_None); resultobj = Py_None;
35986 return resultobj;
35987 fail:
35988 return NULL;
35989 }
35990
35991
35992 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35993 PyObject *resultobj;
35994 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35995 wxMenu *result;
35996 PyObject * obj0 = 0 ;
35997 char *kwnames[] = {
35998 (char *) "self", NULL
35999 };
36000
36001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36003 if (SWIG_arg_fail(1)) SWIG_fail;
36004 {
36005 PyThreadState* __tstate = wxPyBeginAllowThreads();
36006 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36007
36008 wxPyEndAllowThreads(__tstate);
36009 if (PyErr_Occurred()) SWIG_fail;
36010 }
36011 {
36012 resultobj = wxPyMake_wxObject(result, 0);
36013 }
36014 return resultobj;
36015 fail:
36016 return NULL;
36017 }
36018
36019
36020 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36021 PyObject *resultobj;
36022 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36023 bool arg2 = (bool) true ;
36024 PyObject * obj0 = 0 ;
36025 PyObject * obj1 = 0 ;
36026 char *kwnames[] = {
36027 (char *) "self",(char *) "enable", NULL
36028 };
36029
36030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36032 if (SWIG_arg_fail(1)) SWIG_fail;
36033 if (obj1) {
36034 {
36035 arg2 = (bool)(SWIG_As_bool(obj1));
36036 if (SWIG_arg_fail(2)) SWIG_fail;
36037 }
36038 }
36039 {
36040 PyThreadState* __tstate = wxPyBeginAllowThreads();
36041 (arg1)->Enable(arg2);
36042
36043 wxPyEndAllowThreads(__tstate);
36044 if (PyErr_Occurred()) SWIG_fail;
36045 }
36046 Py_INCREF(Py_None); resultobj = Py_None;
36047 return resultobj;
36048 fail:
36049 return NULL;
36050 }
36051
36052
36053 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36054 PyObject *resultobj;
36055 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36056 bool result;
36057 PyObject * obj0 = 0 ;
36058 char *kwnames[] = {
36059 (char *) "self", NULL
36060 };
36061
36062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36064 if (SWIG_arg_fail(1)) SWIG_fail;
36065 {
36066 PyThreadState* __tstate = wxPyBeginAllowThreads();
36067 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36068
36069 wxPyEndAllowThreads(__tstate);
36070 if (PyErr_Occurred()) SWIG_fail;
36071 }
36072 {
36073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36074 }
36075 return resultobj;
36076 fail:
36077 return NULL;
36078 }
36079
36080
36081 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36082 PyObject *resultobj;
36083 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36084 bool arg2 = (bool) true ;
36085 PyObject * obj0 = 0 ;
36086 PyObject * obj1 = 0 ;
36087 char *kwnames[] = {
36088 (char *) "self",(char *) "check", NULL
36089 };
36090
36091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36093 if (SWIG_arg_fail(1)) SWIG_fail;
36094 if (obj1) {
36095 {
36096 arg2 = (bool)(SWIG_As_bool(obj1));
36097 if (SWIG_arg_fail(2)) SWIG_fail;
36098 }
36099 }
36100 {
36101 PyThreadState* __tstate = wxPyBeginAllowThreads();
36102 (arg1)->Check(arg2);
36103
36104 wxPyEndAllowThreads(__tstate);
36105 if (PyErr_Occurred()) SWIG_fail;
36106 }
36107 Py_INCREF(Py_None); resultobj = Py_None;
36108 return resultobj;
36109 fail:
36110 return NULL;
36111 }
36112
36113
36114 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36115 PyObject *resultobj;
36116 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36117 bool result;
36118 PyObject * obj0 = 0 ;
36119 char *kwnames[] = {
36120 (char *) "self", NULL
36121 };
36122
36123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36125 if (SWIG_arg_fail(1)) SWIG_fail;
36126 {
36127 PyThreadState* __tstate = wxPyBeginAllowThreads();
36128 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36129
36130 wxPyEndAllowThreads(__tstate);
36131 if (PyErr_Occurred()) SWIG_fail;
36132 }
36133 {
36134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36135 }
36136 return resultobj;
36137 fail:
36138 return NULL;
36139 }
36140
36141
36142 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36143 PyObject *resultobj;
36144 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36145 PyObject * obj0 = 0 ;
36146 char *kwnames[] = {
36147 (char *) "self", NULL
36148 };
36149
36150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36152 if (SWIG_arg_fail(1)) SWIG_fail;
36153 {
36154 PyThreadState* __tstate = wxPyBeginAllowThreads();
36155 (arg1)->Toggle();
36156
36157 wxPyEndAllowThreads(__tstate);
36158 if (PyErr_Occurred()) SWIG_fail;
36159 }
36160 Py_INCREF(Py_None); resultobj = Py_None;
36161 return resultobj;
36162 fail:
36163 return NULL;
36164 }
36165
36166
36167 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36168 PyObject *resultobj;
36169 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36170 wxString *arg2 = 0 ;
36171 bool temp2 = false ;
36172 PyObject * obj0 = 0 ;
36173 PyObject * obj1 = 0 ;
36174 char *kwnames[] = {
36175 (char *) "self",(char *) "str", NULL
36176 };
36177
36178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36180 if (SWIG_arg_fail(1)) SWIG_fail;
36181 {
36182 arg2 = wxString_in_helper(obj1);
36183 if (arg2 == NULL) SWIG_fail;
36184 temp2 = true;
36185 }
36186 {
36187 PyThreadState* __tstate = wxPyBeginAllowThreads();
36188 (arg1)->SetHelp((wxString const &)*arg2);
36189
36190 wxPyEndAllowThreads(__tstate);
36191 if (PyErr_Occurred()) SWIG_fail;
36192 }
36193 Py_INCREF(Py_None); resultobj = Py_None;
36194 {
36195 if (temp2)
36196 delete arg2;
36197 }
36198 return resultobj;
36199 fail:
36200 {
36201 if (temp2)
36202 delete arg2;
36203 }
36204 return NULL;
36205 }
36206
36207
36208 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36209 PyObject *resultobj;
36210 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36211 wxString *result;
36212 PyObject * obj0 = 0 ;
36213 char *kwnames[] = {
36214 (char *) "self", NULL
36215 };
36216
36217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36219 if (SWIG_arg_fail(1)) SWIG_fail;
36220 {
36221 PyThreadState* __tstate = wxPyBeginAllowThreads();
36222 {
36223 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36224 result = (wxString *) &_result_ref;
36225 }
36226
36227 wxPyEndAllowThreads(__tstate);
36228 if (PyErr_Occurred()) SWIG_fail;
36229 }
36230 {
36231 #if wxUSE_UNICODE
36232 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36233 #else
36234 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36235 #endif
36236 }
36237 return resultobj;
36238 fail:
36239 return NULL;
36240 }
36241
36242
36243 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36244 PyObject *resultobj;
36245 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36246 wxAcceleratorEntry *result;
36247 PyObject * obj0 = 0 ;
36248 char *kwnames[] = {
36249 (char *) "self", NULL
36250 };
36251
36252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36254 if (SWIG_arg_fail(1)) SWIG_fail;
36255 {
36256 PyThreadState* __tstate = wxPyBeginAllowThreads();
36257 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36258
36259 wxPyEndAllowThreads(__tstate);
36260 if (PyErr_Occurred()) SWIG_fail;
36261 }
36262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36263 return resultobj;
36264 fail:
36265 return NULL;
36266 }
36267
36268
36269 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36270 PyObject *resultobj;
36271 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36272 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36273 PyObject * obj0 = 0 ;
36274 PyObject * obj1 = 0 ;
36275 char *kwnames[] = {
36276 (char *) "self",(char *) "accel", NULL
36277 };
36278
36279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36281 if (SWIG_arg_fail(1)) SWIG_fail;
36282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36283 if (SWIG_arg_fail(2)) SWIG_fail;
36284 {
36285 PyThreadState* __tstate = wxPyBeginAllowThreads();
36286 (arg1)->SetAccel(arg2);
36287
36288 wxPyEndAllowThreads(__tstate);
36289 if (PyErr_Occurred()) SWIG_fail;
36290 }
36291 Py_INCREF(Py_None); resultobj = Py_None;
36292 return resultobj;
36293 fail:
36294 return NULL;
36295 }
36296
36297
36298 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36299 PyObject *resultobj;
36300 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36301 wxFont *arg2 = 0 ;
36302 PyObject * obj0 = 0 ;
36303 PyObject * obj1 = 0 ;
36304 char *kwnames[] = {
36305 (char *) "self",(char *) "font", NULL
36306 };
36307
36308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36310 if (SWIG_arg_fail(1)) SWIG_fail;
36311 {
36312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36313 if (SWIG_arg_fail(2)) SWIG_fail;
36314 if (arg2 == NULL) {
36315 SWIG_null_ref("wxFont");
36316 }
36317 if (SWIG_arg_fail(2)) SWIG_fail;
36318 }
36319 {
36320 PyThreadState* __tstate = wxPyBeginAllowThreads();
36321 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36322
36323 wxPyEndAllowThreads(__tstate);
36324 if (PyErr_Occurred()) SWIG_fail;
36325 }
36326 Py_INCREF(Py_None); resultobj = Py_None;
36327 return resultobj;
36328 fail:
36329 return NULL;
36330 }
36331
36332
36333 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36334 PyObject *resultobj;
36335 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36336 wxFont result;
36337 PyObject * obj0 = 0 ;
36338 char *kwnames[] = {
36339 (char *) "self", NULL
36340 };
36341
36342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36344 if (SWIG_arg_fail(1)) SWIG_fail;
36345 {
36346 PyThreadState* __tstate = wxPyBeginAllowThreads();
36347 result = wxMenuItem_GetFont(arg1);
36348
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 {
36353 wxFont * resultptr;
36354 resultptr = new wxFont((wxFont &)(result));
36355 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36356 }
36357 return resultobj;
36358 fail:
36359 return NULL;
36360 }
36361
36362
36363 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36364 PyObject *resultobj;
36365 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36366 wxColour *arg2 = 0 ;
36367 wxColour temp2 ;
36368 PyObject * obj0 = 0 ;
36369 PyObject * obj1 = 0 ;
36370 char *kwnames[] = {
36371 (char *) "self",(char *) "colText", NULL
36372 };
36373
36374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36376 if (SWIG_arg_fail(1)) SWIG_fail;
36377 {
36378 arg2 = &temp2;
36379 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36380 }
36381 {
36382 PyThreadState* __tstate = wxPyBeginAllowThreads();
36383 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36384
36385 wxPyEndAllowThreads(__tstate);
36386 if (PyErr_Occurred()) SWIG_fail;
36387 }
36388 Py_INCREF(Py_None); resultobj = Py_None;
36389 return resultobj;
36390 fail:
36391 return NULL;
36392 }
36393
36394
36395 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36396 PyObject *resultobj;
36397 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36398 wxColour result;
36399 PyObject * obj0 = 0 ;
36400 char *kwnames[] = {
36401 (char *) "self", NULL
36402 };
36403
36404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36406 if (SWIG_arg_fail(1)) SWIG_fail;
36407 {
36408 PyThreadState* __tstate = wxPyBeginAllowThreads();
36409 result = wxMenuItem_GetTextColour(arg1);
36410
36411 wxPyEndAllowThreads(__tstate);
36412 if (PyErr_Occurred()) SWIG_fail;
36413 }
36414 {
36415 wxColour * resultptr;
36416 resultptr = new wxColour((wxColour &)(result));
36417 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36418 }
36419 return resultobj;
36420 fail:
36421 return NULL;
36422 }
36423
36424
36425 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36426 PyObject *resultobj;
36427 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36428 wxColour *arg2 = 0 ;
36429 wxColour temp2 ;
36430 PyObject * obj0 = 0 ;
36431 PyObject * obj1 = 0 ;
36432 char *kwnames[] = {
36433 (char *) "self",(char *) "colBack", NULL
36434 };
36435
36436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36438 if (SWIG_arg_fail(1)) SWIG_fail;
36439 {
36440 arg2 = &temp2;
36441 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36442 }
36443 {
36444 PyThreadState* __tstate = wxPyBeginAllowThreads();
36445 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36446
36447 wxPyEndAllowThreads(__tstate);
36448 if (PyErr_Occurred()) SWIG_fail;
36449 }
36450 Py_INCREF(Py_None); resultobj = Py_None;
36451 return resultobj;
36452 fail:
36453 return NULL;
36454 }
36455
36456
36457 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36458 PyObject *resultobj;
36459 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36460 wxColour result;
36461 PyObject * obj0 = 0 ;
36462 char *kwnames[] = {
36463 (char *) "self", NULL
36464 };
36465
36466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36468 if (SWIG_arg_fail(1)) SWIG_fail;
36469 {
36470 PyThreadState* __tstate = wxPyBeginAllowThreads();
36471 result = wxMenuItem_GetBackgroundColour(arg1);
36472
36473 wxPyEndAllowThreads(__tstate);
36474 if (PyErr_Occurred()) SWIG_fail;
36475 }
36476 {
36477 wxColour * resultptr;
36478 resultptr = new wxColour((wxColour &)(result));
36479 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36480 }
36481 return resultobj;
36482 fail:
36483 return NULL;
36484 }
36485
36486
36487 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36488 PyObject *resultobj;
36489 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36490 wxBitmap *arg2 = 0 ;
36491 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36492 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36493 PyObject * obj0 = 0 ;
36494 PyObject * obj1 = 0 ;
36495 PyObject * obj2 = 0 ;
36496 char *kwnames[] = {
36497 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36498 };
36499
36500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36502 if (SWIG_arg_fail(1)) SWIG_fail;
36503 {
36504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36505 if (SWIG_arg_fail(2)) SWIG_fail;
36506 if (arg2 == NULL) {
36507 SWIG_null_ref("wxBitmap");
36508 }
36509 if (SWIG_arg_fail(2)) SWIG_fail;
36510 }
36511 if (obj2) {
36512 {
36513 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36514 if (SWIG_arg_fail(3)) SWIG_fail;
36515 if (arg3 == NULL) {
36516 SWIG_null_ref("wxBitmap");
36517 }
36518 if (SWIG_arg_fail(3)) SWIG_fail;
36519 }
36520 }
36521 {
36522 PyThreadState* __tstate = wxPyBeginAllowThreads();
36523 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36524
36525 wxPyEndAllowThreads(__tstate);
36526 if (PyErr_Occurred()) SWIG_fail;
36527 }
36528 Py_INCREF(Py_None); resultobj = Py_None;
36529 return resultobj;
36530 fail:
36531 return NULL;
36532 }
36533
36534
36535 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36536 PyObject *resultobj;
36537 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36538 wxBitmap *arg2 = 0 ;
36539 PyObject * obj0 = 0 ;
36540 PyObject * obj1 = 0 ;
36541 char *kwnames[] = {
36542 (char *) "self",(char *) "bmpDisabled", NULL
36543 };
36544
36545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36547 if (SWIG_arg_fail(1)) SWIG_fail;
36548 {
36549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36550 if (SWIG_arg_fail(2)) SWIG_fail;
36551 if (arg2 == NULL) {
36552 SWIG_null_ref("wxBitmap");
36553 }
36554 if (SWIG_arg_fail(2)) SWIG_fail;
36555 }
36556 {
36557 PyThreadState* __tstate = wxPyBeginAllowThreads();
36558 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
36559
36560 wxPyEndAllowThreads(__tstate);
36561 if (PyErr_Occurred()) SWIG_fail;
36562 }
36563 Py_INCREF(Py_None); resultobj = Py_None;
36564 return resultobj;
36565 fail:
36566 return NULL;
36567 }
36568
36569
36570 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36571 PyObject *resultobj;
36572 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36573 wxBitmap *result;
36574 PyObject * obj0 = 0 ;
36575 char *kwnames[] = {
36576 (char *) "self", NULL
36577 };
36578
36579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36581 if (SWIG_arg_fail(1)) SWIG_fail;
36582 {
36583 PyThreadState* __tstate = wxPyBeginAllowThreads();
36584 {
36585 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
36586 result = (wxBitmap *) &_result_ref;
36587 }
36588
36589 wxPyEndAllowThreads(__tstate);
36590 if (PyErr_Occurred()) SWIG_fail;
36591 }
36592 {
36593 wxBitmap* resultptr = new wxBitmap(*result);
36594 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36595 }
36596 return resultobj;
36597 fail:
36598 return NULL;
36599 }
36600
36601
36602 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36603 PyObject *resultobj;
36604 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36605 int arg2 ;
36606 PyObject * obj0 = 0 ;
36607 PyObject * obj1 = 0 ;
36608 char *kwnames[] = {
36609 (char *) "self",(char *) "nWidth", NULL
36610 };
36611
36612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36614 if (SWIG_arg_fail(1)) SWIG_fail;
36615 {
36616 arg2 = (int)(SWIG_As_int(obj1));
36617 if (SWIG_arg_fail(2)) SWIG_fail;
36618 }
36619 {
36620 PyThreadState* __tstate = wxPyBeginAllowThreads();
36621 wxMenuItem_SetMarginWidth(arg1,arg2);
36622
36623 wxPyEndAllowThreads(__tstate);
36624 if (PyErr_Occurred()) SWIG_fail;
36625 }
36626 Py_INCREF(Py_None); resultobj = Py_None;
36627 return resultobj;
36628 fail:
36629 return NULL;
36630 }
36631
36632
36633 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36634 PyObject *resultobj;
36635 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36636 int result;
36637 PyObject * obj0 = 0 ;
36638 char *kwnames[] = {
36639 (char *) "self", NULL
36640 };
36641
36642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36644 if (SWIG_arg_fail(1)) SWIG_fail;
36645 {
36646 PyThreadState* __tstate = wxPyBeginAllowThreads();
36647 result = (int)wxMenuItem_GetMarginWidth(arg1);
36648
36649 wxPyEndAllowThreads(__tstate);
36650 if (PyErr_Occurred()) SWIG_fail;
36651 }
36652 {
36653 resultobj = SWIG_From_int((int)(result));
36654 }
36655 return resultobj;
36656 fail:
36657 return NULL;
36658 }
36659
36660
36661 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36662 PyObject *resultobj;
36663 int result;
36664 char *kwnames[] = {
36665 NULL
36666 };
36667
36668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36669 {
36670 PyThreadState* __tstate = wxPyBeginAllowThreads();
36671 result = (int)MenuItem_GetDefaultMarginWidth();
36672
36673 wxPyEndAllowThreads(__tstate);
36674 if (PyErr_Occurred()) SWIG_fail;
36675 }
36676 {
36677 resultobj = SWIG_From_int((int)(result));
36678 }
36679 return resultobj;
36680 fail:
36681 return NULL;
36682 }
36683
36684
36685 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36686 PyObject *resultobj;
36687 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36688 bool result;
36689 PyObject * obj0 = 0 ;
36690 char *kwnames[] = {
36691 (char *) "self", NULL
36692 };
36693
36694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36696 if (SWIG_arg_fail(1)) SWIG_fail;
36697 {
36698 PyThreadState* __tstate = wxPyBeginAllowThreads();
36699 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
36700
36701 wxPyEndAllowThreads(__tstate);
36702 if (PyErr_Occurred()) SWIG_fail;
36703 }
36704 {
36705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36706 }
36707 return resultobj;
36708 fail:
36709 return NULL;
36710 }
36711
36712
36713 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36714 PyObject *resultobj;
36715 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36716 bool arg2 = (bool) true ;
36717 PyObject * obj0 = 0 ;
36718 PyObject * obj1 = 0 ;
36719 char *kwnames[] = {
36720 (char *) "self",(char *) "ownerDrawn", NULL
36721 };
36722
36723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36725 if (SWIG_arg_fail(1)) SWIG_fail;
36726 if (obj1) {
36727 {
36728 arg2 = (bool)(SWIG_As_bool(obj1));
36729 if (SWIG_arg_fail(2)) SWIG_fail;
36730 }
36731 }
36732 {
36733 PyThreadState* __tstate = wxPyBeginAllowThreads();
36734 wxMenuItem_SetOwnerDrawn(arg1,arg2);
36735
36736 wxPyEndAllowThreads(__tstate);
36737 if (PyErr_Occurred()) SWIG_fail;
36738 }
36739 Py_INCREF(Py_None); resultobj = Py_None;
36740 return resultobj;
36741 fail:
36742 return NULL;
36743 }
36744
36745
36746 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36747 PyObject *resultobj;
36748 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36749 PyObject * obj0 = 0 ;
36750 char *kwnames[] = {
36751 (char *) "self", NULL
36752 };
36753
36754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36756 if (SWIG_arg_fail(1)) SWIG_fail;
36757 {
36758 PyThreadState* __tstate = wxPyBeginAllowThreads();
36759 wxMenuItem_ResetOwnerDrawn(arg1);
36760
36761 wxPyEndAllowThreads(__tstate);
36762 if (PyErr_Occurred()) SWIG_fail;
36763 }
36764 Py_INCREF(Py_None); resultobj = Py_None;
36765 return resultobj;
36766 fail:
36767 return NULL;
36768 }
36769
36770
36771 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36772 PyObject *resultobj;
36773 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36774 wxBitmap *arg2 = 0 ;
36775 PyObject * obj0 = 0 ;
36776 PyObject * obj1 = 0 ;
36777 char *kwnames[] = {
36778 (char *) "self",(char *) "bitmap", NULL
36779 };
36780
36781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36783 if (SWIG_arg_fail(1)) SWIG_fail;
36784 {
36785 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36786 if (SWIG_arg_fail(2)) SWIG_fail;
36787 if (arg2 == NULL) {
36788 SWIG_null_ref("wxBitmap");
36789 }
36790 if (SWIG_arg_fail(2)) SWIG_fail;
36791 }
36792 {
36793 PyThreadState* __tstate = wxPyBeginAllowThreads();
36794 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36795
36796 wxPyEndAllowThreads(__tstate);
36797 if (PyErr_Occurred()) SWIG_fail;
36798 }
36799 Py_INCREF(Py_None); resultobj = Py_None;
36800 return resultobj;
36801 fail:
36802 return NULL;
36803 }
36804
36805
36806 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36807 PyObject *resultobj;
36808 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36809 wxBitmap *result;
36810 PyObject * obj0 = 0 ;
36811 char *kwnames[] = {
36812 (char *) "self", NULL
36813 };
36814
36815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36817 if (SWIG_arg_fail(1)) SWIG_fail;
36818 {
36819 PyThreadState* __tstate = wxPyBeginAllowThreads();
36820 {
36821 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36822 result = (wxBitmap *) &_result_ref;
36823 }
36824
36825 wxPyEndAllowThreads(__tstate);
36826 if (PyErr_Occurred()) SWIG_fail;
36827 }
36828 {
36829 wxBitmap* resultptr = new wxBitmap(*result);
36830 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36831 }
36832 return resultobj;
36833 fail:
36834 return NULL;
36835 }
36836
36837
36838 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36839 PyObject *obj;
36840 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36841 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36842 Py_INCREF(obj);
36843 return Py_BuildValue((char *)"");
36844 }
36845 static int _wrap_ControlNameStr_set(PyObject *) {
36846 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36847 return 1;
36848 }
36849
36850
36851 static PyObject *_wrap_ControlNameStr_get(void) {
36852 PyObject *pyobj;
36853
36854 {
36855 #if wxUSE_UNICODE
36856 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36857 #else
36858 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36859 #endif
36860 }
36861 return pyobj;
36862 }
36863
36864
36865 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36866 PyObject *resultobj;
36867 wxWindow *arg1 = (wxWindow *) 0 ;
36868 int arg2 = (int) -1 ;
36869 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36870 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36871 wxSize const &arg4_defvalue = wxDefaultSize ;
36872 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36873 long arg5 = (long) 0 ;
36874 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36875 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36876 wxString const &arg7_defvalue = wxPyControlNameStr ;
36877 wxString *arg7 = (wxString *) &arg7_defvalue ;
36878 wxControl *result;
36879 wxPoint temp3 ;
36880 wxSize temp4 ;
36881 bool temp7 = false ;
36882 PyObject * obj0 = 0 ;
36883 PyObject * obj1 = 0 ;
36884 PyObject * obj2 = 0 ;
36885 PyObject * obj3 = 0 ;
36886 PyObject * obj4 = 0 ;
36887 PyObject * obj5 = 0 ;
36888 PyObject * obj6 = 0 ;
36889 char *kwnames[] = {
36890 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36891 };
36892
36893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36895 if (SWIG_arg_fail(1)) SWIG_fail;
36896 if (obj1) {
36897 {
36898 arg2 = (int)(SWIG_As_int(obj1));
36899 if (SWIG_arg_fail(2)) SWIG_fail;
36900 }
36901 }
36902 if (obj2) {
36903 {
36904 arg3 = &temp3;
36905 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36906 }
36907 }
36908 if (obj3) {
36909 {
36910 arg4 = &temp4;
36911 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36912 }
36913 }
36914 if (obj4) {
36915 {
36916 arg5 = (long)(SWIG_As_long(obj4));
36917 if (SWIG_arg_fail(5)) SWIG_fail;
36918 }
36919 }
36920 if (obj5) {
36921 {
36922 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36923 if (SWIG_arg_fail(6)) SWIG_fail;
36924 if (arg6 == NULL) {
36925 SWIG_null_ref("wxValidator");
36926 }
36927 if (SWIG_arg_fail(6)) SWIG_fail;
36928 }
36929 }
36930 if (obj6) {
36931 {
36932 arg7 = wxString_in_helper(obj6);
36933 if (arg7 == NULL) SWIG_fail;
36934 temp7 = true;
36935 }
36936 }
36937 {
36938 if (!wxPyCheckForApp()) SWIG_fail;
36939 PyThreadState* __tstate = wxPyBeginAllowThreads();
36940 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36941
36942 wxPyEndAllowThreads(__tstate);
36943 if (PyErr_Occurred()) SWIG_fail;
36944 }
36945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36946 {
36947 if (temp7)
36948 delete arg7;
36949 }
36950 return resultobj;
36951 fail:
36952 {
36953 if (temp7)
36954 delete arg7;
36955 }
36956 return NULL;
36957 }
36958
36959
36960 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36961 PyObject *resultobj;
36962 wxControl *result;
36963 char *kwnames[] = {
36964 NULL
36965 };
36966
36967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36968 {
36969 if (!wxPyCheckForApp()) SWIG_fail;
36970 PyThreadState* __tstate = wxPyBeginAllowThreads();
36971 result = (wxControl *)new wxControl();
36972
36973 wxPyEndAllowThreads(__tstate);
36974 if (PyErr_Occurred()) SWIG_fail;
36975 }
36976 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36977 return resultobj;
36978 fail:
36979 return NULL;
36980 }
36981
36982
36983 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36984 PyObject *resultobj;
36985 wxControl *arg1 = (wxControl *) 0 ;
36986 wxWindow *arg2 = (wxWindow *) 0 ;
36987 int arg3 = (int) -1 ;
36988 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36989 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36990 wxSize const &arg5_defvalue = wxDefaultSize ;
36991 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36992 long arg6 = (long) 0 ;
36993 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36994 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36995 wxString const &arg8_defvalue = wxPyControlNameStr ;
36996 wxString *arg8 = (wxString *) &arg8_defvalue ;
36997 bool result;
36998 wxPoint temp4 ;
36999 wxSize temp5 ;
37000 bool temp8 = false ;
37001 PyObject * obj0 = 0 ;
37002 PyObject * obj1 = 0 ;
37003 PyObject * obj2 = 0 ;
37004 PyObject * obj3 = 0 ;
37005 PyObject * obj4 = 0 ;
37006 PyObject * obj5 = 0 ;
37007 PyObject * obj6 = 0 ;
37008 PyObject * obj7 = 0 ;
37009 char *kwnames[] = {
37010 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37011 };
37012
37013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37015 if (SWIG_arg_fail(1)) SWIG_fail;
37016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37017 if (SWIG_arg_fail(2)) SWIG_fail;
37018 if (obj2) {
37019 {
37020 arg3 = (int)(SWIG_As_int(obj2));
37021 if (SWIG_arg_fail(3)) SWIG_fail;
37022 }
37023 }
37024 if (obj3) {
37025 {
37026 arg4 = &temp4;
37027 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37028 }
37029 }
37030 if (obj4) {
37031 {
37032 arg5 = &temp5;
37033 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37034 }
37035 }
37036 if (obj5) {
37037 {
37038 arg6 = (long)(SWIG_As_long(obj5));
37039 if (SWIG_arg_fail(6)) SWIG_fail;
37040 }
37041 }
37042 if (obj6) {
37043 {
37044 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37045 if (SWIG_arg_fail(7)) SWIG_fail;
37046 if (arg7 == NULL) {
37047 SWIG_null_ref("wxValidator");
37048 }
37049 if (SWIG_arg_fail(7)) SWIG_fail;
37050 }
37051 }
37052 if (obj7) {
37053 {
37054 arg8 = wxString_in_helper(obj7);
37055 if (arg8 == NULL) SWIG_fail;
37056 temp8 = true;
37057 }
37058 }
37059 {
37060 PyThreadState* __tstate = wxPyBeginAllowThreads();
37061 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37062
37063 wxPyEndAllowThreads(__tstate);
37064 if (PyErr_Occurred()) SWIG_fail;
37065 }
37066 {
37067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37068 }
37069 {
37070 if (temp8)
37071 delete arg8;
37072 }
37073 return resultobj;
37074 fail:
37075 {
37076 if (temp8)
37077 delete arg8;
37078 }
37079 return NULL;
37080 }
37081
37082
37083 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37084 PyObject *resultobj;
37085 wxControl *arg1 = (wxControl *) 0 ;
37086 wxCommandEvent *arg2 = 0 ;
37087 PyObject * obj0 = 0 ;
37088 PyObject * obj1 = 0 ;
37089 char *kwnames[] = {
37090 (char *) "self",(char *) "event", NULL
37091 };
37092
37093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37095 if (SWIG_arg_fail(1)) SWIG_fail;
37096 {
37097 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37098 if (SWIG_arg_fail(2)) SWIG_fail;
37099 if (arg2 == NULL) {
37100 SWIG_null_ref("wxCommandEvent");
37101 }
37102 if (SWIG_arg_fail(2)) SWIG_fail;
37103 }
37104 {
37105 PyThreadState* __tstate = wxPyBeginAllowThreads();
37106 (arg1)->Command(*arg2);
37107
37108 wxPyEndAllowThreads(__tstate);
37109 if (PyErr_Occurred()) SWIG_fail;
37110 }
37111 Py_INCREF(Py_None); resultobj = Py_None;
37112 return resultobj;
37113 fail:
37114 return NULL;
37115 }
37116
37117
37118 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37119 PyObject *resultobj;
37120 wxControl *arg1 = (wxControl *) 0 ;
37121 wxString result;
37122 PyObject * obj0 = 0 ;
37123 char *kwnames[] = {
37124 (char *) "self", NULL
37125 };
37126
37127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37129 if (SWIG_arg_fail(1)) SWIG_fail;
37130 {
37131 PyThreadState* __tstate = wxPyBeginAllowThreads();
37132 result = (arg1)->GetLabel();
37133
37134 wxPyEndAllowThreads(__tstate);
37135 if (PyErr_Occurred()) SWIG_fail;
37136 }
37137 {
37138 #if wxUSE_UNICODE
37139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37140 #else
37141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37142 #endif
37143 }
37144 return resultobj;
37145 fail:
37146 return NULL;
37147 }
37148
37149
37150 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37151 PyObject *resultobj;
37152 wxControl *arg1 = (wxControl *) 0 ;
37153 wxString *arg2 = 0 ;
37154 bool temp2 = false ;
37155 PyObject * obj0 = 0 ;
37156 PyObject * obj1 = 0 ;
37157 char *kwnames[] = {
37158 (char *) "self",(char *) "label", NULL
37159 };
37160
37161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37163 if (SWIG_arg_fail(1)) SWIG_fail;
37164 {
37165 arg2 = wxString_in_helper(obj1);
37166 if (arg2 == NULL) SWIG_fail;
37167 temp2 = true;
37168 }
37169 {
37170 PyThreadState* __tstate = wxPyBeginAllowThreads();
37171 (arg1)->SetLabel((wxString const &)*arg2);
37172
37173 wxPyEndAllowThreads(__tstate);
37174 if (PyErr_Occurred()) SWIG_fail;
37175 }
37176 Py_INCREF(Py_None); resultobj = Py_None;
37177 {
37178 if (temp2)
37179 delete arg2;
37180 }
37181 return resultobj;
37182 fail:
37183 {
37184 if (temp2)
37185 delete arg2;
37186 }
37187 return NULL;
37188 }
37189
37190
37191 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37192 PyObject *resultobj;
37193 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37194 wxVisualAttributes result;
37195 PyObject * obj0 = 0 ;
37196 char *kwnames[] = {
37197 (char *) "variant", NULL
37198 };
37199
37200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37201 if (obj0) {
37202 {
37203 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37204 if (SWIG_arg_fail(1)) SWIG_fail;
37205 }
37206 }
37207 {
37208 if (!wxPyCheckForApp()) SWIG_fail;
37209 PyThreadState* __tstate = wxPyBeginAllowThreads();
37210 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37211
37212 wxPyEndAllowThreads(__tstate);
37213 if (PyErr_Occurred()) SWIG_fail;
37214 }
37215 {
37216 wxVisualAttributes * resultptr;
37217 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37218 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37219 }
37220 return resultobj;
37221 fail:
37222 return NULL;
37223 }
37224
37225
37226 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37227 PyObject *obj;
37228 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37229 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37230 Py_INCREF(obj);
37231 return Py_BuildValue((char *)"");
37232 }
37233 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37234 PyObject *resultobj;
37235 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37236 wxString *arg2 = 0 ;
37237 PyObject *arg3 = (PyObject *) NULL ;
37238 int result;
37239 bool temp2 = false ;
37240 PyObject * obj0 = 0 ;
37241 PyObject * obj1 = 0 ;
37242 PyObject * obj2 = 0 ;
37243 char *kwnames[] = {
37244 (char *) "self",(char *) "item",(char *) "clientData", NULL
37245 };
37246
37247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37249 if (SWIG_arg_fail(1)) SWIG_fail;
37250 {
37251 arg2 = wxString_in_helper(obj1);
37252 if (arg2 == NULL) SWIG_fail;
37253 temp2 = true;
37254 }
37255 if (obj2) {
37256 arg3 = obj2;
37257 }
37258 {
37259 PyThreadState* __tstate = wxPyBeginAllowThreads();
37260 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37261
37262 wxPyEndAllowThreads(__tstate);
37263 if (PyErr_Occurred()) SWIG_fail;
37264 }
37265 {
37266 resultobj = SWIG_From_int((int)(result));
37267 }
37268 {
37269 if (temp2)
37270 delete arg2;
37271 }
37272 return resultobj;
37273 fail:
37274 {
37275 if (temp2)
37276 delete arg2;
37277 }
37278 return NULL;
37279 }
37280
37281
37282 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37283 PyObject *resultobj;
37284 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37285 wxArrayString *arg2 = 0 ;
37286 bool temp2 = false ;
37287 PyObject * obj0 = 0 ;
37288 PyObject * obj1 = 0 ;
37289 char *kwnames[] = {
37290 (char *) "self",(char *) "strings", NULL
37291 };
37292
37293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37295 if (SWIG_arg_fail(1)) SWIG_fail;
37296 {
37297 if (! PySequence_Check(obj1)) {
37298 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37299 SWIG_fail;
37300 }
37301 arg2 = new wxArrayString;
37302 temp2 = true;
37303 int i, len=PySequence_Length(obj1);
37304 for (i=0; i<len; i++) {
37305 PyObject* item = PySequence_GetItem(obj1, i);
37306 #if wxUSE_UNICODE
37307 PyObject* str = PyObject_Unicode(item);
37308 #else
37309 PyObject* str = PyObject_Str(item);
37310 #endif
37311 if (PyErr_Occurred()) SWIG_fail;
37312 arg2->Add(Py2wxString(str));
37313 Py_DECREF(item);
37314 Py_DECREF(str);
37315 }
37316 }
37317 {
37318 PyThreadState* __tstate = wxPyBeginAllowThreads();
37319 (arg1)->Append((wxArrayString const &)*arg2);
37320
37321 wxPyEndAllowThreads(__tstate);
37322 if (PyErr_Occurred()) SWIG_fail;
37323 }
37324 Py_INCREF(Py_None); resultobj = Py_None;
37325 {
37326 if (temp2) delete arg2;
37327 }
37328 return resultobj;
37329 fail:
37330 {
37331 if (temp2) delete arg2;
37332 }
37333 return NULL;
37334 }
37335
37336
37337 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37338 PyObject *resultobj;
37339 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37340 wxString *arg2 = 0 ;
37341 int arg3 ;
37342 PyObject *arg4 = (PyObject *) NULL ;
37343 int result;
37344 bool temp2 = false ;
37345 PyObject * obj0 = 0 ;
37346 PyObject * obj1 = 0 ;
37347 PyObject * obj2 = 0 ;
37348 PyObject * obj3 = 0 ;
37349 char *kwnames[] = {
37350 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37351 };
37352
37353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37355 if (SWIG_arg_fail(1)) SWIG_fail;
37356 {
37357 arg2 = wxString_in_helper(obj1);
37358 if (arg2 == NULL) SWIG_fail;
37359 temp2 = true;
37360 }
37361 {
37362 arg3 = (int)(SWIG_As_int(obj2));
37363 if (SWIG_arg_fail(3)) SWIG_fail;
37364 }
37365 if (obj3) {
37366 arg4 = obj3;
37367 }
37368 {
37369 PyThreadState* __tstate = wxPyBeginAllowThreads();
37370 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37371
37372 wxPyEndAllowThreads(__tstate);
37373 if (PyErr_Occurred()) SWIG_fail;
37374 }
37375 {
37376 resultobj = SWIG_From_int((int)(result));
37377 }
37378 {
37379 if (temp2)
37380 delete arg2;
37381 }
37382 return resultobj;
37383 fail:
37384 {
37385 if (temp2)
37386 delete arg2;
37387 }
37388 return NULL;
37389 }
37390
37391
37392 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37393 PyObject *resultobj;
37394 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37395 PyObject * obj0 = 0 ;
37396 char *kwnames[] = {
37397 (char *) "self", NULL
37398 };
37399
37400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37402 if (SWIG_arg_fail(1)) SWIG_fail;
37403 {
37404 PyThreadState* __tstate = wxPyBeginAllowThreads();
37405 (arg1)->Clear();
37406
37407 wxPyEndAllowThreads(__tstate);
37408 if (PyErr_Occurred()) SWIG_fail;
37409 }
37410 Py_INCREF(Py_None); resultobj = Py_None;
37411 return resultobj;
37412 fail:
37413 return NULL;
37414 }
37415
37416
37417 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37418 PyObject *resultobj;
37419 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37420 int arg2 ;
37421 PyObject * obj0 = 0 ;
37422 PyObject * obj1 = 0 ;
37423 char *kwnames[] = {
37424 (char *) "self",(char *) "n", NULL
37425 };
37426
37427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37429 if (SWIG_arg_fail(1)) SWIG_fail;
37430 {
37431 arg2 = (int)(SWIG_As_int(obj1));
37432 if (SWIG_arg_fail(2)) SWIG_fail;
37433 }
37434 {
37435 PyThreadState* __tstate = wxPyBeginAllowThreads();
37436 (arg1)->Delete(arg2);
37437
37438 wxPyEndAllowThreads(__tstate);
37439 if (PyErr_Occurred()) SWIG_fail;
37440 }
37441 Py_INCREF(Py_None); resultobj = Py_None;
37442 return resultobj;
37443 fail:
37444 return NULL;
37445 }
37446
37447
37448 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37449 PyObject *resultobj;
37450 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37451 int arg2 ;
37452 PyObject *result;
37453 PyObject * obj0 = 0 ;
37454 PyObject * obj1 = 0 ;
37455 char *kwnames[] = {
37456 (char *) "self",(char *) "n", NULL
37457 };
37458
37459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37461 if (SWIG_arg_fail(1)) SWIG_fail;
37462 {
37463 arg2 = (int)(SWIG_As_int(obj1));
37464 if (SWIG_arg_fail(2)) SWIG_fail;
37465 }
37466 {
37467 PyThreadState* __tstate = wxPyBeginAllowThreads();
37468 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37469
37470 wxPyEndAllowThreads(__tstate);
37471 if (PyErr_Occurred()) SWIG_fail;
37472 }
37473 resultobj = result;
37474 return resultobj;
37475 fail:
37476 return NULL;
37477 }
37478
37479
37480 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37481 PyObject *resultobj;
37482 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37483 int arg2 ;
37484 PyObject *arg3 = (PyObject *) 0 ;
37485 PyObject * obj0 = 0 ;
37486 PyObject * obj1 = 0 ;
37487 PyObject * obj2 = 0 ;
37488 char *kwnames[] = {
37489 (char *) "self",(char *) "n",(char *) "clientData", NULL
37490 };
37491
37492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37494 if (SWIG_arg_fail(1)) SWIG_fail;
37495 {
37496 arg2 = (int)(SWIG_As_int(obj1));
37497 if (SWIG_arg_fail(2)) SWIG_fail;
37498 }
37499 arg3 = obj2;
37500 {
37501 PyThreadState* __tstate = wxPyBeginAllowThreads();
37502 wxItemContainer_SetClientData(arg1,arg2,arg3);
37503
37504 wxPyEndAllowThreads(__tstate);
37505 if (PyErr_Occurred()) SWIG_fail;
37506 }
37507 Py_INCREF(Py_None); resultobj = Py_None;
37508 return resultobj;
37509 fail:
37510 return NULL;
37511 }
37512
37513
37514 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37515 PyObject *resultobj;
37516 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37517 int result;
37518 PyObject * obj0 = 0 ;
37519 char *kwnames[] = {
37520 (char *) "self", NULL
37521 };
37522
37523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37525 if (SWIG_arg_fail(1)) SWIG_fail;
37526 {
37527 PyThreadState* __tstate = wxPyBeginAllowThreads();
37528 result = (int)((wxItemContainer const *)arg1)->GetCount();
37529
37530 wxPyEndAllowThreads(__tstate);
37531 if (PyErr_Occurred()) SWIG_fail;
37532 }
37533 {
37534 resultobj = SWIG_From_int((int)(result));
37535 }
37536 return resultobj;
37537 fail:
37538 return NULL;
37539 }
37540
37541
37542 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37543 PyObject *resultobj;
37544 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37545 bool result;
37546 PyObject * obj0 = 0 ;
37547 char *kwnames[] = {
37548 (char *) "self", NULL
37549 };
37550
37551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37553 if (SWIG_arg_fail(1)) SWIG_fail;
37554 {
37555 PyThreadState* __tstate = wxPyBeginAllowThreads();
37556 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37557
37558 wxPyEndAllowThreads(__tstate);
37559 if (PyErr_Occurred()) SWIG_fail;
37560 }
37561 {
37562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37563 }
37564 return resultobj;
37565 fail:
37566 return NULL;
37567 }
37568
37569
37570 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37571 PyObject *resultobj;
37572 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37573 int arg2 ;
37574 wxString result;
37575 PyObject * obj0 = 0 ;
37576 PyObject * obj1 = 0 ;
37577 char *kwnames[] = {
37578 (char *) "self",(char *) "n", NULL
37579 };
37580
37581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37583 if (SWIG_arg_fail(1)) SWIG_fail;
37584 {
37585 arg2 = (int)(SWIG_As_int(obj1));
37586 if (SWIG_arg_fail(2)) SWIG_fail;
37587 }
37588 {
37589 PyThreadState* __tstate = wxPyBeginAllowThreads();
37590 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37591
37592 wxPyEndAllowThreads(__tstate);
37593 if (PyErr_Occurred()) SWIG_fail;
37594 }
37595 {
37596 #if wxUSE_UNICODE
37597 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37598 #else
37599 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37600 #endif
37601 }
37602 return resultobj;
37603 fail:
37604 return NULL;
37605 }
37606
37607
37608 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37609 PyObject *resultobj;
37610 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37611 wxArrayString result;
37612 PyObject * obj0 = 0 ;
37613 char *kwnames[] = {
37614 (char *) "self", NULL
37615 };
37616
37617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37619 if (SWIG_arg_fail(1)) SWIG_fail;
37620 {
37621 PyThreadState* __tstate = wxPyBeginAllowThreads();
37622 result = ((wxItemContainer const *)arg1)->GetStrings();
37623
37624 wxPyEndAllowThreads(__tstate);
37625 if (PyErr_Occurred()) SWIG_fail;
37626 }
37627 {
37628 resultobj = wxArrayString2PyList_helper(result);
37629 }
37630 return resultobj;
37631 fail:
37632 return NULL;
37633 }
37634
37635
37636 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37637 PyObject *resultobj;
37638 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37639 int arg2 ;
37640 wxString *arg3 = 0 ;
37641 bool temp3 = false ;
37642 PyObject * obj0 = 0 ;
37643 PyObject * obj1 = 0 ;
37644 PyObject * obj2 = 0 ;
37645 char *kwnames[] = {
37646 (char *) "self",(char *) "n",(char *) "s", NULL
37647 };
37648
37649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37651 if (SWIG_arg_fail(1)) SWIG_fail;
37652 {
37653 arg2 = (int)(SWIG_As_int(obj1));
37654 if (SWIG_arg_fail(2)) SWIG_fail;
37655 }
37656 {
37657 arg3 = wxString_in_helper(obj2);
37658 if (arg3 == NULL) SWIG_fail;
37659 temp3 = true;
37660 }
37661 {
37662 PyThreadState* __tstate = wxPyBeginAllowThreads();
37663 (arg1)->SetString(arg2,(wxString const &)*arg3);
37664
37665 wxPyEndAllowThreads(__tstate);
37666 if (PyErr_Occurred()) SWIG_fail;
37667 }
37668 Py_INCREF(Py_None); resultobj = Py_None;
37669 {
37670 if (temp3)
37671 delete arg3;
37672 }
37673 return resultobj;
37674 fail:
37675 {
37676 if (temp3)
37677 delete arg3;
37678 }
37679 return NULL;
37680 }
37681
37682
37683 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37684 PyObject *resultobj;
37685 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37686 wxString *arg2 = 0 ;
37687 int result;
37688 bool temp2 = false ;
37689 PyObject * obj0 = 0 ;
37690 PyObject * obj1 = 0 ;
37691 char *kwnames[] = {
37692 (char *) "self",(char *) "s", NULL
37693 };
37694
37695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37697 if (SWIG_arg_fail(1)) SWIG_fail;
37698 {
37699 arg2 = wxString_in_helper(obj1);
37700 if (arg2 == NULL) SWIG_fail;
37701 temp2 = true;
37702 }
37703 {
37704 PyThreadState* __tstate = wxPyBeginAllowThreads();
37705 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37706
37707 wxPyEndAllowThreads(__tstate);
37708 if (PyErr_Occurred()) SWIG_fail;
37709 }
37710 {
37711 resultobj = SWIG_From_int((int)(result));
37712 }
37713 {
37714 if (temp2)
37715 delete arg2;
37716 }
37717 return resultobj;
37718 fail:
37719 {
37720 if (temp2)
37721 delete arg2;
37722 }
37723 return NULL;
37724 }
37725
37726
37727 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37728 PyObject *resultobj;
37729 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37730 int arg2 ;
37731 PyObject * obj0 = 0 ;
37732 PyObject * obj1 = 0 ;
37733 char *kwnames[] = {
37734 (char *) "self",(char *) "n", NULL
37735 };
37736
37737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
37738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37739 if (SWIG_arg_fail(1)) SWIG_fail;
37740 {
37741 arg2 = (int)(SWIG_As_int(obj1));
37742 if (SWIG_arg_fail(2)) SWIG_fail;
37743 }
37744 {
37745 PyThreadState* __tstate = wxPyBeginAllowThreads();
37746 (arg1)->SetSelection(arg2);
37747
37748 wxPyEndAllowThreads(__tstate);
37749 if (PyErr_Occurred()) SWIG_fail;
37750 }
37751 Py_INCREF(Py_None); resultobj = Py_None;
37752 return resultobj;
37753 fail:
37754 return NULL;
37755 }
37756
37757
37758 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37759 PyObject *resultobj;
37760 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37761 int result;
37762 PyObject * obj0 = 0 ;
37763 char *kwnames[] = {
37764 (char *) "self", NULL
37765 };
37766
37767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37769 if (SWIG_arg_fail(1)) SWIG_fail;
37770 {
37771 PyThreadState* __tstate = wxPyBeginAllowThreads();
37772 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37773
37774 wxPyEndAllowThreads(__tstate);
37775 if (PyErr_Occurred()) SWIG_fail;
37776 }
37777 {
37778 resultobj = SWIG_From_int((int)(result));
37779 }
37780 return resultobj;
37781 fail:
37782 return NULL;
37783 }
37784
37785
37786 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37787 PyObject *resultobj;
37788 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37789 wxString *arg2 = 0 ;
37790 bool result;
37791 bool temp2 = false ;
37792 PyObject * obj0 = 0 ;
37793 PyObject * obj1 = 0 ;
37794 char *kwnames[] = {
37795 (char *) "self",(char *) "s", NULL
37796 };
37797
37798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
37799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37800 if (SWIG_arg_fail(1)) SWIG_fail;
37801 {
37802 arg2 = wxString_in_helper(obj1);
37803 if (arg2 == NULL) SWIG_fail;
37804 temp2 = true;
37805 }
37806 {
37807 PyThreadState* __tstate = wxPyBeginAllowThreads();
37808 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
37809
37810 wxPyEndAllowThreads(__tstate);
37811 if (PyErr_Occurred()) SWIG_fail;
37812 }
37813 {
37814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37815 }
37816 {
37817 if (temp2)
37818 delete arg2;
37819 }
37820 return resultobj;
37821 fail:
37822 {
37823 if (temp2)
37824 delete arg2;
37825 }
37826 return NULL;
37827 }
37828
37829
37830 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37831 PyObject *resultobj;
37832 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37833 wxString result;
37834 PyObject * obj0 = 0 ;
37835 char *kwnames[] = {
37836 (char *) "self", NULL
37837 };
37838
37839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37841 if (SWIG_arg_fail(1)) SWIG_fail;
37842 {
37843 PyThreadState* __tstate = wxPyBeginAllowThreads();
37844 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37845
37846 wxPyEndAllowThreads(__tstate);
37847 if (PyErr_Occurred()) SWIG_fail;
37848 }
37849 {
37850 #if wxUSE_UNICODE
37851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37852 #else
37853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37854 #endif
37855 }
37856 return resultobj;
37857 fail:
37858 return NULL;
37859 }
37860
37861
37862 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37863 PyObject *resultobj;
37864 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37865 int arg2 ;
37866 PyObject * obj0 = 0 ;
37867 PyObject * obj1 = 0 ;
37868 char *kwnames[] = {
37869 (char *) "self",(char *) "n", NULL
37870 };
37871
37872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37874 if (SWIG_arg_fail(1)) SWIG_fail;
37875 {
37876 arg2 = (int)(SWIG_As_int(obj1));
37877 if (SWIG_arg_fail(2)) SWIG_fail;
37878 }
37879 {
37880 PyThreadState* __tstate = wxPyBeginAllowThreads();
37881 (arg1)->Select(arg2);
37882
37883 wxPyEndAllowThreads(__tstate);
37884 if (PyErr_Occurred()) SWIG_fail;
37885 }
37886 Py_INCREF(Py_None); resultobj = Py_None;
37887 return resultobj;
37888 fail:
37889 return NULL;
37890 }
37891
37892
37893 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37894 PyObject *obj;
37895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37896 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37897 Py_INCREF(obj);
37898 return Py_BuildValue((char *)"");
37899 }
37900 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37901 PyObject *obj;
37902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37903 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37904 Py_INCREF(obj);
37905 return Py_BuildValue((char *)"");
37906 }
37907 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37908 PyObject *resultobj;
37909 wxSizerItem *result;
37910 char *kwnames[] = {
37911 NULL
37912 };
37913
37914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37915 {
37916 PyThreadState* __tstate = wxPyBeginAllowThreads();
37917 result = (wxSizerItem *)new wxSizerItem();
37918
37919 wxPyEndAllowThreads(__tstate);
37920 if (PyErr_Occurred()) SWIG_fail;
37921 }
37922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37923 return resultobj;
37924 fail:
37925 return NULL;
37926 }
37927
37928
37929 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37930 PyObject *resultobj;
37931 wxWindow *arg1 = (wxWindow *) 0 ;
37932 int arg2 ;
37933 int arg3 ;
37934 int arg4 ;
37935 PyObject *arg5 = (PyObject *) NULL ;
37936 wxSizerItem *result;
37937 PyObject * obj0 = 0 ;
37938 PyObject * obj1 = 0 ;
37939 PyObject * obj2 = 0 ;
37940 PyObject * obj3 = 0 ;
37941 PyObject * obj4 = 0 ;
37942 char *kwnames[] = {
37943 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37944 };
37945
37946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37948 if (SWIG_arg_fail(1)) SWIG_fail;
37949 {
37950 arg2 = (int)(SWIG_As_int(obj1));
37951 if (SWIG_arg_fail(2)) SWIG_fail;
37952 }
37953 {
37954 arg3 = (int)(SWIG_As_int(obj2));
37955 if (SWIG_arg_fail(3)) SWIG_fail;
37956 }
37957 {
37958 arg4 = (int)(SWIG_As_int(obj3));
37959 if (SWIG_arg_fail(4)) SWIG_fail;
37960 }
37961 if (obj4) {
37962 arg5 = obj4;
37963 }
37964 {
37965 PyThreadState* __tstate = wxPyBeginAllowThreads();
37966 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37967
37968 wxPyEndAllowThreads(__tstate);
37969 if (PyErr_Occurred()) SWIG_fail;
37970 }
37971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37972 return resultobj;
37973 fail:
37974 return NULL;
37975 }
37976
37977
37978 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37979 PyObject *resultobj;
37980 int arg1 ;
37981 int arg2 ;
37982 int arg3 ;
37983 int arg4 ;
37984 int arg5 ;
37985 PyObject *arg6 = (PyObject *) NULL ;
37986 wxSizerItem *result;
37987 PyObject * obj0 = 0 ;
37988 PyObject * obj1 = 0 ;
37989 PyObject * obj2 = 0 ;
37990 PyObject * obj3 = 0 ;
37991 PyObject * obj4 = 0 ;
37992 PyObject * obj5 = 0 ;
37993 char *kwnames[] = {
37994 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37995 };
37996
37997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37998 {
37999 arg1 = (int)(SWIG_As_int(obj0));
38000 if (SWIG_arg_fail(1)) SWIG_fail;
38001 }
38002 {
38003 arg2 = (int)(SWIG_As_int(obj1));
38004 if (SWIG_arg_fail(2)) SWIG_fail;
38005 }
38006 {
38007 arg3 = (int)(SWIG_As_int(obj2));
38008 if (SWIG_arg_fail(3)) SWIG_fail;
38009 }
38010 {
38011 arg4 = (int)(SWIG_As_int(obj3));
38012 if (SWIG_arg_fail(4)) SWIG_fail;
38013 }
38014 {
38015 arg5 = (int)(SWIG_As_int(obj4));
38016 if (SWIG_arg_fail(5)) SWIG_fail;
38017 }
38018 if (obj5) {
38019 arg6 = obj5;
38020 }
38021 {
38022 PyThreadState* __tstate = wxPyBeginAllowThreads();
38023 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38024
38025 wxPyEndAllowThreads(__tstate);
38026 if (PyErr_Occurred()) SWIG_fail;
38027 }
38028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38029 return resultobj;
38030 fail:
38031 return NULL;
38032 }
38033
38034
38035 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38036 PyObject *resultobj;
38037 wxSizer *arg1 = (wxSizer *) 0 ;
38038 int arg2 ;
38039 int arg3 ;
38040 int arg4 ;
38041 PyObject *arg5 = (PyObject *) NULL ;
38042 wxSizerItem *result;
38043 PyObject * obj0 = 0 ;
38044 PyObject * obj1 = 0 ;
38045 PyObject * obj2 = 0 ;
38046 PyObject * obj3 = 0 ;
38047 PyObject * obj4 = 0 ;
38048 char *kwnames[] = {
38049 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38050 };
38051
38052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38054 if (SWIG_arg_fail(1)) SWIG_fail;
38055 {
38056 arg2 = (int)(SWIG_As_int(obj1));
38057 if (SWIG_arg_fail(2)) SWIG_fail;
38058 }
38059 {
38060 arg3 = (int)(SWIG_As_int(obj2));
38061 if (SWIG_arg_fail(3)) SWIG_fail;
38062 }
38063 {
38064 arg4 = (int)(SWIG_As_int(obj3));
38065 if (SWIG_arg_fail(4)) SWIG_fail;
38066 }
38067 if (obj4) {
38068 arg5 = obj4;
38069 }
38070 {
38071 PyThreadState* __tstate = wxPyBeginAllowThreads();
38072 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38073
38074 wxPyEndAllowThreads(__tstate);
38075 if (PyErr_Occurred()) SWIG_fail;
38076 }
38077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38078 return resultobj;
38079 fail:
38080 return NULL;
38081 }
38082
38083
38084 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38085 PyObject *resultobj;
38086 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38087 PyObject * obj0 = 0 ;
38088 char *kwnames[] = {
38089 (char *) "self", NULL
38090 };
38091
38092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38094 if (SWIG_arg_fail(1)) SWIG_fail;
38095 {
38096 PyThreadState* __tstate = wxPyBeginAllowThreads();
38097 (arg1)->DeleteWindows();
38098
38099 wxPyEndAllowThreads(__tstate);
38100 if (PyErr_Occurred()) SWIG_fail;
38101 }
38102 Py_INCREF(Py_None); resultobj = Py_None;
38103 return resultobj;
38104 fail:
38105 return NULL;
38106 }
38107
38108
38109 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38110 PyObject *resultobj;
38111 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38112 PyObject * obj0 = 0 ;
38113 char *kwnames[] = {
38114 (char *) "self", NULL
38115 };
38116
38117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38119 if (SWIG_arg_fail(1)) SWIG_fail;
38120 {
38121 PyThreadState* __tstate = wxPyBeginAllowThreads();
38122 (arg1)->DetachSizer();
38123
38124 wxPyEndAllowThreads(__tstate);
38125 if (PyErr_Occurred()) SWIG_fail;
38126 }
38127 Py_INCREF(Py_None); resultobj = Py_None;
38128 return resultobj;
38129 fail:
38130 return NULL;
38131 }
38132
38133
38134 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38135 PyObject *resultobj;
38136 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38137 wxSize result;
38138 PyObject * obj0 = 0 ;
38139 char *kwnames[] = {
38140 (char *) "self", NULL
38141 };
38142
38143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38145 if (SWIG_arg_fail(1)) SWIG_fail;
38146 {
38147 PyThreadState* __tstate = wxPyBeginAllowThreads();
38148 result = (arg1)->GetSize();
38149
38150 wxPyEndAllowThreads(__tstate);
38151 if (PyErr_Occurred()) SWIG_fail;
38152 }
38153 {
38154 wxSize * resultptr;
38155 resultptr = new wxSize((wxSize &)(result));
38156 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38157 }
38158 return resultobj;
38159 fail:
38160 return NULL;
38161 }
38162
38163
38164 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38165 PyObject *resultobj;
38166 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38167 wxSize result;
38168 PyObject * obj0 = 0 ;
38169 char *kwnames[] = {
38170 (char *) "self", NULL
38171 };
38172
38173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38175 if (SWIG_arg_fail(1)) SWIG_fail;
38176 {
38177 PyThreadState* __tstate = wxPyBeginAllowThreads();
38178 result = (arg1)->CalcMin();
38179
38180 wxPyEndAllowThreads(__tstate);
38181 if (PyErr_Occurred()) SWIG_fail;
38182 }
38183 {
38184 wxSize * resultptr;
38185 resultptr = new wxSize((wxSize &)(result));
38186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38187 }
38188 return resultobj;
38189 fail:
38190 return NULL;
38191 }
38192
38193
38194 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38195 PyObject *resultobj;
38196 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38197 wxPoint arg2 ;
38198 wxSize arg3 ;
38199 PyObject * obj0 = 0 ;
38200 PyObject * obj1 = 0 ;
38201 PyObject * obj2 = 0 ;
38202 char *kwnames[] = {
38203 (char *) "self",(char *) "pos",(char *) "size", NULL
38204 };
38205
38206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38208 if (SWIG_arg_fail(1)) SWIG_fail;
38209 {
38210 wxPoint * argp;
38211 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38212 if (SWIG_arg_fail(2)) SWIG_fail;
38213 if (argp == NULL) {
38214 SWIG_null_ref("wxPoint");
38215 }
38216 if (SWIG_arg_fail(2)) SWIG_fail;
38217 arg2 = *argp;
38218 }
38219 {
38220 wxSize * argp;
38221 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38222 if (SWIG_arg_fail(3)) SWIG_fail;
38223 if (argp == NULL) {
38224 SWIG_null_ref("wxSize");
38225 }
38226 if (SWIG_arg_fail(3)) SWIG_fail;
38227 arg3 = *argp;
38228 }
38229 {
38230 PyThreadState* __tstate = wxPyBeginAllowThreads();
38231 (arg1)->SetDimension(arg2,arg3);
38232
38233 wxPyEndAllowThreads(__tstate);
38234 if (PyErr_Occurred()) SWIG_fail;
38235 }
38236 Py_INCREF(Py_None); resultobj = Py_None;
38237 return resultobj;
38238 fail:
38239 return NULL;
38240 }
38241
38242
38243 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38244 PyObject *resultobj;
38245 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38246 wxSize result;
38247 PyObject * obj0 = 0 ;
38248 char *kwnames[] = {
38249 (char *) "self", NULL
38250 };
38251
38252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38254 if (SWIG_arg_fail(1)) SWIG_fail;
38255 {
38256 PyThreadState* __tstate = wxPyBeginAllowThreads();
38257 result = (arg1)->GetMinSize();
38258
38259 wxPyEndAllowThreads(__tstate);
38260 if (PyErr_Occurred()) SWIG_fail;
38261 }
38262 {
38263 wxSize * resultptr;
38264 resultptr = new wxSize((wxSize &)(result));
38265 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38266 }
38267 return resultobj;
38268 fail:
38269 return NULL;
38270 }
38271
38272
38273 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38274 PyObject *resultobj;
38275 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38276 wxSize result;
38277 PyObject * obj0 = 0 ;
38278 char *kwnames[] = {
38279 (char *) "self", NULL
38280 };
38281
38282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38284 if (SWIG_arg_fail(1)) SWIG_fail;
38285 {
38286 PyThreadState* __tstate = wxPyBeginAllowThreads();
38287 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38288
38289 wxPyEndAllowThreads(__tstate);
38290 if (PyErr_Occurred()) SWIG_fail;
38291 }
38292 {
38293 wxSize * resultptr;
38294 resultptr = new wxSize((wxSize &)(result));
38295 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38296 }
38297 return resultobj;
38298 fail:
38299 return NULL;
38300 }
38301
38302
38303 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38304 PyObject *resultobj;
38305 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38306 int arg2 ;
38307 int arg3 ;
38308 PyObject * obj0 = 0 ;
38309 PyObject * obj1 = 0 ;
38310 PyObject * obj2 = 0 ;
38311 char *kwnames[] = {
38312 (char *) "self",(char *) "x",(char *) "y", NULL
38313 };
38314
38315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38317 if (SWIG_arg_fail(1)) SWIG_fail;
38318 {
38319 arg2 = (int)(SWIG_As_int(obj1));
38320 if (SWIG_arg_fail(2)) SWIG_fail;
38321 }
38322 {
38323 arg3 = (int)(SWIG_As_int(obj2));
38324 if (SWIG_arg_fail(3)) SWIG_fail;
38325 }
38326 {
38327 PyThreadState* __tstate = wxPyBeginAllowThreads();
38328 (arg1)->SetInitSize(arg2,arg3);
38329
38330 wxPyEndAllowThreads(__tstate);
38331 if (PyErr_Occurred()) SWIG_fail;
38332 }
38333 Py_INCREF(Py_None); resultobj = Py_None;
38334 return resultobj;
38335 fail:
38336 return NULL;
38337 }
38338
38339
38340 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38341 PyObject *resultobj;
38342 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38343 int arg2 ;
38344 int arg3 ;
38345 PyObject * obj0 = 0 ;
38346 PyObject * obj1 = 0 ;
38347 PyObject * obj2 = 0 ;
38348 char *kwnames[] = {
38349 (char *) "self",(char *) "width",(char *) "height", NULL
38350 };
38351
38352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38354 if (SWIG_arg_fail(1)) SWIG_fail;
38355 {
38356 arg2 = (int)(SWIG_As_int(obj1));
38357 if (SWIG_arg_fail(2)) SWIG_fail;
38358 }
38359 {
38360 arg3 = (int)(SWIG_As_int(obj2));
38361 if (SWIG_arg_fail(3)) SWIG_fail;
38362 }
38363 {
38364 PyThreadState* __tstate = wxPyBeginAllowThreads();
38365 (arg1)->SetRatio(arg2,arg3);
38366
38367 wxPyEndAllowThreads(__tstate);
38368 if (PyErr_Occurred()) SWIG_fail;
38369 }
38370 Py_INCREF(Py_None); resultobj = Py_None;
38371 return resultobj;
38372 fail:
38373 return NULL;
38374 }
38375
38376
38377 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38378 PyObject *resultobj;
38379 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38380 wxSize arg2 ;
38381 PyObject * obj0 = 0 ;
38382 PyObject * obj1 = 0 ;
38383 char *kwnames[] = {
38384 (char *) "self",(char *) "size", NULL
38385 };
38386
38387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38389 if (SWIG_arg_fail(1)) SWIG_fail;
38390 {
38391 wxSize * argp;
38392 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38393 if (SWIG_arg_fail(2)) SWIG_fail;
38394 if (argp == NULL) {
38395 SWIG_null_ref("wxSize");
38396 }
38397 if (SWIG_arg_fail(2)) SWIG_fail;
38398 arg2 = *argp;
38399 }
38400 {
38401 PyThreadState* __tstate = wxPyBeginAllowThreads();
38402 (arg1)->SetRatio(arg2);
38403
38404 wxPyEndAllowThreads(__tstate);
38405 if (PyErr_Occurred()) SWIG_fail;
38406 }
38407 Py_INCREF(Py_None); resultobj = Py_None;
38408 return resultobj;
38409 fail:
38410 return NULL;
38411 }
38412
38413
38414 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38415 PyObject *resultobj;
38416 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38417 float arg2 ;
38418 PyObject * obj0 = 0 ;
38419 PyObject * obj1 = 0 ;
38420 char *kwnames[] = {
38421 (char *) "self",(char *) "ratio", NULL
38422 };
38423
38424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38426 if (SWIG_arg_fail(1)) SWIG_fail;
38427 {
38428 arg2 = (float)(SWIG_As_float(obj1));
38429 if (SWIG_arg_fail(2)) SWIG_fail;
38430 }
38431 {
38432 PyThreadState* __tstate = wxPyBeginAllowThreads();
38433 (arg1)->SetRatio(arg2);
38434
38435 wxPyEndAllowThreads(__tstate);
38436 if (PyErr_Occurred()) SWIG_fail;
38437 }
38438 Py_INCREF(Py_None); resultobj = Py_None;
38439 return resultobj;
38440 fail:
38441 return NULL;
38442 }
38443
38444
38445 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38446 PyObject *resultobj;
38447 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38448 float result;
38449 PyObject * obj0 = 0 ;
38450 char *kwnames[] = {
38451 (char *) "self", NULL
38452 };
38453
38454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38456 if (SWIG_arg_fail(1)) SWIG_fail;
38457 {
38458 PyThreadState* __tstate = wxPyBeginAllowThreads();
38459 result = (float)(arg1)->GetRatio();
38460
38461 wxPyEndAllowThreads(__tstate);
38462 if (PyErr_Occurred()) SWIG_fail;
38463 }
38464 {
38465 resultobj = SWIG_From_float((float)(result));
38466 }
38467 return resultobj;
38468 fail:
38469 return NULL;
38470 }
38471
38472
38473 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38474 PyObject *resultobj;
38475 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38476 wxRect result;
38477 PyObject * obj0 = 0 ;
38478 char *kwnames[] = {
38479 (char *) "self", NULL
38480 };
38481
38482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38484 if (SWIG_arg_fail(1)) SWIG_fail;
38485 {
38486 PyThreadState* __tstate = wxPyBeginAllowThreads();
38487 result = (arg1)->GetRect();
38488
38489 wxPyEndAllowThreads(__tstate);
38490 if (PyErr_Occurred()) SWIG_fail;
38491 }
38492 {
38493 wxRect * resultptr;
38494 resultptr = new wxRect((wxRect &)(result));
38495 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38496 }
38497 return resultobj;
38498 fail:
38499 return NULL;
38500 }
38501
38502
38503 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38504 PyObject *resultobj;
38505 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38506 bool result;
38507 PyObject * obj0 = 0 ;
38508 char *kwnames[] = {
38509 (char *) "self", NULL
38510 };
38511
38512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38514 if (SWIG_arg_fail(1)) SWIG_fail;
38515 {
38516 PyThreadState* __tstate = wxPyBeginAllowThreads();
38517 result = (bool)(arg1)->IsWindow();
38518
38519 wxPyEndAllowThreads(__tstate);
38520 if (PyErr_Occurred()) SWIG_fail;
38521 }
38522 {
38523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38524 }
38525 return resultobj;
38526 fail:
38527 return NULL;
38528 }
38529
38530
38531 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38532 PyObject *resultobj;
38533 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38534 bool result;
38535 PyObject * obj0 = 0 ;
38536 char *kwnames[] = {
38537 (char *) "self", NULL
38538 };
38539
38540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38542 if (SWIG_arg_fail(1)) SWIG_fail;
38543 {
38544 PyThreadState* __tstate = wxPyBeginAllowThreads();
38545 result = (bool)(arg1)->IsSizer();
38546
38547 wxPyEndAllowThreads(__tstate);
38548 if (PyErr_Occurred()) SWIG_fail;
38549 }
38550 {
38551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38552 }
38553 return resultobj;
38554 fail:
38555 return NULL;
38556 }
38557
38558
38559 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38560 PyObject *resultobj;
38561 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38562 bool result;
38563 PyObject * obj0 = 0 ;
38564 char *kwnames[] = {
38565 (char *) "self", NULL
38566 };
38567
38568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38570 if (SWIG_arg_fail(1)) SWIG_fail;
38571 {
38572 PyThreadState* __tstate = wxPyBeginAllowThreads();
38573 result = (bool)(arg1)->IsSpacer();
38574
38575 wxPyEndAllowThreads(__tstate);
38576 if (PyErr_Occurred()) SWIG_fail;
38577 }
38578 {
38579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38580 }
38581 return resultobj;
38582 fail:
38583 return NULL;
38584 }
38585
38586
38587 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38588 PyObject *resultobj;
38589 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38590 int arg2 ;
38591 PyObject * obj0 = 0 ;
38592 PyObject * obj1 = 0 ;
38593 char *kwnames[] = {
38594 (char *) "self",(char *) "proportion", NULL
38595 };
38596
38597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38599 if (SWIG_arg_fail(1)) SWIG_fail;
38600 {
38601 arg2 = (int)(SWIG_As_int(obj1));
38602 if (SWIG_arg_fail(2)) SWIG_fail;
38603 }
38604 {
38605 PyThreadState* __tstate = wxPyBeginAllowThreads();
38606 (arg1)->SetProportion(arg2);
38607
38608 wxPyEndAllowThreads(__tstate);
38609 if (PyErr_Occurred()) SWIG_fail;
38610 }
38611 Py_INCREF(Py_None); resultobj = Py_None;
38612 return resultobj;
38613 fail:
38614 return NULL;
38615 }
38616
38617
38618 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38619 PyObject *resultobj;
38620 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38621 int result;
38622 PyObject * obj0 = 0 ;
38623 char *kwnames[] = {
38624 (char *) "self", NULL
38625 };
38626
38627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38629 if (SWIG_arg_fail(1)) SWIG_fail;
38630 {
38631 PyThreadState* __tstate = wxPyBeginAllowThreads();
38632 result = (int)(arg1)->GetProportion();
38633
38634 wxPyEndAllowThreads(__tstate);
38635 if (PyErr_Occurred()) SWIG_fail;
38636 }
38637 {
38638 resultobj = SWIG_From_int((int)(result));
38639 }
38640 return resultobj;
38641 fail:
38642 return NULL;
38643 }
38644
38645
38646 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38647 PyObject *resultobj;
38648 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38649 int arg2 ;
38650 PyObject * obj0 = 0 ;
38651 PyObject * obj1 = 0 ;
38652 char *kwnames[] = {
38653 (char *) "self",(char *) "flag", NULL
38654 };
38655
38656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38658 if (SWIG_arg_fail(1)) SWIG_fail;
38659 {
38660 arg2 = (int)(SWIG_As_int(obj1));
38661 if (SWIG_arg_fail(2)) SWIG_fail;
38662 }
38663 {
38664 PyThreadState* __tstate = wxPyBeginAllowThreads();
38665 (arg1)->SetFlag(arg2);
38666
38667 wxPyEndAllowThreads(__tstate);
38668 if (PyErr_Occurred()) SWIG_fail;
38669 }
38670 Py_INCREF(Py_None); resultobj = Py_None;
38671 return resultobj;
38672 fail:
38673 return NULL;
38674 }
38675
38676
38677 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38678 PyObject *resultobj;
38679 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38680 int result;
38681 PyObject * obj0 = 0 ;
38682 char *kwnames[] = {
38683 (char *) "self", NULL
38684 };
38685
38686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38688 if (SWIG_arg_fail(1)) SWIG_fail;
38689 {
38690 PyThreadState* __tstate = wxPyBeginAllowThreads();
38691 result = (int)(arg1)->GetFlag();
38692
38693 wxPyEndAllowThreads(__tstate);
38694 if (PyErr_Occurred()) SWIG_fail;
38695 }
38696 {
38697 resultobj = SWIG_From_int((int)(result));
38698 }
38699 return resultobj;
38700 fail:
38701 return NULL;
38702 }
38703
38704
38705 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38706 PyObject *resultobj;
38707 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38708 int arg2 ;
38709 PyObject * obj0 = 0 ;
38710 PyObject * obj1 = 0 ;
38711 char *kwnames[] = {
38712 (char *) "self",(char *) "border", NULL
38713 };
38714
38715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38717 if (SWIG_arg_fail(1)) SWIG_fail;
38718 {
38719 arg2 = (int)(SWIG_As_int(obj1));
38720 if (SWIG_arg_fail(2)) SWIG_fail;
38721 }
38722 {
38723 PyThreadState* __tstate = wxPyBeginAllowThreads();
38724 (arg1)->SetBorder(arg2);
38725
38726 wxPyEndAllowThreads(__tstate);
38727 if (PyErr_Occurred()) SWIG_fail;
38728 }
38729 Py_INCREF(Py_None); resultobj = Py_None;
38730 return resultobj;
38731 fail:
38732 return NULL;
38733 }
38734
38735
38736 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38737 PyObject *resultobj;
38738 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38739 int result;
38740 PyObject * obj0 = 0 ;
38741 char *kwnames[] = {
38742 (char *) "self", NULL
38743 };
38744
38745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38747 if (SWIG_arg_fail(1)) SWIG_fail;
38748 {
38749 PyThreadState* __tstate = wxPyBeginAllowThreads();
38750 result = (int)(arg1)->GetBorder();
38751
38752 wxPyEndAllowThreads(__tstate);
38753 if (PyErr_Occurred()) SWIG_fail;
38754 }
38755 {
38756 resultobj = SWIG_From_int((int)(result));
38757 }
38758 return resultobj;
38759 fail:
38760 return NULL;
38761 }
38762
38763
38764 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38765 PyObject *resultobj;
38766 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38767 wxWindow *result;
38768 PyObject * obj0 = 0 ;
38769 char *kwnames[] = {
38770 (char *) "self", NULL
38771 };
38772
38773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38775 if (SWIG_arg_fail(1)) SWIG_fail;
38776 {
38777 PyThreadState* __tstate = wxPyBeginAllowThreads();
38778 result = (wxWindow *)(arg1)->GetWindow();
38779
38780 wxPyEndAllowThreads(__tstate);
38781 if (PyErr_Occurred()) SWIG_fail;
38782 }
38783 {
38784 resultobj = wxPyMake_wxObject(result, 0);
38785 }
38786 return resultobj;
38787 fail:
38788 return NULL;
38789 }
38790
38791
38792 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38793 PyObject *resultobj;
38794 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38795 wxWindow *arg2 = (wxWindow *) 0 ;
38796 PyObject * obj0 = 0 ;
38797 PyObject * obj1 = 0 ;
38798 char *kwnames[] = {
38799 (char *) "self",(char *) "window", NULL
38800 };
38801
38802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38804 if (SWIG_arg_fail(1)) SWIG_fail;
38805 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38806 if (SWIG_arg_fail(2)) SWIG_fail;
38807 {
38808 PyThreadState* __tstate = wxPyBeginAllowThreads();
38809 (arg1)->SetWindow(arg2);
38810
38811 wxPyEndAllowThreads(__tstate);
38812 if (PyErr_Occurred()) SWIG_fail;
38813 }
38814 Py_INCREF(Py_None); resultobj = Py_None;
38815 return resultobj;
38816 fail:
38817 return NULL;
38818 }
38819
38820
38821 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38822 PyObject *resultobj;
38823 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38824 wxSizer *result;
38825 PyObject * obj0 = 0 ;
38826 char *kwnames[] = {
38827 (char *) "self", NULL
38828 };
38829
38830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38832 if (SWIG_arg_fail(1)) SWIG_fail;
38833 {
38834 PyThreadState* __tstate = wxPyBeginAllowThreads();
38835 result = (wxSizer *)(arg1)->GetSizer();
38836
38837 wxPyEndAllowThreads(__tstate);
38838 if (PyErr_Occurred()) SWIG_fail;
38839 }
38840 {
38841 resultobj = wxPyMake_wxSizer(result, 0);
38842 }
38843 return resultobj;
38844 fail:
38845 return NULL;
38846 }
38847
38848
38849 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38850 PyObject *resultobj;
38851 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38852 wxSizer *arg2 = (wxSizer *) 0 ;
38853 PyObject * obj0 = 0 ;
38854 PyObject * obj1 = 0 ;
38855 char *kwnames[] = {
38856 (char *) "self",(char *) "sizer", NULL
38857 };
38858
38859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38861 if (SWIG_arg_fail(1)) SWIG_fail;
38862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38863 if (SWIG_arg_fail(2)) SWIG_fail;
38864 {
38865 PyThreadState* __tstate = wxPyBeginAllowThreads();
38866 (arg1)->SetSizer(arg2);
38867
38868 wxPyEndAllowThreads(__tstate);
38869 if (PyErr_Occurred()) SWIG_fail;
38870 }
38871 Py_INCREF(Py_None); resultobj = Py_None;
38872 return resultobj;
38873 fail:
38874 return NULL;
38875 }
38876
38877
38878 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38879 PyObject *resultobj;
38880 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38881 wxSize *result;
38882 PyObject * obj0 = 0 ;
38883 char *kwnames[] = {
38884 (char *) "self", NULL
38885 };
38886
38887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38889 if (SWIG_arg_fail(1)) SWIG_fail;
38890 {
38891 PyThreadState* __tstate = wxPyBeginAllowThreads();
38892 {
38893 wxSize const &_result_ref = (arg1)->GetSpacer();
38894 result = (wxSize *) &_result_ref;
38895 }
38896
38897 wxPyEndAllowThreads(__tstate);
38898 if (PyErr_Occurred()) SWIG_fail;
38899 }
38900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38901 return resultobj;
38902 fail:
38903 return NULL;
38904 }
38905
38906
38907 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38908 PyObject *resultobj;
38909 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38910 wxSize *arg2 = 0 ;
38911 wxSize temp2 ;
38912 PyObject * obj0 = 0 ;
38913 PyObject * obj1 = 0 ;
38914 char *kwnames[] = {
38915 (char *) "self",(char *) "size", NULL
38916 };
38917
38918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38920 if (SWIG_arg_fail(1)) SWIG_fail;
38921 {
38922 arg2 = &temp2;
38923 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38924 }
38925 {
38926 PyThreadState* __tstate = wxPyBeginAllowThreads();
38927 (arg1)->SetSpacer((wxSize const &)*arg2);
38928
38929 wxPyEndAllowThreads(__tstate);
38930 if (PyErr_Occurred()) SWIG_fail;
38931 }
38932 Py_INCREF(Py_None); resultobj = Py_None;
38933 return resultobj;
38934 fail:
38935 return NULL;
38936 }
38937
38938
38939 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38940 PyObject *resultobj;
38941 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38942 bool arg2 ;
38943 PyObject * obj0 = 0 ;
38944 PyObject * obj1 = 0 ;
38945 char *kwnames[] = {
38946 (char *) "self",(char *) "show", NULL
38947 };
38948
38949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38951 if (SWIG_arg_fail(1)) SWIG_fail;
38952 {
38953 arg2 = (bool)(SWIG_As_bool(obj1));
38954 if (SWIG_arg_fail(2)) SWIG_fail;
38955 }
38956 {
38957 PyThreadState* __tstate = wxPyBeginAllowThreads();
38958 (arg1)->Show(arg2);
38959
38960 wxPyEndAllowThreads(__tstate);
38961 if (PyErr_Occurred()) SWIG_fail;
38962 }
38963 Py_INCREF(Py_None); resultobj = Py_None;
38964 return resultobj;
38965 fail:
38966 return NULL;
38967 }
38968
38969
38970 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38971 PyObject *resultobj;
38972 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38973 bool result;
38974 PyObject * obj0 = 0 ;
38975 char *kwnames[] = {
38976 (char *) "self", NULL
38977 };
38978
38979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38981 if (SWIG_arg_fail(1)) SWIG_fail;
38982 {
38983 PyThreadState* __tstate = wxPyBeginAllowThreads();
38984 result = (bool)(arg1)->IsShown();
38985
38986 wxPyEndAllowThreads(__tstate);
38987 if (PyErr_Occurred()) SWIG_fail;
38988 }
38989 {
38990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38991 }
38992 return resultobj;
38993 fail:
38994 return NULL;
38995 }
38996
38997
38998 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38999 PyObject *resultobj;
39000 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39001 wxPoint result;
39002 PyObject * obj0 = 0 ;
39003 char *kwnames[] = {
39004 (char *) "self", NULL
39005 };
39006
39007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39009 if (SWIG_arg_fail(1)) SWIG_fail;
39010 {
39011 PyThreadState* __tstate = wxPyBeginAllowThreads();
39012 result = (arg1)->GetPosition();
39013
39014 wxPyEndAllowThreads(__tstate);
39015 if (PyErr_Occurred()) SWIG_fail;
39016 }
39017 {
39018 wxPoint * resultptr;
39019 resultptr = new wxPoint((wxPoint &)(result));
39020 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39021 }
39022 return resultobj;
39023 fail:
39024 return NULL;
39025 }
39026
39027
39028 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39029 PyObject *resultobj;
39030 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39031 PyObject *result;
39032 PyObject * obj0 = 0 ;
39033 char *kwnames[] = {
39034 (char *) "self", NULL
39035 };
39036
39037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39039 if (SWIG_arg_fail(1)) SWIG_fail;
39040 {
39041 PyThreadState* __tstate = wxPyBeginAllowThreads();
39042 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39043
39044 wxPyEndAllowThreads(__tstate);
39045 if (PyErr_Occurred()) SWIG_fail;
39046 }
39047 resultobj = result;
39048 return resultobj;
39049 fail:
39050 return NULL;
39051 }
39052
39053
39054 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39055 PyObject *obj;
39056 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39057 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39058 Py_INCREF(obj);
39059 return Py_BuildValue((char *)"");
39060 }
39061 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39062 PyObject *resultobj;
39063 wxSizer *arg1 = (wxSizer *) 0 ;
39064 PyObject *arg2 = (PyObject *) 0 ;
39065 PyObject * obj0 = 0 ;
39066 PyObject * obj1 = 0 ;
39067 char *kwnames[] = {
39068 (char *) "self",(char *) "_self", NULL
39069 };
39070
39071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39073 if (SWIG_arg_fail(1)) SWIG_fail;
39074 arg2 = obj1;
39075 {
39076 PyThreadState* __tstate = wxPyBeginAllowThreads();
39077 wxSizer__setOORInfo(arg1,arg2);
39078
39079 wxPyEndAllowThreads(__tstate);
39080 if (PyErr_Occurred()) SWIG_fail;
39081 }
39082 Py_INCREF(Py_None); resultobj = Py_None;
39083 return resultobj;
39084 fail:
39085 return NULL;
39086 }
39087
39088
39089 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39090 PyObject *resultobj;
39091 wxSizer *arg1 = (wxSizer *) 0 ;
39092 PyObject *arg2 = (PyObject *) 0 ;
39093 int arg3 = (int) 0 ;
39094 int arg4 = (int) 0 ;
39095 int arg5 = (int) 0 ;
39096 PyObject *arg6 = (PyObject *) NULL ;
39097 wxSizerItem *result;
39098 PyObject * obj0 = 0 ;
39099 PyObject * obj1 = 0 ;
39100 PyObject * obj2 = 0 ;
39101 PyObject * obj3 = 0 ;
39102 PyObject * obj4 = 0 ;
39103 PyObject * obj5 = 0 ;
39104 char *kwnames[] = {
39105 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39106 };
39107
39108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39110 if (SWIG_arg_fail(1)) SWIG_fail;
39111 arg2 = obj1;
39112 if (obj2) {
39113 {
39114 arg3 = (int)(SWIG_As_int(obj2));
39115 if (SWIG_arg_fail(3)) SWIG_fail;
39116 }
39117 }
39118 if (obj3) {
39119 {
39120 arg4 = (int)(SWIG_As_int(obj3));
39121 if (SWIG_arg_fail(4)) SWIG_fail;
39122 }
39123 }
39124 if (obj4) {
39125 {
39126 arg5 = (int)(SWIG_As_int(obj4));
39127 if (SWIG_arg_fail(5)) SWIG_fail;
39128 }
39129 }
39130 if (obj5) {
39131 arg6 = obj5;
39132 }
39133 {
39134 PyThreadState* __tstate = wxPyBeginAllowThreads();
39135 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39136
39137 wxPyEndAllowThreads(__tstate);
39138 if (PyErr_Occurred()) SWIG_fail;
39139 }
39140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39141 return resultobj;
39142 fail:
39143 return NULL;
39144 }
39145
39146
39147 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39148 PyObject *resultobj;
39149 wxSizer *arg1 = (wxSizer *) 0 ;
39150 int arg2 ;
39151 PyObject *arg3 = (PyObject *) 0 ;
39152 int arg4 = (int) 0 ;
39153 int arg5 = (int) 0 ;
39154 int arg6 = (int) 0 ;
39155 PyObject *arg7 = (PyObject *) NULL ;
39156 wxSizerItem *result;
39157 PyObject * obj0 = 0 ;
39158 PyObject * obj1 = 0 ;
39159 PyObject * obj2 = 0 ;
39160 PyObject * obj3 = 0 ;
39161 PyObject * obj4 = 0 ;
39162 PyObject * obj5 = 0 ;
39163 PyObject * obj6 = 0 ;
39164 char *kwnames[] = {
39165 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39166 };
39167
39168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39170 if (SWIG_arg_fail(1)) SWIG_fail;
39171 {
39172 arg2 = (int)(SWIG_As_int(obj1));
39173 if (SWIG_arg_fail(2)) SWIG_fail;
39174 }
39175 arg3 = obj2;
39176 if (obj3) {
39177 {
39178 arg4 = (int)(SWIG_As_int(obj3));
39179 if (SWIG_arg_fail(4)) SWIG_fail;
39180 }
39181 }
39182 if (obj4) {
39183 {
39184 arg5 = (int)(SWIG_As_int(obj4));
39185 if (SWIG_arg_fail(5)) SWIG_fail;
39186 }
39187 }
39188 if (obj5) {
39189 {
39190 arg6 = (int)(SWIG_As_int(obj5));
39191 if (SWIG_arg_fail(6)) SWIG_fail;
39192 }
39193 }
39194 if (obj6) {
39195 arg7 = obj6;
39196 }
39197 {
39198 PyThreadState* __tstate = wxPyBeginAllowThreads();
39199 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39200
39201 wxPyEndAllowThreads(__tstate);
39202 if (PyErr_Occurred()) SWIG_fail;
39203 }
39204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39205 return resultobj;
39206 fail:
39207 return NULL;
39208 }
39209
39210
39211 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39212 PyObject *resultobj;
39213 wxSizer *arg1 = (wxSizer *) 0 ;
39214 PyObject *arg2 = (PyObject *) 0 ;
39215 int arg3 = (int) 0 ;
39216 int arg4 = (int) 0 ;
39217 int arg5 = (int) 0 ;
39218 PyObject *arg6 = (PyObject *) NULL ;
39219 wxSizerItem *result;
39220 PyObject * obj0 = 0 ;
39221 PyObject * obj1 = 0 ;
39222 PyObject * obj2 = 0 ;
39223 PyObject * obj3 = 0 ;
39224 PyObject * obj4 = 0 ;
39225 PyObject * obj5 = 0 ;
39226 char *kwnames[] = {
39227 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39228 };
39229
39230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39232 if (SWIG_arg_fail(1)) SWIG_fail;
39233 arg2 = obj1;
39234 if (obj2) {
39235 {
39236 arg3 = (int)(SWIG_As_int(obj2));
39237 if (SWIG_arg_fail(3)) SWIG_fail;
39238 }
39239 }
39240 if (obj3) {
39241 {
39242 arg4 = (int)(SWIG_As_int(obj3));
39243 if (SWIG_arg_fail(4)) SWIG_fail;
39244 }
39245 }
39246 if (obj4) {
39247 {
39248 arg5 = (int)(SWIG_As_int(obj4));
39249 if (SWIG_arg_fail(5)) SWIG_fail;
39250 }
39251 }
39252 if (obj5) {
39253 arg6 = obj5;
39254 }
39255 {
39256 PyThreadState* __tstate = wxPyBeginAllowThreads();
39257 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39258
39259 wxPyEndAllowThreads(__tstate);
39260 if (PyErr_Occurred()) SWIG_fail;
39261 }
39262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39263 return resultobj;
39264 fail:
39265 return NULL;
39266 }
39267
39268
39269 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39270 PyObject *resultobj;
39271 wxSizer *arg1 = (wxSizer *) 0 ;
39272 PyObject *arg2 = (PyObject *) 0 ;
39273 bool result;
39274 PyObject * obj0 = 0 ;
39275 PyObject * obj1 = 0 ;
39276 char *kwnames[] = {
39277 (char *) "self",(char *) "item", NULL
39278 };
39279
39280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39282 if (SWIG_arg_fail(1)) SWIG_fail;
39283 arg2 = obj1;
39284 {
39285 PyThreadState* __tstate = wxPyBeginAllowThreads();
39286 result = (bool)wxSizer_Remove(arg1,arg2);
39287
39288 wxPyEndAllowThreads(__tstate);
39289 if (PyErr_Occurred()) SWIG_fail;
39290 }
39291 {
39292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39293 }
39294 return resultobj;
39295 fail:
39296 return NULL;
39297 }
39298
39299
39300 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39301 PyObject *resultobj;
39302 wxSizer *arg1 = (wxSizer *) 0 ;
39303 PyObject *arg2 = (PyObject *) 0 ;
39304 bool result;
39305 PyObject * obj0 = 0 ;
39306 PyObject * obj1 = 0 ;
39307 char *kwnames[] = {
39308 (char *) "self",(char *) "item", NULL
39309 };
39310
39311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39313 if (SWIG_arg_fail(1)) SWIG_fail;
39314 arg2 = obj1;
39315 {
39316 PyThreadState* __tstate = wxPyBeginAllowThreads();
39317 result = (bool)wxSizer_Detach(arg1,arg2);
39318
39319 wxPyEndAllowThreads(__tstate);
39320 if (PyErr_Occurred()) SWIG_fail;
39321 }
39322 {
39323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39324 }
39325 return resultobj;
39326 fail:
39327 return NULL;
39328 }
39329
39330
39331 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39332 PyObject *resultobj;
39333 wxSizer *arg1 = (wxSizer *) 0 ;
39334 PyObject *arg2 = (PyObject *) 0 ;
39335 wxSizerItem *result;
39336 PyObject * obj0 = 0 ;
39337 PyObject * obj1 = 0 ;
39338 char *kwnames[] = {
39339 (char *) "self",(char *) "item", NULL
39340 };
39341
39342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39344 if (SWIG_arg_fail(1)) SWIG_fail;
39345 arg2 = obj1;
39346 {
39347 PyThreadState* __tstate = wxPyBeginAllowThreads();
39348 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39349
39350 wxPyEndAllowThreads(__tstate);
39351 if (PyErr_Occurred()) SWIG_fail;
39352 }
39353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39354 return resultobj;
39355 fail:
39356 return NULL;
39357 }
39358
39359
39360 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39361 PyObject *resultobj;
39362 wxSizer *arg1 = (wxSizer *) 0 ;
39363 PyObject *arg2 = (PyObject *) 0 ;
39364 wxSize *arg3 = 0 ;
39365 wxSize temp3 ;
39366 PyObject * obj0 = 0 ;
39367 PyObject * obj1 = 0 ;
39368 PyObject * obj2 = 0 ;
39369 char *kwnames[] = {
39370 (char *) "self",(char *) "item",(char *) "size", NULL
39371 };
39372
39373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39375 if (SWIG_arg_fail(1)) SWIG_fail;
39376 arg2 = obj1;
39377 {
39378 arg3 = &temp3;
39379 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39380 }
39381 {
39382 PyThreadState* __tstate = wxPyBeginAllowThreads();
39383 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39384
39385 wxPyEndAllowThreads(__tstate);
39386 if (PyErr_Occurred()) SWIG_fail;
39387 }
39388 Py_INCREF(Py_None); resultobj = Py_None;
39389 return resultobj;
39390 fail:
39391 return NULL;
39392 }
39393
39394
39395 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39396 PyObject *resultobj;
39397 wxSizer *arg1 = (wxSizer *) 0 ;
39398 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39399 wxSizerItem *result;
39400 PyObject * obj0 = 0 ;
39401 PyObject * obj1 = 0 ;
39402 char *kwnames[] = {
39403 (char *) "self",(char *) "item", NULL
39404 };
39405
39406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39408 if (SWIG_arg_fail(1)) SWIG_fail;
39409 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39410 if (SWIG_arg_fail(2)) SWIG_fail;
39411 {
39412 PyThreadState* __tstate = wxPyBeginAllowThreads();
39413 result = (wxSizerItem *)(arg1)->Add(arg2);
39414
39415 wxPyEndAllowThreads(__tstate);
39416 if (PyErr_Occurred()) SWIG_fail;
39417 }
39418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39419 return resultobj;
39420 fail:
39421 return NULL;
39422 }
39423
39424
39425 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39426 PyObject *resultobj;
39427 wxSizer *arg1 = (wxSizer *) 0 ;
39428 size_t arg2 ;
39429 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39430 wxSizerItem *result;
39431 PyObject * obj0 = 0 ;
39432 PyObject * obj1 = 0 ;
39433 PyObject * obj2 = 0 ;
39434 char *kwnames[] = {
39435 (char *) "self",(char *) "index",(char *) "item", NULL
39436 };
39437
39438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39440 if (SWIG_arg_fail(1)) SWIG_fail;
39441 {
39442 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39443 if (SWIG_arg_fail(2)) SWIG_fail;
39444 }
39445 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39446 if (SWIG_arg_fail(3)) SWIG_fail;
39447 {
39448 PyThreadState* __tstate = wxPyBeginAllowThreads();
39449 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39450
39451 wxPyEndAllowThreads(__tstate);
39452 if (PyErr_Occurred()) SWIG_fail;
39453 }
39454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39455 return resultobj;
39456 fail:
39457 return NULL;
39458 }
39459
39460
39461 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39462 PyObject *resultobj;
39463 wxSizer *arg1 = (wxSizer *) 0 ;
39464 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39465 wxSizerItem *result;
39466 PyObject * obj0 = 0 ;
39467 PyObject * obj1 = 0 ;
39468 char *kwnames[] = {
39469 (char *) "self",(char *) "item", NULL
39470 };
39471
39472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39474 if (SWIG_arg_fail(1)) SWIG_fail;
39475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39476 if (SWIG_arg_fail(2)) SWIG_fail;
39477 {
39478 PyThreadState* __tstate = wxPyBeginAllowThreads();
39479 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39480
39481 wxPyEndAllowThreads(__tstate);
39482 if (PyErr_Occurred()) SWIG_fail;
39483 }
39484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39485 return resultobj;
39486 fail:
39487 return NULL;
39488 }
39489
39490
39491 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39492 PyObject *resultobj;
39493 wxSizer *arg1 = (wxSizer *) 0 ;
39494 int arg2 ;
39495 int arg3 ;
39496 int arg4 ;
39497 int arg5 ;
39498 PyObject * obj0 = 0 ;
39499 PyObject * obj1 = 0 ;
39500 PyObject * obj2 = 0 ;
39501 PyObject * obj3 = 0 ;
39502 PyObject * obj4 = 0 ;
39503 char *kwnames[] = {
39504 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39505 };
39506
39507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39509 if (SWIG_arg_fail(1)) SWIG_fail;
39510 {
39511 arg2 = (int)(SWIG_As_int(obj1));
39512 if (SWIG_arg_fail(2)) SWIG_fail;
39513 }
39514 {
39515 arg3 = (int)(SWIG_As_int(obj2));
39516 if (SWIG_arg_fail(3)) SWIG_fail;
39517 }
39518 {
39519 arg4 = (int)(SWIG_As_int(obj3));
39520 if (SWIG_arg_fail(4)) SWIG_fail;
39521 }
39522 {
39523 arg5 = (int)(SWIG_As_int(obj4));
39524 if (SWIG_arg_fail(5)) SWIG_fail;
39525 }
39526 {
39527 PyThreadState* __tstate = wxPyBeginAllowThreads();
39528 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39529
39530 wxPyEndAllowThreads(__tstate);
39531 if (PyErr_Occurred()) SWIG_fail;
39532 }
39533 Py_INCREF(Py_None); resultobj = Py_None;
39534 return resultobj;
39535 fail:
39536 return NULL;
39537 }
39538
39539
39540 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39541 PyObject *resultobj;
39542 wxSizer *arg1 = (wxSizer *) 0 ;
39543 wxSize *arg2 = 0 ;
39544 wxSize temp2 ;
39545 PyObject * obj0 = 0 ;
39546 PyObject * obj1 = 0 ;
39547 char *kwnames[] = {
39548 (char *) "self",(char *) "size", NULL
39549 };
39550
39551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39553 if (SWIG_arg_fail(1)) SWIG_fail;
39554 {
39555 arg2 = &temp2;
39556 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39557 }
39558 {
39559 PyThreadState* __tstate = wxPyBeginAllowThreads();
39560 (arg1)->SetMinSize((wxSize const &)*arg2);
39561
39562 wxPyEndAllowThreads(__tstate);
39563 if (PyErr_Occurred()) SWIG_fail;
39564 }
39565 Py_INCREF(Py_None); resultobj = Py_None;
39566 return resultobj;
39567 fail:
39568 return NULL;
39569 }
39570
39571
39572 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39573 PyObject *resultobj;
39574 wxSizer *arg1 = (wxSizer *) 0 ;
39575 wxSize result;
39576 PyObject * obj0 = 0 ;
39577 char *kwnames[] = {
39578 (char *) "self", NULL
39579 };
39580
39581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39583 if (SWIG_arg_fail(1)) SWIG_fail;
39584 {
39585 PyThreadState* __tstate = wxPyBeginAllowThreads();
39586 result = (arg1)->GetSize();
39587
39588 wxPyEndAllowThreads(__tstate);
39589 if (PyErr_Occurred()) SWIG_fail;
39590 }
39591 {
39592 wxSize * resultptr;
39593 resultptr = new wxSize((wxSize &)(result));
39594 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39595 }
39596 return resultobj;
39597 fail:
39598 return NULL;
39599 }
39600
39601
39602 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39603 PyObject *resultobj;
39604 wxSizer *arg1 = (wxSizer *) 0 ;
39605 wxPoint result;
39606 PyObject * obj0 = 0 ;
39607 char *kwnames[] = {
39608 (char *) "self", NULL
39609 };
39610
39611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39613 if (SWIG_arg_fail(1)) SWIG_fail;
39614 {
39615 PyThreadState* __tstate = wxPyBeginAllowThreads();
39616 result = (arg1)->GetPosition();
39617
39618 wxPyEndAllowThreads(__tstate);
39619 if (PyErr_Occurred()) SWIG_fail;
39620 }
39621 {
39622 wxPoint * resultptr;
39623 resultptr = new wxPoint((wxPoint &)(result));
39624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39625 }
39626 return resultobj;
39627 fail:
39628 return NULL;
39629 }
39630
39631
39632 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39633 PyObject *resultobj;
39634 wxSizer *arg1 = (wxSizer *) 0 ;
39635 wxSize result;
39636 PyObject * obj0 = 0 ;
39637 char *kwnames[] = {
39638 (char *) "self", NULL
39639 };
39640
39641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39643 if (SWIG_arg_fail(1)) SWIG_fail;
39644 {
39645 PyThreadState* __tstate = wxPyBeginAllowThreads();
39646 result = (arg1)->GetMinSize();
39647
39648 wxPyEndAllowThreads(__tstate);
39649 if (PyErr_Occurred()) SWIG_fail;
39650 }
39651 {
39652 wxSize * resultptr;
39653 resultptr = new wxSize((wxSize &)(result));
39654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39655 }
39656 return resultobj;
39657 fail:
39658 return NULL;
39659 }
39660
39661
39662 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39663 PyObject *resultobj;
39664 wxSizer *arg1 = (wxSizer *) 0 ;
39665 PyObject * obj0 = 0 ;
39666 char *kwnames[] = {
39667 (char *) "self", NULL
39668 };
39669
39670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39672 if (SWIG_arg_fail(1)) SWIG_fail;
39673 {
39674 PyThreadState* __tstate = wxPyBeginAllowThreads();
39675 (arg1)->RecalcSizes();
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 *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39688 PyObject *resultobj;
39689 wxSizer *arg1 = (wxSizer *) 0 ;
39690 wxSize result;
39691 PyObject * obj0 = 0 ;
39692 char *kwnames[] = {
39693 (char *) "self", NULL
39694 };
39695
39696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39698 if (SWIG_arg_fail(1)) SWIG_fail;
39699 {
39700 PyThreadState* __tstate = wxPyBeginAllowThreads();
39701 result = (arg1)->CalcMin();
39702
39703 wxPyEndAllowThreads(__tstate);
39704 if (PyErr_Occurred()) SWIG_fail;
39705 }
39706 {
39707 wxSize * resultptr;
39708 resultptr = new wxSize((wxSize &)(result));
39709 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39710 }
39711 return resultobj;
39712 fail:
39713 return NULL;
39714 }
39715
39716
39717 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39718 PyObject *resultobj;
39719 wxSizer *arg1 = (wxSizer *) 0 ;
39720 PyObject * obj0 = 0 ;
39721 char *kwnames[] = {
39722 (char *) "self", NULL
39723 };
39724
39725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39727 if (SWIG_arg_fail(1)) SWIG_fail;
39728 {
39729 PyThreadState* __tstate = wxPyBeginAllowThreads();
39730 (arg1)->Layout();
39731
39732 wxPyEndAllowThreads(__tstate);
39733 if (PyErr_Occurred()) SWIG_fail;
39734 }
39735 Py_INCREF(Py_None); resultobj = Py_None;
39736 return resultobj;
39737 fail:
39738 return NULL;
39739 }
39740
39741
39742 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39743 PyObject *resultobj;
39744 wxSizer *arg1 = (wxSizer *) 0 ;
39745 wxWindow *arg2 = (wxWindow *) 0 ;
39746 wxSize result;
39747 PyObject * obj0 = 0 ;
39748 PyObject * obj1 = 0 ;
39749 char *kwnames[] = {
39750 (char *) "self",(char *) "window", NULL
39751 };
39752
39753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39755 if (SWIG_arg_fail(1)) SWIG_fail;
39756 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39757 if (SWIG_arg_fail(2)) SWIG_fail;
39758 {
39759 PyThreadState* __tstate = wxPyBeginAllowThreads();
39760 result = (arg1)->Fit(arg2);
39761
39762 wxPyEndAllowThreads(__tstate);
39763 if (PyErr_Occurred()) SWIG_fail;
39764 }
39765 {
39766 wxSize * resultptr;
39767 resultptr = new wxSize((wxSize &)(result));
39768 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39769 }
39770 return resultobj;
39771 fail:
39772 return NULL;
39773 }
39774
39775
39776 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39777 PyObject *resultobj;
39778 wxSizer *arg1 = (wxSizer *) 0 ;
39779 wxWindow *arg2 = (wxWindow *) 0 ;
39780 PyObject * obj0 = 0 ;
39781 PyObject * obj1 = 0 ;
39782 char *kwnames[] = {
39783 (char *) "self",(char *) "window", NULL
39784 };
39785
39786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39788 if (SWIG_arg_fail(1)) SWIG_fail;
39789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39790 if (SWIG_arg_fail(2)) SWIG_fail;
39791 {
39792 PyThreadState* __tstate = wxPyBeginAllowThreads();
39793 (arg1)->FitInside(arg2);
39794
39795 wxPyEndAllowThreads(__tstate);
39796 if (PyErr_Occurred()) SWIG_fail;
39797 }
39798 Py_INCREF(Py_None); resultobj = Py_None;
39799 return resultobj;
39800 fail:
39801 return NULL;
39802 }
39803
39804
39805 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39806 PyObject *resultobj;
39807 wxSizer *arg1 = (wxSizer *) 0 ;
39808 wxWindow *arg2 = (wxWindow *) 0 ;
39809 PyObject * obj0 = 0 ;
39810 PyObject * obj1 = 0 ;
39811 char *kwnames[] = {
39812 (char *) "self",(char *) "window", NULL
39813 };
39814
39815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39817 if (SWIG_arg_fail(1)) SWIG_fail;
39818 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39819 if (SWIG_arg_fail(2)) SWIG_fail;
39820 {
39821 PyThreadState* __tstate = wxPyBeginAllowThreads();
39822 (arg1)->SetSizeHints(arg2);
39823
39824 wxPyEndAllowThreads(__tstate);
39825 if (PyErr_Occurred()) SWIG_fail;
39826 }
39827 Py_INCREF(Py_None); resultobj = Py_None;
39828 return resultobj;
39829 fail:
39830 return NULL;
39831 }
39832
39833
39834 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39835 PyObject *resultobj;
39836 wxSizer *arg1 = (wxSizer *) 0 ;
39837 wxWindow *arg2 = (wxWindow *) 0 ;
39838 PyObject * obj0 = 0 ;
39839 PyObject * obj1 = 0 ;
39840 char *kwnames[] = {
39841 (char *) "self",(char *) "window", NULL
39842 };
39843
39844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39846 if (SWIG_arg_fail(1)) SWIG_fail;
39847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39848 if (SWIG_arg_fail(2)) SWIG_fail;
39849 {
39850 PyThreadState* __tstate = wxPyBeginAllowThreads();
39851 (arg1)->SetVirtualSizeHints(arg2);
39852
39853 wxPyEndAllowThreads(__tstate);
39854 if (PyErr_Occurred()) SWIG_fail;
39855 }
39856 Py_INCREF(Py_None); resultobj = Py_None;
39857 return resultobj;
39858 fail:
39859 return NULL;
39860 }
39861
39862
39863 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39864 PyObject *resultobj;
39865 wxSizer *arg1 = (wxSizer *) 0 ;
39866 bool arg2 = (bool) false ;
39867 PyObject * obj0 = 0 ;
39868 PyObject * obj1 = 0 ;
39869 char *kwnames[] = {
39870 (char *) "self",(char *) "deleteWindows", NULL
39871 };
39872
39873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39875 if (SWIG_arg_fail(1)) SWIG_fail;
39876 if (obj1) {
39877 {
39878 arg2 = (bool)(SWIG_As_bool(obj1));
39879 if (SWIG_arg_fail(2)) SWIG_fail;
39880 }
39881 }
39882 {
39883 PyThreadState* __tstate = wxPyBeginAllowThreads();
39884 (arg1)->Clear(arg2);
39885
39886 wxPyEndAllowThreads(__tstate);
39887 if (PyErr_Occurred()) SWIG_fail;
39888 }
39889 Py_INCREF(Py_None); resultobj = Py_None;
39890 return resultobj;
39891 fail:
39892 return NULL;
39893 }
39894
39895
39896 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39897 PyObject *resultobj;
39898 wxSizer *arg1 = (wxSizer *) 0 ;
39899 PyObject * obj0 = 0 ;
39900 char *kwnames[] = {
39901 (char *) "self", NULL
39902 };
39903
39904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39906 if (SWIG_arg_fail(1)) SWIG_fail;
39907 {
39908 PyThreadState* __tstate = wxPyBeginAllowThreads();
39909 (arg1)->DeleteWindows();
39910
39911 wxPyEndAllowThreads(__tstate);
39912 if (PyErr_Occurred()) SWIG_fail;
39913 }
39914 Py_INCREF(Py_None); resultobj = Py_None;
39915 return resultobj;
39916 fail:
39917 return NULL;
39918 }
39919
39920
39921 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39922 PyObject *resultobj;
39923 wxSizer *arg1 = (wxSizer *) 0 ;
39924 PyObject *result;
39925 PyObject * obj0 = 0 ;
39926 char *kwnames[] = {
39927 (char *) "self", NULL
39928 };
39929
39930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39932 if (SWIG_arg_fail(1)) SWIG_fail;
39933 {
39934 PyThreadState* __tstate = wxPyBeginAllowThreads();
39935 result = (PyObject *)wxSizer_GetChildren(arg1);
39936
39937 wxPyEndAllowThreads(__tstate);
39938 if (PyErr_Occurred()) SWIG_fail;
39939 }
39940 resultobj = result;
39941 return resultobj;
39942 fail:
39943 return NULL;
39944 }
39945
39946
39947 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39948 PyObject *resultobj;
39949 wxSizer *arg1 = (wxSizer *) 0 ;
39950 PyObject *arg2 = (PyObject *) 0 ;
39951 bool arg3 = (bool) true ;
39952 bool arg4 = (bool) false ;
39953 bool result;
39954 PyObject * obj0 = 0 ;
39955 PyObject * obj1 = 0 ;
39956 PyObject * obj2 = 0 ;
39957 PyObject * obj3 = 0 ;
39958 char *kwnames[] = {
39959 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39960 };
39961
39962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39964 if (SWIG_arg_fail(1)) SWIG_fail;
39965 arg2 = obj1;
39966 if (obj2) {
39967 {
39968 arg3 = (bool)(SWIG_As_bool(obj2));
39969 if (SWIG_arg_fail(3)) SWIG_fail;
39970 }
39971 }
39972 if (obj3) {
39973 {
39974 arg4 = (bool)(SWIG_As_bool(obj3));
39975 if (SWIG_arg_fail(4)) SWIG_fail;
39976 }
39977 }
39978 {
39979 PyThreadState* __tstate = wxPyBeginAllowThreads();
39980 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39981
39982 wxPyEndAllowThreads(__tstate);
39983 if (PyErr_Occurred()) SWIG_fail;
39984 }
39985 {
39986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39987 }
39988 return resultobj;
39989 fail:
39990 return NULL;
39991 }
39992
39993
39994 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39995 PyObject *resultobj;
39996 wxSizer *arg1 = (wxSizer *) 0 ;
39997 PyObject *arg2 = (PyObject *) 0 ;
39998 bool result;
39999 PyObject * obj0 = 0 ;
40000 PyObject * obj1 = 0 ;
40001 char *kwnames[] = {
40002 (char *) "self",(char *) "item", NULL
40003 };
40004
40005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40007 if (SWIG_arg_fail(1)) SWIG_fail;
40008 arg2 = obj1;
40009 {
40010 PyThreadState* __tstate = wxPyBeginAllowThreads();
40011 result = (bool)wxSizer_IsShown(arg1,arg2);
40012
40013 wxPyEndAllowThreads(__tstate);
40014 if (PyErr_Occurred()) SWIG_fail;
40015 }
40016 {
40017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40018 }
40019 return resultobj;
40020 fail:
40021 return NULL;
40022 }
40023
40024
40025 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40026 PyObject *resultobj;
40027 wxSizer *arg1 = (wxSizer *) 0 ;
40028 bool arg2 ;
40029 PyObject * obj0 = 0 ;
40030 PyObject * obj1 = 0 ;
40031 char *kwnames[] = {
40032 (char *) "self",(char *) "show", NULL
40033 };
40034
40035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40037 if (SWIG_arg_fail(1)) SWIG_fail;
40038 {
40039 arg2 = (bool)(SWIG_As_bool(obj1));
40040 if (SWIG_arg_fail(2)) SWIG_fail;
40041 }
40042 {
40043 PyThreadState* __tstate = wxPyBeginAllowThreads();
40044 (arg1)->ShowItems(arg2);
40045
40046 wxPyEndAllowThreads(__tstate);
40047 if (PyErr_Occurred()) SWIG_fail;
40048 }
40049 Py_INCREF(Py_None); resultobj = Py_None;
40050 return resultobj;
40051 fail:
40052 return NULL;
40053 }
40054
40055
40056 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40057 PyObject *obj;
40058 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40059 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40060 Py_INCREF(obj);
40061 return Py_BuildValue((char *)"");
40062 }
40063 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40064 PyObject *resultobj;
40065 wxPySizer *result;
40066 char *kwnames[] = {
40067 NULL
40068 };
40069
40070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40071 {
40072 PyThreadState* __tstate = wxPyBeginAllowThreads();
40073 result = (wxPySizer *)new wxPySizer();
40074
40075 wxPyEndAllowThreads(__tstate);
40076 if (PyErr_Occurred()) SWIG_fail;
40077 }
40078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40079 return resultobj;
40080 fail:
40081 return NULL;
40082 }
40083
40084
40085 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40086 PyObject *resultobj;
40087 wxPySizer *arg1 = (wxPySizer *) 0 ;
40088 PyObject *arg2 = (PyObject *) 0 ;
40089 PyObject *arg3 = (PyObject *) 0 ;
40090 PyObject * obj0 = 0 ;
40091 PyObject * obj1 = 0 ;
40092 PyObject * obj2 = 0 ;
40093 char *kwnames[] = {
40094 (char *) "self",(char *) "self",(char *) "_class", NULL
40095 };
40096
40097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40099 if (SWIG_arg_fail(1)) SWIG_fail;
40100 arg2 = obj1;
40101 arg3 = obj2;
40102 {
40103 PyThreadState* __tstate = wxPyBeginAllowThreads();
40104 (arg1)->_setCallbackInfo(arg2,arg3);
40105
40106 wxPyEndAllowThreads(__tstate);
40107 if (PyErr_Occurred()) SWIG_fail;
40108 }
40109 Py_INCREF(Py_None); resultobj = Py_None;
40110 return resultobj;
40111 fail:
40112 return NULL;
40113 }
40114
40115
40116 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40117 PyObject *obj;
40118 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40119 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40120 Py_INCREF(obj);
40121 return Py_BuildValue((char *)"");
40122 }
40123 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40124 PyObject *resultobj;
40125 int arg1 = (int) wxHORIZONTAL ;
40126 wxBoxSizer *result;
40127 PyObject * obj0 = 0 ;
40128 char *kwnames[] = {
40129 (char *) "orient", NULL
40130 };
40131
40132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40133 if (obj0) {
40134 {
40135 arg1 = (int)(SWIG_As_int(obj0));
40136 if (SWIG_arg_fail(1)) SWIG_fail;
40137 }
40138 }
40139 {
40140 PyThreadState* __tstate = wxPyBeginAllowThreads();
40141 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40142
40143 wxPyEndAllowThreads(__tstate);
40144 if (PyErr_Occurred()) SWIG_fail;
40145 }
40146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40147 return resultobj;
40148 fail:
40149 return NULL;
40150 }
40151
40152
40153 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40154 PyObject *resultobj;
40155 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40156 int result;
40157 PyObject * obj0 = 0 ;
40158 char *kwnames[] = {
40159 (char *) "self", NULL
40160 };
40161
40162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40164 if (SWIG_arg_fail(1)) SWIG_fail;
40165 {
40166 PyThreadState* __tstate = wxPyBeginAllowThreads();
40167 result = (int)(arg1)->GetOrientation();
40168
40169 wxPyEndAllowThreads(__tstate);
40170 if (PyErr_Occurred()) SWIG_fail;
40171 }
40172 {
40173 resultobj = SWIG_From_int((int)(result));
40174 }
40175 return resultobj;
40176 fail:
40177 return NULL;
40178 }
40179
40180
40181 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40182 PyObject *resultobj;
40183 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40184 int arg2 ;
40185 PyObject * obj0 = 0 ;
40186 PyObject * obj1 = 0 ;
40187 char *kwnames[] = {
40188 (char *) "self",(char *) "orient", NULL
40189 };
40190
40191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40193 if (SWIG_arg_fail(1)) SWIG_fail;
40194 {
40195 arg2 = (int)(SWIG_As_int(obj1));
40196 if (SWIG_arg_fail(2)) SWIG_fail;
40197 }
40198 {
40199 PyThreadState* __tstate = wxPyBeginAllowThreads();
40200 (arg1)->SetOrientation(arg2);
40201
40202 wxPyEndAllowThreads(__tstate);
40203 if (PyErr_Occurred()) SWIG_fail;
40204 }
40205 Py_INCREF(Py_None); resultobj = Py_None;
40206 return resultobj;
40207 fail:
40208 return NULL;
40209 }
40210
40211
40212 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40213 PyObject *obj;
40214 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40215 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40216 Py_INCREF(obj);
40217 return Py_BuildValue((char *)"");
40218 }
40219 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40220 PyObject *resultobj;
40221 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40222 int arg2 = (int) wxHORIZONTAL ;
40223 wxStaticBoxSizer *result;
40224 PyObject * obj0 = 0 ;
40225 PyObject * obj1 = 0 ;
40226 char *kwnames[] = {
40227 (char *) "box",(char *) "orient", NULL
40228 };
40229
40230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40232 if (SWIG_arg_fail(1)) SWIG_fail;
40233 if (obj1) {
40234 {
40235 arg2 = (int)(SWIG_As_int(obj1));
40236 if (SWIG_arg_fail(2)) SWIG_fail;
40237 }
40238 }
40239 {
40240 PyThreadState* __tstate = wxPyBeginAllowThreads();
40241 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40242
40243 wxPyEndAllowThreads(__tstate);
40244 if (PyErr_Occurred()) SWIG_fail;
40245 }
40246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40247 return resultobj;
40248 fail:
40249 return NULL;
40250 }
40251
40252
40253 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40254 PyObject *resultobj;
40255 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40256 wxStaticBox *result;
40257 PyObject * obj0 = 0 ;
40258 char *kwnames[] = {
40259 (char *) "self", NULL
40260 };
40261
40262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40264 if (SWIG_arg_fail(1)) SWIG_fail;
40265 {
40266 PyThreadState* __tstate = wxPyBeginAllowThreads();
40267 result = (wxStaticBox *)(arg1)->GetStaticBox();
40268
40269 wxPyEndAllowThreads(__tstate);
40270 if (PyErr_Occurred()) SWIG_fail;
40271 }
40272 {
40273 resultobj = wxPyMake_wxObject(result, 0);
40274 }
40275 return resultobj;
40276 fail:
40277 return NULL;
40278 }
40279
40280
40281 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40282 PyObject *obj;
40283 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40284 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40285 Py_INCREF(obj);
40286 return Py_BuildValue((char *)"");
40287 }
40288 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40289 PyObject *resultobj;
40290 int arg1 = (int) 1 ;
40291 int arg2 = (int) 0 ;
40292 int arg3 = (int) 0 ;
40293 int arg4 = (int) 0 ;
40294 wxGridSizer *result;
40295 PyObject * obj0 = 0 ;
40296 PyObject * obj1 = 0 ;
40297 PyObject * obj2 = 0 ;
40298 PyObject * obj3 = 0 ;
40299 char *kwnames[] = {
40300 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40301 };
40302
40303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40304 if (obj0) {
40305 {
40306 arg1 = (int)(SWIG_As_int(obj0));
40307 if (SWIG_arg_fail(1)) SWIG_fail;
40308 }
40309 }
40310 if (obj1) {
40311 {
40312 arg2 = (int)(SWIG_As_int(obj1));
40313 if (SWIG_arg_fail(2)) SWIG_fail;
40314 }
40315 }
40316 if (obj2) {
40317 {
40318 arg3 = (int)(SWIG_As_int(obj2));
40319 if (SWIG_arg_fail(3)) SWIG_fail;
40320 }
40321 }
40322 if (obj3) {
40323 {
40324 arg4 = (int)(SWIG_As_int(obj3));
40325 if (SWIG_arg_fail(4)) SWIG_fail;
40326 }
40327 }
40328 {
40329 PyThreadState* __tstate = wxPyBeginAllowThreads();
40330 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40331
40332 wxPyEndAllowThreads(__tstate);
40333 if (PyErr_Occurred()) SWIG_fail;
40334 }
40335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40336 return resultobj;
40337 fail:
40338 return NULL;
40339 }
40340
40341
40342 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40343 PyObject *resultobj;
40344 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40345 int arg2 ;
40346 PyObject * obj0 = 0 ;
40347 PyObject * obj1 = 0 ;
40348 char *kwnames[] = {
40349 (char *) "self",(char *) "cols", NULL
40350 };
40351
40352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40354 if (SWIG_arg_fail(1)) SWIG_fail;
40355 {
40356 arg2 = (int)(SWIG_As_int(obj1));
40357 if (SWIG_arg_fail(2)) SWIG_fail;
40358 }
40359 {
40360 PyThreadState* __tstate = wxPyBeginAllowThreads();
40361 (arg1)->SetCols(arg2);
40362
40363 wxPyEndAllowThreads(__tstate);
40364 if (PyErr_Occurred()) SWIG_fail;
40365 }
40366 Py_INCREF(Py_None); resultobj = Py_None;
40367 return resultobj;
40368 fail:
40369 return NULL;
40370 }
40371
40372
40373 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40374 PyObject *resultobj;
40375 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40376 int arg2 ;
40377 PyObject * obj0 = 0 ;
40378 PyObject * obj1 = 0 ;
40379 char *kwnames[] = {
40380 (char *) "self",(char *) "rows", NULL
40381 };
40382
40383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40385 if (SWIG_arg_fail(1)) SWIG_fail;
40386 {
40387 arg2 = (int)(SWIG_As_int(obj1));
40388 if (SWIG_arg_fail(2)) SWIG_fail;
40389 }
40390 {
40391 PyThreadState* __tstate = wxPyBeginAllowThreads();
40392 (arg1)->SetRows(arg2);
40393
40394 wxPyEndAllowThreads(__tstate);
40395 if (PyErr_Occurred()) SWIG_fail;
40396 }
40397 Py_INCREF(Py_None); resultobj = Py_None;
40398 return resultobj;
40399 fail:
40400 return NULL;
40401 }
40402
40403
40404 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40405 PyObject *resultobj;
40406 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40407 int arg2 ;
40408 PyObject * obj0 = 0 ;
40409 PyObject * obj1 = 0 ;
40410 char *kwnames[] = {
40411 (char *) "self",(char *) "gap", NULL
40412 };
40413
40414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40416 if (SWIG_arg_fail(1)) SWIG_fail;
40417 {
40418 arg2 = (int)(SWIG_As_int(obj1));
40419 if (SWIG_arg_fail(2)) SWIG_fail;
40420 }
40421 {
40422 PyThreadState* __tstate = wxPyBeginAllowThreads();
40423 (arg1)->SetVGap(arg2);
40424
40425 wxPyEndAllowThreads(__tstate);
40426 if (PyErr_Occurred()) SWIG_fail;
40427 }
40428 Py_INCREF(Py_None); resultobj = Py_None;
40429 return resultobj;
40430 fail:
40431 return NULL;
40432 }
40433
40434
40435 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40436 PyObject *resultobj;
40437 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40438 int arg2 ;
40439 PyObject * obj0 = 0 ;
40440 PyObject * obj1 = 0 ;
40441 char *kwnames[] = {
40442 (char *) "self",(char *) "gap", NULL
40443 };
40444
40445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40447 if (SWIG_arg_fail(1)) SWIG_fail;
40448 {
40449 arg2 = (int)(SWIG_As_int(obj1));
40450 if (SWIG_arg_fail(2)) SWIG_fail;
40451 }
40452 {
40453 PyThreadState* __tstate = wxPyBeginAllowThreads();
40454 (arg1)->SetHGap(arg2);
40455
40456 wxPyEndAllowThreads(__tstate);
40457 if (PyErr_Occurred()) SWIG_fail;
40458 }
40459 Py_INCREF(Py_None); resultobj = Py_None;
40460 return resultobj;
40461 fail:
40462 return NULL;
40463 }
40464
40465
40466 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40467 PyObject *resultobj;
40468 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40469 int result;
40470 PyObject * obj0 = 0 ;
40471 char *kwnames[] = {
40472 (char *) "self", NULL
40473 };
40474
40475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40477 if (SWIG_arg_fail(1)) SWIG_fail;
40478 {
40479 PyThreadState* __tstate = wxPyBeginAllowThreads();
40480 result = (int)(arg1)->GetCols();
40481
40482 wxPyEndAllowThreads(__tstate);
40483 if (PyErr_Occurred()) SWIG_fail;
40484 }
40485 {
40486 resultobj = SWIG_From_int((int)(result));
40487 }
40488 return resultobj;
40489 fail:
40490 return NULL;
40491 }
40492
40493
40494 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40495 PyObject *resultobj;
40496 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40497 int result;
40498 PyObject * obj0 = 0 ;
40499 char *kwnames[] = {
40500 (char *) "self", NULL
40501 };
40502
40503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40505 if (SWIG_arg_fail(1)) SWIG_fail;
40506 {
40507 PyThreadState* __tstate = wxPyBeginAllowThreads();
40508 result = (int)(arg1)->GetRows();
40509
40510 wxPyEndAllowThreads(__tstate);
40511 if (PyErr_Occurred()) SWIG_fail;
40512 }
40513 {
40514 resultobj = SWIG_From_int((int)(result));
40515 }
40516 return resultobj;
40517 fail:
40518 return NULL;
40519 }
40520
40521
40522 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40523 PyObject *resultobj;
40524 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40525 int result;
40526 PyObject * obj0 = 0 ;
40527 char *kwnames[] = {
40528 (char *) "self", NULL
40529 };
40530
40531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40533 if (SWIG_arg_fail(1)) SWIG_fail;
40534 {
40535 PyThreadState* __tstate = wxPyBeginAllowThreads();
40536 result = (int)(arg1)->GetVGap();
40537
40538 wxPyEndAllowThreads(__tstate);
40539 if (PyErr_Occurred()) SWIG_fail;
40540 }
40541 {
40542 resultobj = SWIG_From_int((int)(result));
40543 }
40544 return resultobj;
40545 fail:
40546 return NULL;
40547 }
40548
40549
40550 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40551 PyObject *resultobj;
40552 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40553 int result;
40554 PyObject * obj0 = 0 ;
40555 char *kwnames[] = {
40556 (char *) "self", NULL
40557 };
40558
40559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40561 if (SWIG_arg_fail(1)) SWIG_fail;
40562 {
40563 PyThreadState* __tstate = wxPyBeginAllowThreads();
40564 result = (int)(arg1)->GetHGap();
40565
40566 wxPyEndAllowThreads(__tstate);
40567 if (PyErr_Occurred()) SWIG_fail;
40568 }
40569 {
40570 resultobj = SWIG_From_int((int)(result));
40571 }
40572 return resultobj;
40573 fail:
40574 return NULL;
40575 }
40576
40577
40578 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40579 PyObject *obj;
40580 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40581 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40582 Py_INCREF(obj);
40583 return Py_BuildValue((char *)"");
40584 }
40585 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40586 PyObject *resultobj;
40587 int arg1 = (int) 1 ;
40588 int arg2 = (int) 0 ;
40589 int arg3 = (int) 0 ;
40590 int arg4 = (int) 0 ;
40591 wxFlexGridSizer *result;
40592 PyObject * obj0 = 0 ;
40593 PyObject * obj1 = 0 ;
40594 PyObject * obj2 = 0 ;
40595 PyObject * obj3 = 0 ;
40596 char *kwnames[] = {
40597 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40598 };
40599
40600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40601 if (obj0) {
40602 {
40603 arg1 = (int)(SWIG_As_int(obj0));
40604 if (SWIG_arg_fail(1)) SWIG_fail;
40605 }
40606 }
40607 if (obj1) {
40608 {
40609 arg2 = (int)(SWIG_As_int(obj1));
40610 if (SWIG_arg_fail(2)) SWIG_fail;
40611 }
40612 }
40613 if (obj2) {
40614 {
40615 arg3 = (int)(SWIG_As_int(obj2));
40616 if (SWIG_arg_fail(3)) SWIG_fail;
40617 }
40618 }
40619 if (obj3) {
40620 {
40621 arg4 = (int)(SWIG_As_int(obj3));
40622 if (SWIG_arg_fail(4)) SWIG_fail;
40623 }
40624 }
40625 {
40626 PyThreadState* __tstate = wxPyBeginAllowThreads();
40627 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40628
40629 wxPyEndAllowThreads(__tstate);
40630 if (PyErr_Occurred()) SWIG_fail;
40631 }
40632 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40633 return resultobj;
40634 fail:
40635 return NULL;
40636 }
40637
40638
40639 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40640 PyObject *resultobj;
40641 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40642 size_t arg2 ;
40643 int arg3 = (int) 0 ;
40644 PyObject * obj0 = 0 ;
40645 PyObject * obj1 = 0 ;
40646 PyObject * obj2 = 0 ;
40647 char *kwnames[] = {
40648 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40649 };
40650
40651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40653 if (SWIG_arg_fail(1)) SWIG_fail;
40654 {
40655 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40656 if (SWIG_arg_fail(2)) SWIG_fail;
40657 }
40658 if (obj2) {
40659 {
40660 arg3 = (int)(SWIG_As_int(obj2));
40661 if (SWIG_arg_fail(3)) SWIG_fail;
40662 }
40663 }
40664 {
40665 PyThreadState* __tstate = wxPyBeginAllowThreads();
40666 (arg1)->AddGrowableRow(arg2,arg3);
40667
40668 wxPyEndAllowThreads(__tstate);
40669 if (PyErr_Occurred()) SWIG_fail;
40670 }
40671 Py_INCREF(Py_None); resultobj = Py_None;
40672 return resultobj;
40673 fail:
40674 return NULL;
40675 }
40676
40677
40678 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40679 PyObject *resultobj;
40680 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40681 size_t arg2 ;
40682 PyObject * obj0 = 0 ;
40683 PyObject * obj1 = 0 ;
40684 char *kwnames[] = {
40685 (char *) "self",(char *) "idx", NULL
40686 };
40687
40688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40690 if (SWIG_arg_fail(1)) SWIG_fail;
40691 {
40692 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40693 if (SWIG_arg_fail(2)) SWIG_fail;
40694 }
40695 {
40696 PyThreadState* __tstate = wxPyBeginAllowThreads();
40697 (arg1)->RemoveGrowableRow(arg2);
40698
40699 wxPyEndAllowThreads(__tstate);
40700 if (PyErr_Occurred()) SWIG_fail;
40701 }
40702 Py_INCREF(Py_None); resultobj = Py_None;
40703 return resultobj;
40704 fail:
40705 return NULL;
40706 }
40707
40708
40709 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40710 PyObject *resultobj;
40711 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40712 size_t arg2 ;
40713 int arg3 = (int) 0 ;
40714 PyObject * obj0 = 0 ;
40715 PyObject * obj1 = 0 ;
40716 PyObject * obj2 = 0 ;
40717 char *kwnames[] = {
40718 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40719 };
40720
40721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40723 if (SWIG_arg_fail(1)) SWIG_fail;
40724 {
40725 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40726 if (SWIG_arg_fail(2)) SWIG_fail;
40727 }
40728 if (obj2) {
40729 {
40730 arg3 = (int)(SWIG_As_int(obj2));
40731 if (SWIG_arg_fail(3)) SWIG_fail;
40732 }
40733 }
40734 {
40735 PyThreadState* __tstate = wxPyBeginAllowThreads();
40736 (arg1)->AddGrowableCol(arg2,arg3);
40737
40738 wxPyEndAllowThreads(__tstate);
40739 if (PyErr_Occurred()) SWIG_fail;
40740 }
40741 Py_INCREF(Py_None); resultobj = Py_None;
40742 return resultobj;
40743 fail:
40744 return NULL;
40745 }
40746
40747
40748 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40749 PyObject *resultobj;
40750 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40751 size_t arg2 ;
40752 PyObject * obj0 = 0 ;
40753 PyObject * obj1 = 0 ;
40754 char *kwnames[] = {
40755 (char *) "self",(char *) "idx", NULL
40756 };
40757
40758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40760 if (SWIG_arg_fail(1)) SWIG_fail;
40761 {
40762 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40763 if (SWIG_arg_fail(2)) SWIG_fail;
40764 }
40765 {
40766 PyThreadState* __tstate = wxPyBeginAllowThreads();
40767 (arg1)->RemoveGrowableCol(arg2);
40768
40769 wxPyEndAllowThreads(__tstate);
40770 if (PyErr_Occurred()) SWIG_fail;
40771 }
40772 Py_INCREF(Py_None); resultobj = Py_None;
40773 return resultobj;
40774 fail:
40775 return NULL;
40776 }
40777
40778
40779 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40780 PyObject *resultobj;
40781 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40782 int arg2 ;
40783 PyObject * obj0 = 0 ;
40784 PyObject * obj1 = 0 ;
40785 char *kwnames[] = {
40786 (char *) "self",(char *) "direction", NULL
40787 };
40788
40789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40791 if (SWIG_arg_fail(1)) SWIG_fail;
40792 {
40793 arg2 = (int)(SWIG_As_int(obj1));
40794 if (SWIG_arg_fail(2)) SWIG_fail;
40795 }
40796 {
40797 PyThreadState* __tstate = wxPyBeginAllowThreads();
40798 (arg1)->SetFlexibleDirection(arg2);
40799
40800 wxPyEndAllowThreads(__tstate);
40801 if (PyErr_Occurred()) SWIG_fail;
40802 }
40803 Py_INCREF(Py_None); resultobj = Py_None;
40804 return resultobj;
40805 fail:
40806 return NULL;
40807 }
40808
40809
40810 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40811 PyObject *resultobj;
40812 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40813 int result;
40814 PyObject * obj0 = 0 ;
40815 char *kwnames[] = {
40816 (char *) "self", NULL
40817 };
40818
40819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40821 if (SWIG_arg_fail(1)) SWIG_fail;
40822 {
40823 PyThreadState* __tstate = wxPyBeginAllowThreads();
40824 result = (int)(arg1)->GetFlexibleDirection();
40825
40826 wxPyEndAllowThreads(__tstate);
40827 if (PyErr_Occurred()) SWIG_fail;
40828 }
40829 {
40830 resultobj = SWIG_From_int((int)(result));
40831 }
40832 return resultobj;
40833 fail:
40834 return NULL;
40835 }
40836
40837
40838 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40839 PyObject *resultobj;
40840 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40841 wxFlexSizerGrowMode arg2 ;
40842 PyObject * obj0 = 0 ;
40843 PyObject * obj1 = 0 ;
40844 char *kwnames[] = {
40845 (char *) "self",(char *) "mode", NULL
40846 };
40847
40848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40850 if (SWIG_arg_fail(1)) SWIG_fail;
40851 {
40852 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40853 if (SWIG_arg_fail(2)) SWIG_fail;
40854 }
40855 {
40856 PyThreadState* __tstate = wxPyBeginAllowThreads();
40857 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40858
40859 wxPyEndAllowThreads(__tstate);
40860 if (PyErr_Occurred()) SWIG_fail;
40861 }
40862 Py_INCREF(Py_None); resultobj = Py_None;
40863 return resultobj;
40864 fail:
40865 return NULL;
40866 }
40867
40868
40869 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40870 PyObject *resultobj;
40871 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40872 wxFlexSizerGrowMode result;
40873 PyObject * obj0 = 0 ;
40874 char *kwnames[] = {
40875 (char *) "self", NULL
40876 };
40877
40878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40880 if (SWIG_arg_fail(1)) SWIG_fail;
40881 {
40882 PyThreadState* __tstate = wxPyBeginAllowThreads();
40883 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40884
40885 wxPyEndAllowThreads(__tstate);
40886 if (PyErr_Occurred()) SWIG_fail;
40887 }
40888 resultobj = SWIG_From_int((result));
40889 return resultobj;
40890 fail:
40891 return NULL;
40892 }
40893
40894
40895 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40896 PyObject *resultobj;
40897 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40898 wxArrayInt *result;
40899 PyObject * obj0 = 0 ;
40900 char *kwnames[] = {
40901 (char *) "self", NULL
40902 };
40903
40904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40906 if (SWIG_arg_fail(1)) SWIG_fail;
40907 {
40908 PyThreadState* __tstate = wxPyBeginAllowThreads();
40909 {
40910 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40911 result = (wxArrayInt *) &_result_ref;
40912 }
40913
40914 wxPyEndAllowThreads(__tstate);
40915 if (PyErr_Occurred()) SWIG_fail;
40916 }
40917 {
40918 resultobj = PyList_New(0);
40919 size_t idx;
40920 for (idx = 0; idx < result->GetCount(); idx += 1) {
40921 PyObject* val = PyInt_FromLong( result->Item(idx) );
40922 PyList_Append(resultobj, val);
40923 Py_DECREF(val);
40924 }
40925 }
40926 return resultobj;
40927 fail:
40928 return NULL;
40929 }
40930
40931
40932 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40933 PyObject *resultobj;
40934 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40935 wxArrayInt *result;
40936 PyObject * obj0 = 0 ;
40937 char *kwnames[] = {
40938 (char *) "self", NULL
40939 };
40940
40941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40943 if (SWIG_arg_fail(1)) SWIG_fail;
40944 {
40945 PyThreadState* __tstate = wxPyBeginAllowThreads();
40946 {
40947 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40948 result = (wxArrayInt *) &_result_ref;
40949 }
40950
40951 wxPyEndAllowThreads(__tstate);
40952 if (PyErr_Occurred()) SWIG_fail;
40953 }
40954 {
40955 resultobj = PyList_New(0);
40956 size_t idx;
40957 for (idx = 0; idx < result->GetCount(); idx += 1) {
40958 PyObject* val = PyInt_FromLong( result->Item(idx) );
40959 PyList_Append(resultobj, val);
40960 Py_DECREF(val);
40961 }
40962 }
40963 return resultobj;
40964 fail:
40965 return NULL;
40966 }
40967
40968
40969 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40970 PyObject *obj;
40971 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40972 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40973 Py_INCREF(obj);
40974 return Py_BuildValue((char *)"");
40975 }
40976 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40977 PyObject *resultobj;
40978 wxStdDialogButtonSizer *result;
40979 char *kwnames[] = {
40980 NULL
40981 };
40982
40983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40984 {
40985 PyThreadState* __tstate = wxPyBeginAllowThreads();
40986 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40987
40988 wxPyEndAllowThreads(__tstate);
40989 if (PyErr_Occurred()) SWIG_fail;
40990 }
40991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40992 return resultobj;
40993 fail:
40994 return NULL;
40995 }
40996
40997
40998 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40999 PyObject *resultobj;
41000 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41001 wxButton *arg2 = (wxButton *) 0 ;
41002 PyObject * obj0 = 0 ;
41003 PyObject * obj1 = 0 ;
41004 char *kwnames[] = {
41005 (char *) "self",(char *) "button", NULL
41006 };
41007
41008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41010 if (SWIG_arg_fail(1)) SWIG_fail;
41011 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41012 if (SWIG_arg_fail(2)) SWIG_fail;
41013 {
41014 PyThreadState* __tstate = wxPyBeginAllowThreads();
41015 (arg1)->AddButton(arg2);
41016
41017 wxPyEndAllowThreads(__tstate);
41018 if (PyErr_Occurred()) SWIG_fail;
41019 }
41020 Py_INCREF(Py_None); resultobj = Py_None;
41021 return resultobj;
41022 fail:
41023 return NULL;
41024 }
41025
41026
41027 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41028 PyObject *resultobj;
41029 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41030 PyObject * obj0 = 0 ;
41031 char *kwnames[] = {
41032 (char *) "self", NULL
41033 };
41034
41035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41037 if (SWIG_arg_fail(1)) SWIG_fail;
41038 {
41039 PyThreadState* __tstate = wxPyBeginAllowThreads();
41040 (arg1)->Realize();
41041
41042 wxPyEndAllowThreads(__tstate);
41043 if (PyErr_Occurred()) SWIG_fail;
41044 }
41045 Py_INCREF(Py_None); resultobj = Py_None;
41046 return resultobj;
41047 fail:
41048 return NULL;
41049 }
41050
41051
41052 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41053 PyObject *resultobj;
41054 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41055 wxButton *arg2 = (wxButton *) 0 ;
41056 PyObject * obj0 = 0 ;
41057 PyObject * obj1 = 0 ;
41058 char *kwnames[] = {
41059 (char *) "self",(char *) "button", NULL
41060 };
41061
41062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41064 if (SWIG_arg_fail(1)) SWIG_fail;
41065 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41066 if (SWIG_arg_fail(2)) SWIG_fail;
41067 {
41068 PyThreadState* __tstate = wxPyBeginAllowThreads();
41069 (arg1)->SetAffirmativeButton(arg2);
41070
41071 wxPyEndAllowThreads(__tstate);
41072 if (PyErr_Occurred()) SWIG_fail;
41073 }
41074 Py_INCREF(Py_None); resultobj = Py_None;
41075 return resultobj;
41076 fail:
41077 return NULL;
41078 }
41079
41080
41081 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41082 PyObject *resultobj;
41083 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41084 wxButton *arg2 = (wxButton *) 0 ;
41085 PyObject * obj0 = 0 ;
41086 PyObject * obj1 = 0 ;
41087 char *kwnames[] = {
41088 (char *) "self",(char *) "button", NULL
41089 };
41090
41091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41093 if (SWIG_arg_fail(1)) SWIG_fail;
41094 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41095 if (SWIG_arg_fail(2)) SWIG_fail;
41096 {
41097 PyThreadState* __tstate = wxPyBeginAllowThreads();
41098 (arg1)->SetNegativeButton(arg2);
41099
41100 wxPyEndAllowThreads(__tstate);
41101 if (PyErr_Occurred()) SWIG_fail;
41102 }
41103 Py_INCREF(Py_None); resultobj = Py_None;
41104 return resultobj;
41105 fail:
41106 return NULL;
41107 }
41108
41109
41110 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41111 PyObject *resultobj;
41112 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41113 wxButton *arg2 = (wxButton *) 0 ;
41114 PyObject * obj0 = 0 ;
41115 PyObject * obj1 = 0 ;
41116 char *kwnames[] = {
41117 (char *) "self",(char *) "button", NULL
41118 };
41119
41120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41122 if (SWIG_arg_fail(1)) SWIG_fail;
41123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41124 if (SWIG_arg_fail(2)) SWIG_fail;
41125 {
41126 PyThreadState* __tstate = wxPyBeginAllowThreads();
41127 (arg1)->SetCancelButton(arg2);
41128
41129 wxPyEndAllowThreads(__tstate);
41130 if (PyErr_Occurred()) SWIG_fail;
41131 }
41132 Py_INCREF(Py_None); resultobj = Py_None;
41133 return resultobj;
41134 fail:
41135 return NULL;
41136 }
41137
41138
41139 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41140 PyObject *resultobj;
41141 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41142 wxButton *result;
41143 PyObject * obj0 = 0 ;
41144 char *kwnames[] = {
41145 (char *) "self", NULL
41146 };
41147
41148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41150 if (SWIG_arg_fail(1)) SWIG_fail;
41151 {
41152 PyThreadState* __tstate = wxPyBeginAllowThreads();
41153 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41154
41155 wxPyEndAllowThreads(__tstate);
41156 if (PyErr_Occurred()) SWIG_fail;
41157 }
41158 {
41159 resultobj = wxPyMake_wxObject(result, 0);
41160 }
41161 return resultobj;
41162 fail:
41163 return NULL;
41164 }
41165
41166
41167 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41168 PyObject *resultobj;
41169 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41170 wxButton *result;
41171 PyObject * obj0 = 0 ;
41172 char *kwnames[] = {
41173 (char *) "self", NULL
41174 };
41175
41176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41178 if (SWIG_arg_fail(1)) SWIG_fail;
41179 {
41180 PyThreadState* __tstate = wxPyBeginAllowThreads();
41181 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41182
41183 wxPyEndAllowThreads(__tstate);
41184 if (PyErr_Occurred()) SWIG_fail;
41185 }
41186 {
41187 resultobj = wxPyMake_wxObject(result, 0);
41188 }
41189 return resultobj;
41190 fail:
41191 return NULL;
41192 }
41193
41194
41195 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41196 PyObject *resultobj;
41197 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41198 wxButton *result;
41199 PyObject * obj0 = 0 ;
41200 char *kwnames[] = {
41201 (char *) "self", NULL
41202 };
41203
41204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41206 if (SWIG_arg_fail(1)) SWIG_fail;
41207 {
41208 PyThreadState* __tstate = wxPyBeginAllowThreads();
41209 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41210
41211 wxPyEndAllowThreads(__tstate);
41212 if (PyErr_Occurred()) SWIG_fail;
41213 }
41214 {
41215 resultobj = wxPyMake_wxObject(result, 0);
41216 }
41217 return resultobj;
41218 fail:
41219 return NULL;
41220 }
41221
41222
41223 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41224 PyObject *resultobj;
41225 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41226 wxButton *result;
41227 PyObject * obj0 = 0 ;
41228 char *kwnames[] = {
41229 (char *) "self", NULL
41230 };
41231
41232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41234 if (SWIG_arg_fail(1)) SWIG_fail;
41235 {
41236 PyThreadState* __tstate = wxPyBeginAllowThreads();
41237 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41238
41239 wxPyEndAllowThreads(__tstate);
41240 if (PyErr_Occurred()) SWIG_fail;
41241 }
41242 {
41243 resultobj = wxPyMake_wxObject(result, 0);
41244 }
41245 return resultobj;
41246 fail:
41247 return NULL;
41248 }
41249
41250
41251 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41252 PyObject *resultobj;
41253 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41254 wxButton *result;
41255 PyObject * obj0 = 0 ;
41256 char *kwnames[] = {
41257 (char *) "self", NULL
41258 };
41259
41260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41262 if (SWIG_arg_fail(1)) SWIG_fail;
41263 {
41264 PyThreadState* __tstate = wxPyBeginAllowThreads();
41265 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41266
41267 wxPyEndAllowThreads(__tstate);
41268 if (PyErr_Occurred()) SWIG_fail;
41269 }
41270 {
41271 resultobj = wxPyMake_wxObject(result, 0);
41272 }
41273 return resultobj;
41274 fail:
41275 return NULL;
41276 }
41277
41278
41279 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41280 PyObject *obj;
41281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41282 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41283 Py_INCREF(obj);
41284 return Py_BuildValue((char *)"");
41285 }
41286 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41287 PyObject *resultobj;
41288 int arg1 = (int) 0 ;
41289 int arg2 = (int) 0 ;
41290 wxGBPosition *result;
41291 PyObject * obj0 = 0 ;
41292 PyObject * obj1 = 0 ;
41293 char *kwnames[] = {
41294 (char *) "row",(char *) "col", NULL
41295 };
41296
41297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41298 if (obj0) {
41299 {
41300 arg1 = (int)(SWIG_As_int(obj0));
41301 if (SWIG_arg_fail(1)) SWIG_fail;
41302 }
41303 }
41304 if (obj1) {
41305 {
41306 arg2 = (int)(SWIG_As_int(obj1));
41307 if (SWIG_arg_fail(2)) SWIG_fail;
41308 }
41309 }
41310 {
41311 PyThreadState* __tstate = wxPyBeginAllowThreads();
41312 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41313
41314 wxPyEndAllowThreads(__tstate);
41315 if (PyErr_Occurred()) SWIG_fail;
41316 }
41317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41318 return resultobj;
41319 fail:
41320 return NULL;
41321 }
41322
41323
41324 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41325 PyObject *resultobj;
41326 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41327 int result;
41328 PyObject * obj0 = 0 ;
41329 char *kwnames[] = {
41330 (char *) "self", NULL
41331 };
41332
41333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41335 if (SWIG_arg_fail(1)) SWIG_fail;
41336 {
41337 PyThreadState* __tstate = wxPyBeginAllowThreads();
41338 result = (int)((wxGBPosition const *)arg1)->GetRow();
41339
41340 wxPyEndAllowThreads(__tstate);
41341 if (PyErr_Occurred()) SWIG_fail;
41342 }
41343 {
41344 resultobj = SWIG_From_int((int)(result));
41345 }
41346 return resultobj;
41347 fail:
41348 return NULL;
41349 }
41350
41351
41352 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41353 PyObject *resultobj;
41354 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41355 int result;
41356 PyObject * obj0 = 0 ;
41357 char *kwnames[] = {
41358 (char *) "self", NULL
41359 };
41360
41361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41363 if (SWIG_arg_fail(1)) SWIG_fail;
41364 {
41365 PyThreadState* __tstate = wxPyBeginAllowThreads();
41366 result = (int)((wxGBPosition const *)arg1)->GetCol();
41367
41368 wxPyEndAllowThreads(__tstate);
41369 if (PyErr_Occurred()) SWIG_fail;
41370 }
41371 {
41372 resultobj = SWIG_From_int((int)(result));
41373 }
41374 return resultobj;
41375 fail:
41376 return NULL;
41377 }
41378
41379
41380 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41381 PyObject *resultobj;
41382 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41383 int arg2 ;
41384 PyObject * obj0 = 0 ;
41385 PyObject * obj1 = 0 ;
41386 char *kwnames[] = {
41387 (char *) "self",(char *) "row", NULL
41388 };
41389
41390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41392 if (SWIG_arg_fail(1)) SWIG_fail;
41393 {
41394 arg2 = (int)(SWIG_As_int(obj1));
41395 if (SWIG_arg_fail(2)) SWIG_fail;
41396 }
41397 {
41398 PyThreadState* __tstate = wxPyBeginAllowThreads();
41399 (arg1)->SetRow(arg2);
41400
41401 wxPyEndAllowThreads(__tstate);
41402 if (PyErr_Occurred()) SWIG_fail;
41403 }
41404 Py_INCREF(Py_None); resultobj = Py_None;
41405 return resultobj;
41406 fail:
41407 return NULL;
41408 }
41409
41410
41411 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41412 PyObject *resultobj;
41413 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41414 int arg2 ;
41415 PyObject * obj0 = 0 ;
41416 PyObject * obj1 = 0 ;
41417 char *kwnames[] = {
41418 (char *) "self",(char *) "col", NULL
41419 };
41420
41421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41423 if (SWIG_arg_fail(1)) SWIG_fail;
41424 {
41425 arg2 = (int)(SWIG_As_int(obj1));
41426 if (SWIG_arg_fail(2)) SWIG_fail;
41427 }
41428 {
41429 PyThreadState* __tstate = wxPyBeginAllowThreads();
41430 (arg1)->SetCol(arg2);
41431
41432 wxPyEndAllowThreads(__tstate);
41433 if (PyErr_Occurred()) SWIG_fail;
41434 }
41435 Py_INCREF(Py_None); resultobj = Py_None;
41436 return resultobj;
41437 fail:
41438 return NULL;
41439 }
41440
41441
41442 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41443 PyObject *resultobj;
41444 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41445 wxGBPosition *arg2 = 0 ;
41446 bool result;
41447 wxGBPosition temp2 ;
41448 PyObject * obj0 = 0 ;
41449 PyObject * obj1 = 0 ;
41450 char *kwnames[] = {
41451 (char *) "self",(char *) "other", NULL
41452 };
41453
41454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41456 if (SWIG_arg_fail(1)) SWIG_fail;
41457 {
41458 arg2 = &temp2;
41459 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41460 }
41461 {
41462 PyThreadState* __tstate = wxPyBeginAllowThreads();
41463 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41464
41465 wxPyEndAllowThreads(__tstate);
41466 if (PyErr_Occurred()) SWIG_fail;
41467 }
41468 {
41469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41470 }
41471 return resultobj;
41472 fail:
41473 return NULL;
41474 }
41475
41476
41477 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41478 PyObject *resultobj;
41479 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41480 wxGBPosition *arg2 = 0 ;
41481 bool result;
41482 wxGBPosition temp2 ;
41483 PyObject * obj0 = 0 ;
41484 PyObject * obj1 = 0 ;
41485 char *kwnames[] = {
41486 (char *) "self",(char *) "other", NULL
41487 };
41488
41489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41491 if (SWIG_arg_fail(1)) SWIG_fail;
41492 {
41493 arg2 = &temp2;
41494 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41495 }
41496 {
41497 PyThreadState* __tstate = wxPyBeginAllowThreads();
41498 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41499
41500 wxPyEndAllowThreads(__tstate);
41501 if (PyErr_Occurred()) SWIG_fail;
41502 }
41503 {
41504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41505 }
41506 return resultobj;
41507 fail:
41508 return NULL;
41509 }
41510
41511
41512 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41513 PyObject *resultobj;
41514 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41515 int arg2 = (int) 0 ;
41516 int arg3 = (int) 0 ;
41517 PyObject * obj0 = 0 ;
41518 PyObject * obj1 = 0 ;
41519 PyObject * obj2 = 0 ;
41520 char *kwnames[] = {
41521 (char *) "self",(char *) "row",(char *) "col", NULL
41522 };
41523
41524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41526 if (SWIG_arg_fail(1)) SWIG_fail;
41527 if (obj1) {
41528 {
41529 arg2 = (int)(SWIG_As_int(obj1));
41530 if (SWIG_arg_fail(2)) SWIG_fail;
41531 }
41532 }
41533 if (obj2) {
41534 {
41535 arg3 = (int)(SWIG_As_int(obj2));
41536 if (SWIG_arg_fail(3)) SWIG_fail;
41537 }
41538 }
41539 {
41540 PyThreadState* __tstate = wxPyBeginAllowThreads();
41541 wxGBPosition_Set(arg1,arg2,arg3);
41542
41543 wxPyEndAllowThreads(__tstate);
41544 if (PyErr_Occurred()) SWIG_fail;
41545 }
41546 Py_INCREF(Py_None); resultobj = Py_None;
41547 return resultobj;
41548 fail:
41549 return NULL;
41550 }
41551
41552
41553 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41554 PyObject *resultobj;
41555 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41556 PyObject *result;
41557 PyObject * obj0 = 0 ;
41558 char *kwnames[] = {
41559 (char *) "self", NULL
41560 };
41561
41562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41564 if (SWIG_arg_fail(1)) SWIG_fail;
41565 {
41566 PyThreadState* __tstate = wxPyBeginAllowThreads();
41567 result = (PyObject *)wxGBPosition_Get(arg1);
41568
41569 wxPyEndAllowThreads(__tstate);
41570 if (PyErr_Occurred()) SWIG_fail;
41571 }
41572 resultobj = result;
41573 return resultobj;
41574 fail:
41575 return NULL;
41576 }
41577
41578
41579 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41580 PyObject *obj;
41581 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41582 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41583 Py_INCREF(obj);
41584 return Py_BuildValue((char *)"");
41585 }
41586 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41587 PyObject *resultobj;
41588 int arg1 = (int) 1 ;
41589 int arg2 = (int) 1 ;
41590 wxGBSpan *result;
41591 PyObject * obj0 = 0 ;
41592 PyObject * obj1 = 0 ;
41593 char *kwnames[] = {
41594 (char *) "rowspan",(char *) "colspan", NULL
41595 };
41596
41597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41598 if (obj0) {
41599 {
41600 arg1 = (int)(SWIG_As_int(obj0));
41601 if (SWIG_arg_fail(1)) SWIG_fail;
41602 }
41603 }
41604 if (obj1) {
41605 {
41606 arg2 = (int)(SWIG_As_int(obj1));
41607 if (SWIG_arg_fail(2)) SWIG_fail;
41608 }
41609 }
41610 {
41611 PyThreadState* __tstate = wxPyBeginAllowThreads();
41612 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41613
41614 wxPyEndAllowThreads(__tstate);
41615 if (PyErr_Occurred()) SWIG_fail;
41616 }
41617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41618 return resultobj;
41619 fail:
41620 return NULL;
41621 }
41622
41623
41624 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41625 PyObject *resultobj;
41626 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41627 int result;
41628 PyObject * obj0 = 0 ;
41629 char *kwnames[] = {
41630 (char *) "self", NULL
41631 };
41632
41633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41635 if (SWIG_arg_fail(1)) SWIG_fail;
41636 {
41637 PyThreadState* __tstate = wxPyBeginAllowThreads();
41638 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41639
41640 wxPyEndAllowThreads(__tstate);
41641 if (PyErr_Occurred()) SWIG_fail;
41642 }
41643 {
41644 resultobj = SWIG_From_int((int)(result));
41645 }
41646 return resultobj;
41647 fail:
41648 return NULL;
41649 }
41650
41651
41652 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41653 PyObject *resultobj;
41654 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41655 int result;
41656 PyObject * obj0 = 0 ;
41657 char *kwnames[] = {
41658 (char *) "self", NULL
41659 };
41660
41661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41663 if (SWIG_arg_fail(1)) SWIG_fail;
41664 {
41665 PyThreadState* __tstate = wxPyBeginAllowThreads();
41666 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41667
41668 wxPyEndAllowThreads(__tstate);
41669 if (PyErr_Occurred()) SWIG_fail;
41670 }
41671 {
41672 resultobj = SWIG_From_int((int)(result));
41673 }
41674 return resultobj;
41675 fail:
41676 return NULL;
41677 }
41678
41679
41680 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41681 PyObject *resultobj;
41682 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41683 int arg2 ;
41684 PyObject * obj0 = 0 ;
41685 PyObject * obj1 = 0 ;
41686 char *kwnames[] = {
41687 (char *) "self",(char *) "rowspan", NULL
41688 };
41689
41690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41692 if (SWIG_arg_fail(1)) SWIG_fail;
41693 {
41694 arg2 = (int)(SWIG_As_int(obj1));
41695 if (SWIG_arg_fail(2)) SWIG_fail;
41696 }
41697 {
41698 PyThreadState* __tstate = wxPyBeginAllowThreads();
41699 (arg1)->SetRowspan(arg2);
41700
41701 wxPyEndAllowThreads(__tstate);
41702 if (PyErr_Occurred()) SWIG_fail;
41703 }
41704 Py_INCREF(Py_None); resultobj = Py_None;
41705 return resultobj;
41706 fail:
41707 return NULL;
41708 }
41709
41710
41711 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41712 PyObject *resultobj;
41713 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41714 int arg2 ;
41715 PyObject * obj0 = 0 ;
41716 PyObject * obj1 = 0 ;
41717 char *kwnames[] = {
41718 (char *) "self",(char *) "colspan", NULL
41719 };
41720
41721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41723 if (SWIG_arg_fail(1)) SWIG_fail;
41724 {
41725 arg2 = (int)(SWIG_As_int(obj1));
41726 if (SWIG_arg_fail(2)) SWIG_fail;
41727 }
41728 {
41729 PyThreadState* __tstate = wxPyBeginAllowThreads();
41730 (arg1)->SetColspan(arg2);
41731
41732 wxPyEndAllowThreads(__tstate);
41733 if (PyErr_Occurred()) SWIG_fail;
41734 }
41735 Py_INCREF(Py_None); resultobj = Py_None;
41736 return resultobj;
41737 fail:
41738 return NULL;
41739 }
41740
41741
41742 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41743 PyObject *resultobj;
41744 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41745 wxGBSpan *arg2 = 0 ;
41746 bool result;
41747 wxGBSpan temp2 ;
41748 PyObject * obj0 = 0 ;
41749 PyObject * obj1 = 0 ;
41750 char *kwnames[] = {
41751 (char *) "self",(char *) "other", NULL
41752 };
41753
41754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41756 if (SWIG_arg_fail(1)) SWIG_fail;
41757 {
41758 arg2 = &temp2;
41759 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41760 }
41761 {
41762 PyThreadState* __tstate = wxPyBeginAllowThreads();
41763 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41764
41765 wxPyEndAllowThreads(__tstate);
41766 if (PyErr_Occurred()) SWIG_fail;
41767 }
41768 {
41769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41770 }
41771 return resultobj;
41772 fail:
41773 return NULL;
41774 }
41775
41776
41777 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41778 PyObject *resultobj;
41779 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41780 wxGBSpan *arg2 = 0 ;
41781 bool result;
41782 wxGBSpan temp2 ;
41783 PyObject * obj0 = 0 ;
41784 PyObject * obj1 = 0 ;
41785 char *kwnames[] = {
41786 (char *) "self",(char *) "other", NULL
41787 };
41788
41789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41791 if (SWIG_arg_fail(1)) SWIG_fail;
41792 {
41793 arg2 = &temp2;
41794 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41795 }
41796 {
41797 PyThreadState* __tstate = wxPyBeginAllowThreads();
41798 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41799
41800 wxPyEndAllowThreads(__tstate);
41801 if (PyErr_Occurred()) SWIG_fail;
41802 }
41803 {
41804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41805 }
41806 return resultobj;
41807 fail:
41808 return NULL;
41809 }
41810
41811
41812 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41813 PyObject *resultobj;
41814 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41815 int arg2 = (int) 1 ;
41816 int arg3 = (int) 1 ;
41817 PyObject * obj0 = 0 ;
41818 PyObject * obj1 = 0 ;
41819 PyObject * obj2 = 0 ;
41820 char *kwnames[] = {
41821 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41822 };
41823
41824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41826 if (SWIG_arg_fail(1)) SWIG_fail;
41827 if (obj1) {
41828 {
41829 arg2 = (int)(SWIG_As_int(obj1));
41830 if (SWIG_arg_fail(2)) SWIG_fail;
41831 }
41832 }
41833 if (obj2) {
41834 {
41835 arg3 = (int)(SWIG_As_int(obj2));
41836 if (SWIG_arg_fail(3)) SWIG_fail;
41837 }
41838 }
41839 {
41840 PyThreadState* __tstate = wxPyBeginAllowThreads();
41841 wxGBSpan_Set(arg1,arg2,arg3);
41842
41843 wxPyEndAllowThreads(__tstate);
41844 if (PyErr_Occurred()) SWIG_fail;
41845 }
41846 Py_INCREF(Py_None); resultobj = Py_None;
41847 return resultobj;
41848 fail:
41849 return NULL;
41850 }
41851
41852
41853 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41854 PyObject *resultobj;
41855 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41856 PyObject *result;
41857 PyObject * obj0 = 0 ;
41858 char *kwnames[] = {
41859 (char *) "self", NULL
41860 };
41861
41862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41864 if (SWIG_arg_fail(1)) SWIG_fail;
41865 {
41866 PyThreadState* __tstate = wxPyBeginAllowThreads();
41867 result = (PyObject *)wxGBSpan_Get(arg1);
41868
41869 wxPyEndAllowThreads(__tstate);
41870 if (PyErr_Occurred()) SWIG_fail;
41871 }
41872 resultobj = result;
41873 return resultobj;
41874 fail:
41875 return NULL;
41876 }
41877
41878
41879 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41880 PyObject *obj;
41881 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41882 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41883 Py_INCREF(obj);
41884 return Py_BuildValue((char *)"");
41885 }
41886 static int _wrap_DefaultSpan_set(PyObject *) {
41887 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41888 return 1;
41889 }
41890
41891
41892 static PyObject *_wrap_DefaultSpan_get(void) {
41893 PyObject *pyobj;
41894
41895 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41896 return pyobj;
41897 }
41898
41899
41900 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41901 PyObject *resultobj;
41902 wxGBSizerItem *result;
41903 char *kwnames[] = {
41904 NULL
41905 };
41906
41907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41908 {
41909 PyThreadState* __tstate = wxPyBeginAllowThreads();
41910 result = (wxGBSizerItem *)new wxGBSizerItem();
41911
41912 wxPyEndAllowThreads(__tstate);
41913 if (PyErr_Occurred()) SWIG_fail;
41914 }
41915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41916 return resultobj;
41917 fail:
41918 return NULL;
41919 }
41920
41921
41922 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41923 PyObject *resultobj;
41924 wxWindow *arg1 = (wxWindow *) 0 ;
41925 wxGBPosition *arg2 = 0 ;
41926 wxGBSpan *arg3 = 0 ;
41927 int arg4 ;
41928 int arg5 ;
41929 PyObject *arg6 = (PyObject *) NULL ;
41930 wxGBSizerItem *result;
41931 wxGBPosition temp2 ;
41932 wxGBSpan temp3 ;
41933 PyObject * obj0 = 0 ;
41934 PyObject * obj1 = 0 ;
41935 PyObject * obj2 = 0 ;
41936 PyObject * obj3 = 0 ;
41937 PyObject * obj4 = 0 ;
41938 PyObject * obj5 = 0 ;
41939 char *kwnames[] = {
41940 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41941 };
41942
41943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41945 if (SWIG_arg_fail(1)) SWIG_fail;
41946 {
41947 arg2 = &temp2;
41948 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41949 }
41950 {
41951 arg3 = &temp3;
41952 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41953 }
41954 {
41955 arg4 = (int)(SWIG_As_int(obj3));
41956 if (SWIG_arg_fail(4)) SWIG_fail;
41957 }
41958 {
41959 arg5 = (int)(SWIG_As_int(obj4));
41960 if (SWIG_arg_fail(5)) SWIG_fail;
41961 }
41962 if (obj5) {
41963 arg6 = obj5;
41964 }
41965 {
41966 PyThreadState* __tstate = wxPyBeginAllowThreads();
41967 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41968
41969 wxPyEndAllowThreads(__tstate);
41970 if (PyErr_Occurred()) SWIG_fail;
41971 }
41972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41973 return resultobj;
41974 fail:
41975 return NULL;
41976 }
41977
41978
41979 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41980 PyObject *resultobj;
41981 wxSizer *arg1 = (wxSizer *) 0 ;
41982 wxGBPosition *arg2 = 0 ;
41983 wxGBSpan *arg3 = 0 ;
41984 int arg4 ;
41985 int arg5 ;
41986 PyObject *arg6 = (PyObject *) NULL ;
41987 wxGBSizerItem *result;
41988 wxGBPosition temp2 ;
41989 wxGBSpan temp3 ;
41990 PyObject * obj0 = 0 ;
41991 PyObject * obj1 = 0 ;
41992 PyObject * obj2 = 0 ;
41993 PyObject * obj3 = 0 ;
41994 PyObject * obj4 = 0 ;
41995 PyObject * obj5 = 0 ;
41996 char *kwnames[] = {
41997 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41998 };
41999
42000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42002 if (SWIG_arg_fail(1)) SWIG_fail;
42003 {
42004 arg2 = &temp2;
42005 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42006 }
42007 {
42008 arg3 = &temp3;
42009 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42010 }
42011 {
42012 arg4 = (int)(SWIG_As_int(obj3));
42013 if (SWIG_arg_fail(4)) SWIG_fail;
42014 }
42015 {
42016 arg5 = (int)(SWIG_As_int(obj4));
42017 if (SWIG_arg_fail(5)) SWIG_fail;
42018 }
42019 if (obj5) {
42020 arg6 = obj5;
42021 }
42022 {
42023 PyThreadState* __tstate = wxPyBeginAllowThreads();
42024 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42025
42026 wxPyEndAllowThreads(__tstate);
42027 if (PyErr_Occurred()) SWIG_fail;
42028 }
42029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42030 return resultobj;
42031 fail:
42032 return NULL;
42033 }
42034
42035
42036 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42037 PyObject *resultobj;
42038 int arg1 ;
42039 int arg2 ;
42040 wxGBPosition *arg3 = 0 ;
42041 wxGBSpan *arg4 = 0 ;
42042 int arg5 ;
42043 int arg6 ;
42044 PyObject *arg7 = (PyObject *) NULL ;
42045 wxGBSizerItem *result;
42046 wxGBPosition temp3 ;
42047 wxGBSpan temp4 ;
42048 PyObject * obj0 = 0 ;
42049 PyObject * obj1 = 0 ;
42050 PyObject * obj2 = 0 ;
42051 PyObject * obj3 = 0 ;
42052 PyObject * obj4 = 0 ;
42053 PyObject * obj5 = 0 ;
42054 PyObject * obj6 = 0 ;
42055 char *kwnames[] = {
42056 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42057 };
42058
42059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42060 {
42061 arg1 = (int)(SWIG_As_int(obj0));
42062 if (SWIG_arg_fail(1)) SWIG_fail;
42063 }
42064 {
42065 arg2 = (int)(SWIG_As_int(obj1));
42066 if (SWIG_arg_fail(2)) SWIG_fail;
42067 }
42068 {
42069 arg3 = &temp3;
42070 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42071 }
42072 {
42073 arg4 = &temp4;
42074 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42075 }
42076 {
42077 arg5 = (int)(SWIG_As_int(obj4));
42078 if (SWIG_arg_fail(5)) SWIG_fail;
42079 }
42080 {
42081 arg6 = (int)(SWIG_As_int(obj5));
42082 if (SWIG_arg_fail(6)) SWIG_fail;
42083 }
42084 if (obj6) {
42085 arg7 = obj6;
42086 }
42087 {
42088 PyThreadState* __tstate = wxPyBeginAllowThreads();
42089 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42090
42091 wxPyEndAllowThreads(__tstate);
42092 if (PyErr_Occurred()) SWIG_fail;
42093 }
42094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42095 return resultobj;
42096 fail:
42097 return NULL;
42098 }
42099
42100
42101 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42102 PyObject *resultobj;
42103 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42104 wxGBPosition result;
42105 PyObject * obj0 = 0 ;
42106 char *kwnames[] = {
42107 (char *) "self", NULL
42108 };
42109
42110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42112 if (SWIG_arg_fail(1)) SWIG_fail;
42113 {
42114 PyThreadState* __tstate = wxPyBeginAllowThreads();
42115 result = ((wxGBSizerItem const *)arg1)->GetPos();
42116
42117 wxPyEndAllowThreads(__tstate);
42118 if (PyErr_Occurred()) SWIG_fail;
42119 }
42120 {
42121 wxGBPosition * resultptr;
42122 resultptr = new wxGBPosition((wxGBPosition &)(result));
42123 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42124 }
42125 return resultobj;
42126 fail:
42127 return NULL;
42128 }
42129
42130
42131 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42132 PyObject *resultobj;
42133 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42134 wxGBSpan result;
42135 PyObject * obj0 = 0 ;
42136 char *kwnames[] = {
42137 (char *) "self", NULL
42138 };
42139
42140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42142 if (SWIG_arg_fail(1)) SWIG_fail;
42143 {
42144 PyThreadState* __tstate = wxPyBeginAllowThreads();
42145 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42146
42147 wxPyEndAllowThreads(__tstate);
42148 if (PyErr_Occurred()) SWIG_fail;
42149 }
42150 {
42151 wxGBSpan * resultptr;
42152 resultptr = new wxGBSpan((wxGBSpan &)(result));
42153 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42154 }
42155 return resultobj;
42156 fail:
42157 return NULL;
42158 }
42159
42160
42161 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42162 PyObject *resultobj;
42163 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42164 wxGBPosition *arg2 = 0 ;
42165 bool result;
42166 wxGBPosition temp2 ;
42167 PyObject * obj0 = 0 ;
42168 PyObject * obj1 = 0 ;
42169 char *kwnames[] = {
42170 (char *) "self",(char *) "pos", NULL
42171 };
42172
42173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42175 if (SWIG_arg_fail(1)) SWIG_fail;
42176 {
42177 arg2 = &temp2;
42178 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42179 }
42180 {
42181 PyThreadState* __tstate = wxPyBeginAllowThreads();
42182 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42183
42184 wxPyEndAllowThreads(__tstate);
42185 if (PyErr_Occurred()) SWIG_fail;
42186 }
42187 {
42188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42189 }
42190 return resultobj;
42191 fail:
42192 return NULL;
42193 }
42194
42195
42196 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42197 PyObject *resultobj;
42198 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42199 wxGBSpan *arg2 = 0 ;
42200 bool result;
42201 wxGBSpan temp2 ;
42202 PyObject * obj0 = 0 ;
42203 PyObject * obj1 = 0 ;
42204 char *kwnames[] = {
42205 (char *) "self",(char *) "span", NULL
42206 };
42207
42208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42210 if (SWIG_arg_fail(1)) SWIG_fail;
42211 {
42212 arg2 = &temp2;
42213 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42214 }
42215 {
42216 PyThreadState* __tstate = wxPyBeginAllowThreads();
42217 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42218
42219 wxPyEndAllowThreads(__tstate);
42220 if (PyErr_Occurred()) SWIG_fail;
42221 }
42222 {
42223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42224 }
42225 return resultobj;
42226 fail:
42227 return NULL;
42228 }
42229
42230
42231 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42232 PyObject *resultobj;
42233 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42234 wxGBSizerItem *arg2 = 0 ;
42235 bool result;
42236 PyObject * obj0 = 0 ;
42237 PyObject * obj1 = 0 ;
42238 char *kwnames[] = {
42239 (char *) "self",(char *) "other", NULL
42240 };
42241
42242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42244 if (SWIG_arg_fail(1)) SWIG_fail;
42245 {
42246 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42247 if (SWIG_arg_fail(2)) SWIG_fail;
42248 if (arg2 == NULL) {
42249 SWIG_null_ref("wxGBSizerItem");
42250 }
42251 if (SWIG_arg_fail(2)) SWIG_fail;
42252 }
42253 {
42254 PyThreadState* __tstate = wxPyBeginAllowThreads();
42255 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42256
42257 wxPyEndAllowThreads(__tstate);
42258 if (PyErr_Occurred()) SWIG_fail;
42259 }
42260 {
42261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42262 }
42263 return resultobj;
42264 fail:
42265 return NULL;
42266 }
42267
42268
42269 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42270 PyObject *resultobj;
42271 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42272 wxGBPosition *arg2 = 0 ;
42273 wxGBSpan *arg3 = 0 ;
42274 bool result;
42275 wxGBPosition temp2 ;
42276 wxGBSpan temp3 ;
42277 PyObject * obj0 = 0 ;
42278 PyObject * obj1 = 0 ;
42279 PyObject * obj2 = 0 ;
42280 char *kwnames[] = {
42281 (char *) "self",(char *) "pos",(char *) "span", NULL
42282 };
42283
42284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42286 if (SWIG_arg_fail(1)) SWIG_fail;
42287 {
42288 arg2 = &temp2;
42289 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42290 }
42291 {
42292 arg3 = &temp3;
42293 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42294 }
42295 {
42296 PyThreadState* __tstate = wxPyBeginAllowThreads();
42297 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42298
42299 wxPyEndAllowThreads(__tstate);
42300 if (PyErr_Occurred()) SWIG_fail;
42301 }
42302 {
42303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42304 }
42305 return resultobj;
42306 fail:
42307 return NULL;
42308 }
42309
42310
42311 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42312 PyObject *resultobj;
42313 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42314 wxGBPosition result;
42315 PyObject * obj0 = 0 ;
42316 char *kwnames[] = {
42317 (char *) "self", NULL
42318 };
42319
42320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42322 if (SWIG_arg_fail(1)) SWIG_fail;
42323 {
42324 PyThreadState* __tstate = wxPyBeginAllowThreads();
42325 result = wxGBSizerItem_GetEndPos(arg1);
42326
42327 wxPyEndAllowThreads(__tstate);
42328 if (PyErr_Occurred()) SWIG_fail;
42329 }
42330 {
42331 wxGBPosition * resultptr;
42332 resultptr = new wxGBPosition((wxGBPosition &)(result));
42333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42334 }
42335 return resultobj;
42336 fail:
42337 return NULL;
42338 }
42339
42340
42341 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42342 PyObject *resultobj;
42343 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42344 wxGridBagSizer *result;
42345 PyObject * obj0 = 0 ;
42346 char *kwnames[] = {
42347 (char *) "self", NULL
42348 };
42349
42350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42352 if (SWIG_arg_fail(1)) SWIG_fail;
42353 {
42354 PyThreadState* __tstate = wxPyBeginAllowThreads();
42355 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42356
42357 wxPyEndAllowThreads(__tstate);
42358 if (PyErr_Occurred()) SWIG_fail;
42359 }
42360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42361 return resultobj;
42362 fail:
42363 return NULL;
42364 }
42365
42366
42367 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42368 PyObject *resultobj;
42369 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42370 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42371 PyObject * obj0 = 0 ;
42372 PyObject * obj1 = 0 ;
42373 char *kwnames[] = {
42374 (char *) "self",(char *) "sizer", NULL
42375 };
42376
42377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42379 if (SWIG_arg_fail(1)) SWIG_fail;
42380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42381 if (SWIG_arg_fail(2)) SWIG_fail;
42382 {
42383 PyThreadState* __tstate = wxPyBeginAllowThreads();
42384 (arg1)->SetGBSizer(arg2);
42385
42386 wxPyEndAllowThreads(__tstate);
42387 if (PyErr_Occurred()) SWIG_fail;
42388 }
42389 Py_INCREF(Py_None); resultobj = Py_None;
42390 return resultobj;
42391 fail:
42392 return NULL;
42393 }
42394
42395
42396 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42397 PyObject *obj;
42398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42399 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42400 Py_INCREF(obj);
42401 return Py_BuildValue((char *)"");
42402 }
42403 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42404 PyObject *resultobj;
42405 int arg1 = (int) 0 ;
42406 int arg2 = (int) 0 ;
42407 wxGridBagSizer *result;
42408 PyObject * obj0 = 0 ;
42409 PyObject * obj1 = 0 ;
42410 char *kwnames[] = {
42411 (char *) "vgap",(char *) "hgap", NULL
42412 };
42413
42414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42415 if (obj0) {
42416 {
42417 arg1 = (int)(SWIG_As_int(obj0));
42418 if (SWIG_arg_fail(1)) SWIG_fail;
42419 }
42420 }
42421 if (obj1) {
42422 {
42423 arg2 = (int)(SWIG_As_int(obj1));
42424 if (SWIG_arg_fail(2)) SWIG_fail;
42425 }
42426 }
42427 {
42428 PyThreadState* __tstate = wxPyBeginAllowThreads();
42429 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42430
42431 wxPyEndAllowThreads(__tstate);
42432 if (PyErr_Occurred()) SWIG_fail;
42433 }
42434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42435 return resultobj;
42436 fail:
42437 return NULL;
42438 }
42439
42440
42441 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42442 PyObject *resultobj;
42443 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42444 PyObject *arg2 = (PyObject *) 0 ;
42445 wxGBPosition *arg3 = 0 ;
42446 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42447 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42448 int arg5 = (int) 0 ;
42449 int arg6 = (int) 0 ;
42450 PyObject *arg7 = (PyObject *) NULL ;
42451 wxGBSizerItem *result;
42452 wxGBPosition temp3 ;
42453 wxGBSpan temp4 ;
42454 PyObject * obj0 = 0 ;
42455 PyObject * obj1 = 0 ;
42456 PyObject * obj2 = 0 ;
42457 PyObject * obj3 = 0 ;
42458 PyObject * obj4 = 0 ;
42459 PyObject * obj5 = 0 ;
42460 PyObject * obj6 = 0 ;
42461 char *kwnames[] = {
42462 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42463 };
42464
42465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42467 if (SWIG_arg_fail(1)) SWIG_fail;
42468 arg2 = obj1;
42469 {
42470 arg3 = &temp3;
42471 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42472 }
42473 if (obj3) {
42474 {
42475 arg4 = &temp4;
42476 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42477 }
42478 }
42479 if (obj4) {
42480 {
42481 arg5 = (int)(SWIG_As_int(obj4));
42482 if (SWIG_arg_fail(5)) SWIG_fail;
42483 }
42484 }
42485 if (obj5) {
42486 {
42487 arg6 = (int)(SWIG_As_int(obj5));
42488 if (SWIG_arg_fail(6)) SWIG_fail;
42489 }
42490 }
42491 if (obj6) {
42492 arg7 = obj6;
42493 }
42494 {
42495 PyThreadState* __tstate = wxPyBeginAllowThreads();
42496 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42497
42498 wxPyEndAllowThreads(__tstate);
42499 if (PyErr_Occurred()) SWIG_fail;
42500 }
42501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42502 return resultobj;
42503 fail:
42504 return NULL;
42505 }
42506
42507
42508 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42509 PyObject *resultobj;
42510 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42511 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42512 wxGBSizerItem *result;
42513 PyObject * obj0 = 0 ;
42514 PyObject * obj1 = 0 ;
42515 char *kwnames[] = {
42516 (char *) "self",(char *) "item", NULL
42517 };
42518
42519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42521 if (SWIG_arg_fail(1)) SWIG_fail;
42522 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42523 if (SWIG_arg_fail(2)) SWIG_fail;
42524 {
42525 PyThreadState* __tstate = wxPyBeginAllowThreads();
42526 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42527
42528 wxPyEndAllowThreads(__tstate);
42529 if (PyErr_Occurred()) SWIG_fail;
42530 }
42531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42532 return resultobj;
42533 fail:
42534 return NULL;
42535 }
42536
42537
42538 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42539 PyObject *resultobj;
42540 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42541 int arg2 ;
42542 int arg3 ;
42543 wxSize result;
42544 PyObject * obj0 = 0 ;
42545 PyObject * obj1 = 0 ;
42546 PyObject * obj2 = 0 ;
42547 char *kwnames[] = {
42548 (char *) "self",(char *) "row",(char *) "col", NULL
42549 };
42550
42551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42553 if (SWIG_arg_fail(1)) SWIG_fail;
42554 {
42555 arg2 = (int)(SWIG_As_int(obj1));
42556 if (SWIG_arg_fail(2)) SWIG_fail;
42557 }
42558 {
42559 arg3 = (int)(SWIG_As_int(obj2));
42560 if (SWIG_arg_fail(3)) SWIG_fail;
42561 }
42562 {
42563 PyThreadState* __tstate = wxPyBeginAllowThreads();
42564 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42565
42566 wxPyEndAllowThreads(__tstate);
42567 if (PyErr_Occurred()) SWIG_fail;
42568 }
42569 {
42570 wxSize * resultptr;
42571 resultptr = new wxSize((wxSize &)(result));
42572 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42573 }
42574 return resultobj;
42575 fail:
42576 return NULL;
42577 }
42578
42579
42580 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42581 PyObject *resultobj;
42582 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42583 wxSize result;
42584 PyObject * obj0 = 0 ;
42585 char *kwnames[] = {
42586 (char *) "self", NULL
42587 };
42588
42589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42591 if (SWIG_arg_fail(1)) SWIG_fail;
42592 {
42593 PyThreadState* __tstate = wxPyBeginAllowThreads();
42594 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42595
42596 wxPyEndAllowThreads(__tstate);
42597 if (PyErr_Occurred()) SWIG_fail;
42598 }
42599 {
42600 wxSize * resultptr;
42601 resultptr = new wxSize((wxSize &)(result));
42602 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42603 }
42604 return resultobj;
42605 fail:
42606 return NULL;
42607 }
42608
42609
42610 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42611 PyObject *resultobj;
42612 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42613 wxSize *arg2 = 0 ;
42614 wxSize temp2 ;
42615 PyObject * obj0 = 0 ;
42616 PyObject * obj1 = 0 ;
42617 char *kwnames[] = {
42618 (char *) "self",(char *) "sz", NULL
42619 };
42620
42621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42623 if (SWIG_arg_fail(1)) SWIG_fail;
42624 {
42625 arg2 = &temp2;
42626 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42627 }
42628 {
42629 PyThreadState* __tstate = wxPyBeginAllowThreads();
42630 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42631
42632 wxPyEndAllowThreads(__tstate);
42633 if (PyErr_Occurred()) SWIG_fail;
42634 }
42635 Py_INCREF(Py_None); resultobj = Py_None;
42636 return resultobj;
42637 fail:
42638 return NULL;
42639 }
42640
42641
42642 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42643 PyObject *resultobj;
42644 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42645 wxWindow *arg2 = (wxWindow *) 0 ;
42646 wxGBPosition result;
42647 PyObject * obj0 = 0 ;
42648 PyObject * obj1 = 0 ;
42649
42650 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42652 if (SWIG_arg_fail(1)) SWIG_fail;
42653 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42654 if (SWIG_arg_fail(2)) SWIG_fail;
42655 {
42656 PyThreadState* __tstate = wxPyBeginAllowThreads();
42657 result = (arg1)->GetItemPosition(arg2);
42658
42659 wxPyEndAllowThreads(__tstate);
42660 if (PyErr_Occurred()) SWIG_fail;
42661 }
42662 {
42663 wxGBPosition * resultptr;
42664 resultptr = new wxGBPosition((wxGBPosition &)(result));
42665 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42666 }
42667 return resultobj;
42668 fail:
42669 return NULL;
42670 }
42671
42672
42673 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42674 PyObject *resultobj;
42675 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42676 wxSizer *arg2 = (wxSizer *) 0 ;
42677 wxGBPosition result;
42678 PyObject * obj0 = 0 ;
42679 PyObject * obj1 = 0 ;
42680
42681 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42683 if (SWIG_arg_fail(1)) SWIG_fail;
42684 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42685 if (SWIG_arg_fail(2)) SWIG_fail;
42686 {
42687 PyThreadState* __tstate = wxPyBeginAllowThreads();
42688 result = (arg1)->GetItemPosition(arg2);
42689
42690 wxPyEndAllowThreads(__tstate);
42691 if (PyErr_Occurred()) SWIG_fail;
42692 }
42693 {
42694 wxGBPosition * resultptr;
42695 resultptr = new wxGBPosition((wxGBPosition &)(result));
42696 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42697 }
42698 return resultobj;
42699 fail:
42700 return NULL;
42701 }
42702
42703
42704 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42705 PyObject *resultobj;
42706 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42707 size_t arg2 ;
42708 wxGBPosition result;
42709 PyObject * obj0 = 0 ;
42710 PyObject * obj1 = 0 ;
42711
42712 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42714 if (SWIG_arg_fail(1)) SWIG_fail;
42715 {
42716 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42717 if (SWIG_arg_fail(2)) SWIG_fail;
42718 }
42719 {
42720 PyThreadState* __tstate = wxPyBeginAllowThreads();
42721 result = (arg1)->GetItemPosition(arg2);
42722
42723 wxPyEndAllowThreads(__tstate);
42724 if (PyErr_Occurred()) SWIG_fail;
42725 }
42726 {
42727 wxGBPosition * resultptr;
42728 resultptr = new wxGBPosition((wxGBPosition &)(result));
42729 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42730 }
42731 return resultobj;
42732 fail:
42733 return NULL;
42734 }
42735
42736
42737 static PyObject *_wrap_GridBagSizer_GetItemPosition(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_GetItemPosition__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_GetItemPosition__SWIG_1(self,args);
42795 }
42796 }
42797 }
42798 if (argc == 2) {
42799 int _v;
42800 {
42801 void *ptr;
42802 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42803 _v = 0;
42804 PyErr_Clear();
42805 } else {
42806 _v = 1;
42807 }
42808 }
42809 if (_v) {
42810 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42811 if (_v) {
42812 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42813 }
42814 }
42815 }
42816
42817 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42818 return NULL;
42819 }
42820
42821
42822 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42823 PyObject *resultobj;
42824 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42825 wxWindow *arg2 = (wxWindow *) 0 ;
42826 wxGBPosition *arg3 = 0 ;
42827 bool result;
42828 wxGBPosition temp3 ;
42829 PyObject * obj0 = 0 ;
42830 PyObject * obj1 = 0 ;
42831 PyObject * obj2 = 0 ;
42832
42833 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42835 if (SWIG_arg_fail(1)) SWIG_fail;
42836 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42837 if (SWIG_arg_fail(2)) SWIG_fail;
42838 {
42839 arg3 = &temp3;
42840 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42841 }
42842 {
42843 PyThreadState* __tstate = wxPyBeginAllowThreads();
42844 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42845
42846 wxPyEndAllowThreads(__tstate);
42847 if (PyErr_Occurred()) SWIG_fail;
42848 }
42849 {
42850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42851 }
42852 return resultobj;
42853 fail:
42854 return NULL;
42855 }
42856
42857
42858 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42859 PyObject *resultobj;
42860 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42861 wxSizer *arg2 = (wxSizer *) 0 ;
42862 wxGBPosition *arg3 = 0 ;
42863 bool result;
42864 wxGBPosition temp3 ;
42865 PyObject * obj0 = 0 ;
42866 PyObject * obj1 = 0 ;
42867 PyObject * obj2 = 0 ;
42868
42869 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42871 if (SWIG_arg_fail(1)) SWIG_fail;
42872 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42873 if (SWIG_arg_fail(2)) SWIG_fail;
42874 {
42875 arg3 = &temp3;
42876 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42877 }
42878 {
42879 PyThreadState* __tstate = wxPyBeginAllowThreads();
42880 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42881
42882 wxPyEndAllowThreads(__tstate);
42883 if (PyErr_Occurred()) SWIG_fail;
42884 }
42885 {
42886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42887 }
42888 return resultobj;
42889 fail:
42890 return NULL;
42891 }
42892
42893
42894 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42895 PyObject *resultobj;
42896 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42897 size_t arg2 ;
42898 wxGBPosition *arg3 = 0 ;
42899 bool result;
42900 wxGBPosition temp3 ;
42901 PyObject * obj0 = 0 ;
42902 PyObject * obj1 = 0 ;
42903 PyObject * obj2 = 0 ;
42904
42905 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42907 if (SWIG_arg_fail(1)) SWIG_fail;
42908 {
42909 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42910 if (SWIG_arg_fail(2)) SWIG_fail;
42911 }
42912 {
42913 arg3 = &temp3;
42914 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42915 }
42916 {
42917 PyThreadState* __tstate = wxPyBeginAllowThreads();
42918 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42919
42920 wxPyEndAllowThreads(__tstate);
42921 if (PyErr_Occurred()) SWIG_fail;
42922 }
42923 {
42924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42925 }
42926 return resultobj;
42927 fail:
42928 return NULL;
42929 }
42930
42931
42932 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42933 int argc;
42934 PyObject *argv[4];
42935 int ii;
42936
42937 argc = PyObject_Length(args);
42938 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42939 argv[ii] = PyTuple_GetItem(args,ii);
42940 }
42941 if (argc == 3) {
42942 int _v;
42943 {
42944 void *ptr;
42945 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42946 _v = 0;
42947 PyErr_Clear();
42948 } else {
42949 _v = 1;
42950 }
42951 }
42952 if (_v) {
42953 {
42954 void *ptr;
42955 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42956 _v = 0;
42957 PyErr_Clear();
42958 } else {
42959 _v = 1;
42960 }
42961 }
42962 if (_v) {
42963 {
42964 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42965 }
42966 if (_v) {
42967 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42968 }
42969 }
42970 }
42971 }
42972 if (argc == 3) {
42973 int _v;
42974 {
42975 void *ptr;
42976 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42977 _v = 0;
42978 PyErr_Clear();
42979 } else {
42980 _v = 1;
42981 }
42982 }
42983 if (_v) {
42984 {
42985 void *ptr;
42986 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42987 _v = 0;
42988 PyErr_Clear();
42989 } else {
42990 _v = 1;
42991 }
42992 }
42993 if (_v) {
42994 {
42995 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42996 }
42997 if (_v) {
42998 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42999 }
43000 }
43001 }
43002 }
43003 if (argc == 3) {
43004 int _v;
43005 {
43006 void *ptr;
43007 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43008 _v = 0;
43009 PyErr_Clear();
43010 } else {
43011 _v = 1;
43012 }
43013 }
43014 if (_v) {
43015 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43016 if (_v) {
43017 {
43018 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43019 }
43020 if (_v) {
43021 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43022 }
43023 }
43024 }
43025 }
43026
43027 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43028 return NULL;
43029 }
43030
43031
43032 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43033 PyObject *resultobj;
43034 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43035 wxWindow *arg2 = (wxWindow *) 0 ;
43036 wxGBSpan result;
43037 PyObject * obj0 = 0 ;
43038 PyObject * obj1 = 0 ;
43039
43040 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43042 if (SWIG_arg_fail(1)) SWIG_fail;
43043 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43044 if (SWIG_arg_fail(2)) SWIG_fail;
43045 {
43046 PyThreadState* __tstate = wxPyBeginAllowThreads();
43047 result = (arg1)->GetItemSpan(arg2);
43048
43049 wxPyEndAllowThreads(__tstate);
43050 if (PyErr_Occurred()) SWIG_fail;
43051 }
43052 {
43053 wxGBSpan * resultptr;
43054 resultptr = new wxGBSpan((wxGBSpan &)(result));
43055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43056 }
43057 return resultobj;
43058 fail:
43059 return NULL;
43060 }
43061
43062
43063 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43064 PyObject *resultobj;
43065 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43066 wxSizer *arg2 = (wxSizer *) 0 ;
43067 wxGBSpan result;
43068 PyObject * obj0 = 0 ;
43069 PyObject * obj1 = 0 ;
43070
43071 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43073 if (SWIG_arg_fail(1)) SWIG_fail;
43074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43075 if (SWIG_arg_fail(2)) SWIG_fail;
43076 {
43077 PyThreadState* __tstate = wxPyBeginAllowThreads();
43078 result = (arg1)->GetItemSpan(arg2);
43079
43080 wxPyEndAllowThreads(__tstate);
43081 if (PyErr_Occurred()) SWIG_fail;
43082 }
43083 {
43084 wxGBSpan * resultptr;
43085 resultptr = new wxGBSpan((wxGBSpan &)(result));
43086 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43087 }
43088 return resultobj;
43089 fail:
43090 return NULL;
43091 }
43092
43093
43094 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43095 PyObject *resultobj;
43096 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43097 size_t arg2 ;
43098 wxGBSpan result;
43099 PyObject * obj0 = 0 ;
43100 PyObject * obj1 = 0 ;
43101
43102 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43104 if (SWIG_arg_fail(1)) SWIG_fail;
43105 {
43106 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43107 if (SWIG_arg_fail(2)) SWIG_fail;
43108 }
43109 {
43110 PyThreadState* __tstate = wxPyBeginAllowThreads();
43111 result = (arg1)->GetItemSpan(arg2);
43112
43113 wxPyEndAllowThreads(__tstate);
43114 if (PyErr_Occurred()) SWIG_fail;
43115 }
43116 {
43117 wxGBSpan * resultptr;
43118 resultptr = new wxGBSpan((wxGBSpan &)(result));
43119 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43120 }
43121 return resultobj;
43122 fail:
43123 return NULL;
43124 }
43125
43126
43127 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43128 int argc;
43129 PyObject *argv[3];
43130 int ii;
43131
43132 argc = PyObject_Length(args);
43133 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43134 argv[ii] = PyTuple_GetItem(args,ii);
43135 }
43136 if (argc == 2) {
43137 int _v;
43138 {
43139 void *ptr;
43140 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43141 _v = 0;
43142 PyErr_Clear();
43143 } else {
43144 _v = 1;
43145 }
43146 }
43147 if (_v) {
43148 {
43149 void *ptr;
43150 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43151 _v = 0;
43152 PyErr_Clear();
43153 } else {
43154 _v = 1;
43155 }
43156 }
43157 if (_v) {
43158 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43159 }
43160 }
43161 }
43162 if (argc == 2) {
43163 int _v;
43164 {
43165 void *ptr;
43166 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43167 _v = 0;
43168 PyErr_Clear();
43169 } else {
43170 _v = 1;
43171 }
43172 }
43173 if (_v) {
43174 {
43175 void *ptr;
43176 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43177 _v = 0;
43178 PyErr_Clear();
43179 } else {
43180 _v = 1;
43181 }
43182 }
43183 if (_v) {
43184 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43185 }
43186 }
43187 }
43188 if (argc == 2) {
43189 int _v;
43190 {
43191 void *ptr;
43192 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43193 _v = 0;
43194 PyErr_Clear();
43195 } else {
43196 _v = 1;
43197 }
43198 }
43199 if (_v) {
43200 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43201 if (_v) {
43202 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43203 }
43204 }
43205 }
43206
43207 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43208 return NULL;
43209 }
43210
43211
43212 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43213 PyObject *resultobj;
43214 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43215 wxWindow *arg2 = (wxWindow *) 0 ;
43216 wxGBSpan *arg3 = 0 ;
43217 bool result;
43218 wxGBSpan temp3 ;
43219 PyObject * obj0 = 0 ;
43220 PyObject * obj1 = 0 ;
43221 PyObject * obj2 = 0 ;
43222
43223 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43225 if (SWIG_arg_fail(1)) SWIG_fail;
43226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43227 if (SWIG_arg_fail(2)) SWIG_fail;
43228 {
43229 arg3 = &temp3;
43230 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43231 }
43232 {
43233 PyThreadState* __tstate = wxPyBeginAllowThreads();
43234 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43235
43236 wxPyEndAllowThreads(__tstate);
43237 if (PyErr_Occurred()) SWIG_fail;
43238 }
43239 {
43240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43241 }
43242 return resultobj;
43243 fail:
43244 return NULL;
43245 }
43246
43247
43248 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43249 PyObject *resultobj;
43250 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43251 wxSizer *arg2 = (wxSizer *) 0 ;
43252 wxGBSpan *arg3 = 0 ;
43253 bool result;
43254 wxGBSpan temp3 ;
43255 PyObject * obj0 = 0 ;
43256 PyObject * obj1 = 0 ;
43257 PyObject * obj2 = 0 ;
43258
43259 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43261 if (SWIG_arg_fail(1)) SWIG_fail;
43262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43263 if (SWIG_arg_fail(2)) SWIG_fail;
43264 {
43265 arg3 = &temp3;
43266 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43267 }
43268 {
43269 PyThreadState* __tstate = wxPyBeginAllowThreads();
43270 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43271
43272 wxPyEndAllowThreads(__tstate);
43273 if (PyErr_Occurred()) SWIG_fail;
43274 }
43275 {
43276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43277 }
43278 return resultobj;
43279 fail:
43280 return NULL;
43281 }
43282
43283
43284 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43285 PyObject *resultobj;
43286 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43287 size_t arg2 ;
43288 wxGBSpan *arg3 = 0 ;
43289 bool result;
43290 wxGBSpan temp3 ;
43291 PyObject * obj0 = 0 ;
43292 PyObject * obj1 = 0 ;
43293 PyObject * obj2 = 0 ;
43294
43295 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43297 if (SWIG_arg_fail(1)) SWIG_fail;
43298 {
43299 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43300 if (SWIG_arg_fail(2)) SWIG_fail;
43301 }
43302 {
43303 arg3 = &temp3;
43304 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43305 }
43306 {
43307 PyThreadState* __tstate = wxPyBeginAllowThreads();
43308 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43309
43310 wxPyEndAllowThreads(__tstate);
43311 if (PyErr_Occurred()) SWIG_fail;
43312 }
43313 {
43314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43315 }
43316 return resultobj;
43317 fail:
43318 return NULL;
43319 }
43320
43321
43322 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43323 int argc;
43324 PyObject *argv[4];
43325 int ii;
43326
43327 argc = PyObject_Length(args);
43328 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43329 argv[ii] = PyTuple_GetItem(args,ii);
43330 }
43331 if (argc == 3) {
43332 int _v;
43333 {
43334 void *ptr;
43335 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43336 _v = 0;
43337 PyErr_Clear();
43338 } else {
43339 _v = 1;
43340 }
43341 }
43342 if (_v) {
43343 {
43344 void *ptr;
43345 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43346 _v = 0;
43347 PyErr_Clear();
43348 } else {
43349 _v = 1;
43350 }
43351 }
43352 if (_v) {
43353 {
43354 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43355 }
43356 if (_v) {
43357 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43358 }
43359 }
43360 }
43361 }
43362 if (argc == 3) {
43363 int _v;
43364 {
43365 void *ptr;
43366 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43367 _v = 0;
43368 PyErr_Clear();
43369 } else {
43370 _v = 1;
43371 }
43372 }
43373 if (_v) {
43374 {
43375 void *ptr;
43376 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43377 _v = 0;
43378 PyErr_Clear();
43379 } else {
43380 _v = 1;
43381 }
43382 }
43383 if (_v) {
43384 {
43385 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43386 }
43387 if (_v) {
43388 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43389 }
43390 }
43391 }
43392 }
43393 if (argc == 3) {
43394 int _v;
43395 {
43396 void *ptr;
43397 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43398 _v = 0;
43399 PyErr_Clear();
43400 } else {
43401 _v = 1;
43402 }
43403 }
43404 if (_v) {
43405 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43406 if (_v) {
43407 {
43408 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43409 }
43410 if (_v) {
43411 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43412 }
43413 }
43414 }
43415 }
43416
43417 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43418 return NULL;
43419 }
43420
43421
43422 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43423 PyObject *resultobj;
43424 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43425 wxWindow *arg2 = (wxWindow *) 0 ;
43426 wxGBSizerItem *result;
43427 PyObject * obj0 = 0 ;
43428 PyObject * obj1 = 0 ;
43429
43430 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43432 if (SWIG_arg_fail(1)) SWIG_fail;
43433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43434 if (SWIG_arg_fail(2)) SWIG_fail;
43435 {
43436 PyThreadState* __tstate = wxPyBeginAllowThreads();
43437 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43438
43439 wxPyEndAllowThreads(__tstate);
43440 if (PyErr_Occurred()) SWIG_fail;
43441 }
43442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43443 return resultobj;
43444 fail:
43445 return NULL;
43446 }
43447
43448
43449 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43450 PyObject *resultobj;
43451 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43452 wxSizer *arg2 = (wxSizer *) 0 ;
43453 wxGBSizerItem *result;
43454 PyObject * obj0 = 0 ;
43455 PyObject * obj1 = 0 ;
43456
43457 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43459 if (SWIG_arg_fail(1)) SWIG_fail;
43460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43461 if (SWIG_arg_fail(2)) SWIG_fail;
43462 {
43463 PyThreadState* __tstate = wxPyBeginAllowThreads();
43464 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43465
43466 wxPyEndAllowThreads(__tstate);
43467 if (PyErr_Occurred()) SWIG_fail;
43468 }
43469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43470 return resultobj;
43471 fail:
43472 return NULL;
43473 }
43474
43475
43476 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43477 int argc;
43478 PyObject *argv[3];
43479 int ii;
43480
43481 argc = PyObject_Length(args);
43482 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43483 argv[ii] = PyTuple_GetItem(args,ii);
43484 }
43485 if (argc == 2) {
43486 int _v;
43487 {
43488 void *ptr;
43489 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43490 _v = 0;
43491 PyErr_Clear();
43492 } else {
43493 _v = 1;
43494 }
43495 }
43496 if (_v) {
43497 {
43498 void *ptr;
43499 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43500 _v = 0;
43501 PyErr_Clear();
43502 } else {
43503 _v = 1;
43504 }
43505 }
43506 if (_v) {
43507 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43508 }
43509 }
43510 }
43511 if (argc == 2) {
43512 int _v;
43513 {
43514 void *ptr;
43515 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43516 _v = 0;
43517 PyErr_Clear();
43518 } else {
43519 _v = 1;
43520 }
43521 }
43522 if (_v) {
43523 {
43524 void *ptr;
43525 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43526 _v = 0;
43527 PyErr_Clear();
43528 } else {
43529 _v = 1;
43530 }
43531 }
43532 if (_v) {
43533 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43534 }
43535 }
43536 }
43537
43538 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43539 return NULL;
43540 }
43541
43542
43543 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43544 PyObject *resultobj;
43545 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43546 wxGBPosition *arg2 = 0 ;
43547 wxGBSizerItem *result;
43548 wxGBPosition temp2 ;
43549 PyObject * obj0 = 0 ;
43550 PyObject * obj1 = 0 ;
43551 char *kwnames[] = {
43552 (char *) "self",(char *) "pos", NULL
43553 };
43554
43555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43557 if (SWIG_arg_fail(1)) SWIG_fail;
43558 {
43559 arg2 = &temp2;
43560 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43561 }
43562 {
43563 PyThreadState* __tstate = wxPyBeginAllowThreads();
43564 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43565
43566 wxPyEndAllowThreads(__tstate);
43567 if (PyErr_Occurred()) SWIG_fail;
43568 }
43569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43570 return resultobj;
43571 fail:
43572 return NULL;
43573 }
43574
43575
43576 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43577 PyObject *resultobj;
43578 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43579 wxPoint *arg2 = 0 ;
43580 wxGBSizerItem *result;
43581 wxPoint temp2 ;
43582 PyObject * obj0 = 0 ;
43583 PyObject * obj1 = 0 ;
43584 char *kwnames[] = {
43585 (char *) "self",(char *) "pt", NULL
43586 };
43587
43588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43590 if (SWIG_arg_fail(1)) SWIG_fail;
43591 {
43592 arg2 = &temp2;
43593 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43594 }
43595 {
43596 PyThreadState* __tstate = wxPyBeginAllowThreads();
43597 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43598
43599 wxPyEndAllowThreads(__tstate);
43600 if (PyErr_Occurred()) SWIG_fail;
43601 }
43602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43603 return resultobj;
43604 fail:
43605 return NULL;
43606 }
43607
43608
43609 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43610 PyObject *resultobj;
43611 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43612 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43613 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43614 bool result;
43615 PyObject * obj0 = 0 ;
43616 PyObject * obj1 = 0 ;
43617 PyObject * obj2 = 0 ;
43618 char *kwnames[] = {
43619 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43620 };
43621
43622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43624 if (SWIG_arg_fail(1)) SWIG_fail;
43625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43626 if (SWIG_arg_fail(2)) SWIG_fail;
43627 if (obj2) {
43628 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43629 if (SWIG_arg_fail(3)) SWIG_fail;
43630 }
43631 {
43632 PyThreadState* __tstate = wxPyBeginAllowThreads();
43633 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43634
43635 wxPyEndAllowThreads(__tstate);
43636 if (PyErr_Occurred()) SWIG_fail;
43637 }
43638 {
43639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43640 }
43641 return resultobj;
43642 fail:
43643 return NULL;
43644 }
43645
43646
43647 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43648 PyObject *resultobj;
43649 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43650 wxGBPosition *arg2 = 0 ;
43651 wxGBSpan *arg3 = 0 ;
43652 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43653 bool result;
43654 wxGBPosition temp2 ;
43655 wxGBSpan temp3 ;
43656 PyObject * obj0 = 0 ;
43657 PyObject * obj1 = 0 ;
43658 PyObject * obj2 = 0 ;
43659 PyObject * obj3 = 0 ;
43660 char *kwnames[] = {
43661 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43662 };
43663
43664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43666 if (SWIG_arg_fail(1)) SWIG_fail;
43667 {
43668 arg2 = &temp2;
43669 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43670 }
43671 {
43672 arg3 = &temp3;
43673 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43674 }
43675 if (obj3) {
43676 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43677 if (SWIG_arg_fail(4)) SWIG_fail;
43678 }
43679 {
43680 PyThreadState* __tstate = wxPyBeginAllowThreads();
43681 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43682
43683 wxPyEndAllowThreads(__tstate);
43684 if (PyErr_Occurred()) SWIG_fail;
43685 }
43686 {
43687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43688 }
43689 return resultobj;
43690 fail:
43691 return NULL;
43692 }
43693
43694
43695 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43696 PyObject *obj;
43697 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43698 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43699 Py_INCREF(obj);
43700 return Py_BuildValue((char *)"");
43701 }
43702 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43703 PyObject *resultobj;
43704 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43705 wxRelationship arg2 ;
43706 wxWindow *arg3 = (wxWindow *) 0 ;
43707 wxEdge arg4 ;
43708 int arg5 = (int) 0 ;
43709 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43710 PyObject * obj0 = 0 ;
43711 PyObject * obj1 = 0 ;
43712 PyObject * obj2 = 0 ;
43713 PyObject * obj3 = 0 ;
43714 PyObject * obj4 = 0 ;
43715 PyObject * obj5 = 0 ;
43716 char *kwnames[] = {
43717 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43718 };
43719
43720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43722 if (SWIG_arg_fail(1)) SWIG_fail;
43723 {
43724 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43725 if (SWIG_arg_fail(2)) SWIG_fail;
43726 }
43727 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43728 if (SWIG_arg_fail(3)) SWIG_fail;
43729 {
43730 arg4 = (wxEdge)(SWIG_As_int(obj3));
43731 if (SWIG_arg_fail(4)) SWIG_fail;
43732 }
43733 if (obj4) {
43734 {
43735 arg5 = (int)(SWIG_As_int(obj4));
43736 if (SWIG_arg_fail(5)) SWIG_fail;
43737 }
43738 }
43739 if (obj5) {
43740 {
43741 arg6 = (int)(SWIG_As_int(obj5));
43742 if (SWIG_arg_fail(6)) SWIG_fail;
43743 }
43744 }
43745 {
43746 PyThreadState* __tstate = wxPyBeginAllowThreads();
43747 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43748
43749 wxPyEndAllowThreads(__tstate);
43750 if (PyErr_Occurred()) SWIG_fail;
43751 }
43752 Py_INCREF(Py_None); resultobj = Py_None;
43753 return resultobj;
43754 fail:
43755 return NULL;
43756 }
43757
43758
43759 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43760 PyObject *resultobj;
43761 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43762 wxWindow *arg2 = (wxWindow *) 0 ;
43763 int arg3 = (int) 0 ;
43764 PyObject * obj0 = 0 ;
43765 PyObject * obj1 = 0 ;
43766 PyObject * obj2 = 0 ;
43767 char *kwnames[] = {
43768 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43769 };
43770
43771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43773 if (SWIG_arg_fail(1)) SWIG_fail;
43774 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43775 if (SWIG_arg_fail(2)) SWIG_fail;
43776 if (obj2) {
43777 {
43778 arg3 = (int)(SWIG_As_int(obj2));
43779 if (SWIG_arg_fail(3)) SWIG_fail;
43780 }
43781 }
43782 {
43783 PyThreadState* __tstate = wxPyBeginAllowThreads();
43784 (arg1)->LeftOf(arg2,arg3);
43785
43786 wxPyEndAllowThreads(__tstate);
43787 if (PyErr_Occurred()) SWIG_fail;
43788 }
43789 Py_INCREF(Py_None); resultobj = Py_None;
43790 return resultobj;
43791 fail:
43792 return NULL;
43793 }
43794
43795
43796 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43797 PyObject *resultobj;
43798 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43799 wxWindow *arg2 = (wxWindow *) 0 ;
43800 int arg3 = (int) 0 ;
43801 PyObject * obj0 = 0 ;
43802 PyObject * obj1 = 0 ;
43803 PyObject * obj2 = 0 ;
43804 char *kwnames[] = {
43805 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43806 };
43807
43808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43810 if (SWIG_arg_fail(1)) SWIG_fail;
43811 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43812 if (SWIG_arg_fail(2)) SWIG_fail;
43813 if (obj2) {
43814 {
43815 arg3 = (int)(SWIG_As_int(obj2));
43816 if (SWIG_arg_fail(3)) SWIG_fail;
43817 }
43818 }
43819 {
43820 PyThreadState* __tstate = wxPyBeginAllowThreads();
43821 (arg1)->RightOf(arg2,arg3);
43822
43823 wxPyEndAllowThreads(__tstate);
43824 if (PyErr_Occurred()) SWIG_fail;
43825 }
43826 Py_INCREF(Py_None); resultobj = Py_None;
43827 return resultobj;
43828 fail:
43829 return NULL;
43830 }
43831
43832
43833 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43834 PyObject *resultobj;
43835 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43836 wxWindow *arg2 = (wxWindow *) 0 ;
43837 int arg3 = (int) 0 ;
43838 PyObject * obj0 = 0 ;
43839 PyObject * obj1 = 0 ;
43840 PyObject * obj2 = 0 ;
43841 char *kwnames[] = {
43842 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43843 };
43844
43845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43847 if (SWIG_arg_fail(1)) SWIG_fail;
43848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43849 if (SWIG_arg_fail(2)) SWIG_fail;
43850 if (obj2) {
43851 {
43852 arg3 = (int)(SWIG_As_int(obj2));
43853 if (SWIG_arg_fail(3)) SWIG_fail;
43854 }
43855 }
43856 {
43857 PyThreadState* __tstate = wxPyBeginAllowThreads();
43858 (arg1)->Above(arg2,arg3);
43859
43860 wxPyEndAllowThreads(__tstate);
43861 if (PyErr_Occurred()) SWIG_fail;
43862 }
43863 Py_INCREF(Py_None); resultobj = Py_None;
43864 return resultobj;
43865 fail:
43866 return NULL;
43867 }
43868
43869
43870 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43871 PyObject *resultobj;
43872 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43873 wxWindow *arg2 = (wxWindow *) 0 ;
43874 int arg3 = (int) 0 ;
43875 PyObject * obj0 = 0 ;
43876 PyObject * obj1 = 0 ;
43877 PyObject * obj2 = 0 ;
43878 char *kwnames[] = {
43879 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43880 };
43881
43882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43884 if (SWIG_arg_fail(1)) SWIG_fail;
43885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43886 if (SWIG_arg_fail(2)) SWIG_fail;
43887 if (obj2) {
43888 {
43889 arg3 = (int)(SWIG_As_int(obj2));
43890 if (SWIG_arg_fail(3)) SWIG_fail;
43891 }
43892 }
43893 {
43894 PyThreadState* __tstate = wxPyBeginAllowThreads();
43895 (arg1)->Below(arg2,arg3);
43896
43897 wxPyEndAllowThreads(__tstate);
43898 if (PyErr_Occurred()) SWIG_fail;
43899 }
43900 Py_INCREF(Py_None); resultobj = Py_None;
43901 return resultobj;
43902 fail:
43903 return NULL;
43904 }
43905
43906
43907 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43908 PyObject *resultobj;
43909 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43910 wxWindow *arg2 = (wxWindow *) 0 ;
43911 wxEdge arg3 ;
43912 int arg4 = (int) 0 ;
43913 PyObject * obj0 = 0 ;
43914 PyObject * obj1 = 0 ;
43915 PyObject * obj2 = 0 ;
43916 PyObject * obj3 = 0 ;
43917 char *kwnames[] = {
43918 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43919 };
43920
43921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43923 if (SWIG_arg_fail(1)) SWIG_fail;
43924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43925 if (SWIG_arg_fail(2)) SWIG_fail;
43926 {
43927 arg3 = (wxEdge)(SWIG_As_int(obj2));
43928 if (SWIG_arg_fail(3)) SWIG_fail;
43929 }
43930 if (obj3) {
43931 {
43932 arg4 = (int)(SWIG_As_int(obj3));
43933 if (SWIG_arg_fail(4)) SWIG_fail;
43934 }
43935 }
43936 {
43937 PyThreadState* __tstate = wxPyBeginAllowThreads();
43938 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43939
43940 wxPyEndAllowThreads(__tstate);
43941 if (PyErr_Occurred()) SWIG_fail;
43942 }
43943 Py_INCREF(Py_None); resultobj = Py_None;
43944 return resultobj;
43945 fail:
43946 return NULL;
43947 }
43948
43949
43950 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43951 PyObject *resultobj;
43952 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43953 wxWindow *arg2 = (wxWindow *) 0 ;
43954 wxEdge arg3 ;
43955 int arg4 ;
43956 PyObject * obj0 = 0 ;
43957 PyObject * obj1 = 0 ;
43958 PyObject * obj2 = 0 ;
43959 PyObject * obj3 = 0 ;
43960 char *kwnames[] = {
43961 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43962 };
43963
43964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43966 if (SWIG_arg_fail(1)) SWIG_fail;
43967 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43968 if (SWIG_arg_fail(2)) SWIG_fail;
43969 {
43970 arg3 = (wxEdge)(SWIG_As_int(obj2));
43971 if (SWIG_arg_fail(3)) SWIG_fail;
43972 }
43973 {
43974 arg4 = (int)(SWIG_As_int(obj3));
43975 if (SWIG_arg_fail(4)) SWIG_fail;
43976 }
43977 {
43978 PyThreadState* __tstate = wxPyBeginAllowThreads();
43979 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43980
43981 wxPyEndAllowThreads(__tstate);
43982 if (PyErr_Occurred()) SWIG_fail;
43983 }
43984 Py_INCREF(Py_None); resultobj = Py_None;
43985 return resultobj;
43986 fail:
43987 return NULL;
43988 }
43989
43990
43991 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43992 PyObject *resultobj;
43993 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43994 int arg2 ;
43995 PyObject * obj0 = 0 ;
43996 PyObject * obj1 = 0 ;
43997 char *kwnames[] = {
43998 (char *) "self",(char *) "val", NULL
43999 };
44000
44001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44003 if (SWIG_arg_fail(1)) SWIG_fail;
44004 {
44005 arg2 = (int)(SWIG_As_int(obj1));
44006 if (SWIG_arg_fail(2)) SWIG_fail;
44007 }
44008 {
44009 PyThreadState* __tstate = wxPyBeginAllowThreads();
44010 (arg1)->Absolute(arg2);
44011
44012 wxPyEndAllowThreads(__tstate);
44013 if (PyErr_Occurred()) SWIG_fail;
44014 }
44015 Py_INCREF(Py_None); resultobj = Py_None;
44016 return resultobj;
44017 fail:
44018 return NULL;
44019 }
44020
44021
44022 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44023 PyObject *resultobj;
44024 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44025 PyObject * obj0 = 0 ;
44026 char *kwnames[] = {
44027 (char *) "self", NULL
44028 };
44029
44030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44032 if (SWIG_arg_fail(1)) SWIG_fail;
44033 {
44034 PyThreadState* __tstate = wxPyBeginAllowThreads();
44035 (arg1)->Unconstrained();
44036
44037 wxPyEndAllowThreads(__tstate);
44038 if (PyErr_Occurred()) SWIG_fail;
44039 }
44040 Py_INCREF(Py_None); resultobj = Py_None;
44041 return resultobj;
44042 fail:
44043 return NULL;
44044 }
44045
44046
44047 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44048 PyObject *resultobj;
44049 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44050 PyObject * obj0 = 0 ;
44051 char *kwnames[] = {
44052 (char *) "self", NULL
44053 };
44054
44055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44057 if (SWIG_arg_fail(1)) SWIG_fail;
44058 {
44059 PyThreadState* __tstate = wxPyBeginAllowThreads();
44060 (arg1)->AsIs();
44061
44062 wxPyEndAllowThreads(__tstate);
44063 if (PyErr_Occurred()) SWIG_fail;
44064 }
44065 Py_INCREF(Py_None); resultobj = Py_None;
44066 return resultobj;
44067 fail:
44068 return NULL;
44069 }
44070
44071
44072 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44073 PyObject *resultobj;
44074 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44075 wxWindow *result;
44076 PyObject * obj0 = 0 ;
44077 char *kwnames[] = {
44078 (char *) "self", NULL
44079 };
44080
44081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44083 if (SWIG_arg_fail(1)) SWIG_fail;
44084 {
44085 PyThreadState* __tstate = wxPyBeginAllowThreads();
44086 result = (wxWindow *)(arg1)->GetOtherWindow();
44087
44088 wxPyEndAllowThreads(__tstate);
44089 if (PyErr_Occurred()) SWIG_fail;
44090 }
44091 {
44092 resultobj = wxPyMake_wxObject(result, 0);
44093 }
44094 return resultobj;
44095 fail:
44096 return NULL;
44097 }
44098
44099
44100 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44101 PyObject *resultobj;
44102 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44103 wxEdge result;
44104 PyObject * obj0 = 0 ;
44105 char *kwnames[] = {
44106 (char *) "self", NULL
44107 };
44108
44109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44111 if (SWIG_arg_fail(1)) SWIG_fail;
44112 {
44113 PyThreadState* __tstate = wxPyBeginAllowThreads();
44114 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44115
44116 wxPyEndAllowThreads(__tstate);
44117 if (PyErr_Occurred()) SWIG_fail;
44118 }
44119 resultobj = SWIG_From_int((result));
44120 return resultobj;
44121 fail:
44122 return NULL;
44123 }
44124
44125
44126 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44127 PyObject *resultobj;
44128 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44129 wxEdge arg2 ;
44130 PyObject * obj0 = 0 ;
44131 PyObject * obj1 = 0 ;
44132 char *kwnames[] = {
44133 (char *) "self",(char *) "which", NULL
44134 };
44135
44136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44138 if (SWIG_arg_fail(1)) SWIG_fail;
44139 {
44140 arg2 = (wxEdge)(SWIG_As_int(obj1));
44141 if (SWIG_arg_fail(2)) SWIG_fail;
44142 }
44143 {
44144 PyThreadState* __tstate = wxPyBeginAllowThreads();
44145 (arg1)->SetEdge((wxEdge )arg2);
44146
44147 wxPyEndAllowThreads(__tstate);
44148 if (PyErr_Occurred()) SWIG_fail;
44149 }
44150 Py_INCREF(Py_None); resultobj = Py_None;
44151 return resultobj;
44152 fail:
44153 return NULL;
44154 }
44155
44156
44157 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44158 PyObject *resultobj;
44159 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44160 int arg2 ;
44161 PyObject * obj0 = 0 ;
44162 PyObject * obj1 = 0 ;
44163 char *kwnames[] = {
44164 (char *) "self",(char *) "v", NULL
44165 };
44166
44167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44169 if (SWIG_arg_fail(1)) SWIG_fail;
44170 {
44171 arg2 = (int)(SWIG_As_int(obj1));
44172 if (SWIG_arg_fail(2)) SWIG_fail;
44173 }
44174 {
44175 PyThreadState* __tstate = wxPyBeginAllowThreads();
44176 (arg1)->SetValue(arg2);
44177
44178 wxPyEndAllowThreads(__tstate);
44179 if (PyErr_Occurred()) SWIG_fail;
44180 }
44181 Py_INCREF(Py_None); resultobj = Py_None;
44182 return resultobj;
44183 fail:
44184 return NULL;
44185 }
44186
44187
44188 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44189 PyObject *resultobj;
44190 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44191 int result;
44192 PyObject * obj0 = 0 ;
44193 char *kwnames[] = {
44194 (char *) "self", NULL
44195 };
44196
44197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44199 if (SWIG_arg_fail(1)) SWIG_fail;
44200 {
44201 PyThreadState* __tstate = wxPyBeginAllowThreads();
44202 result = (int)(arg1)->GetMargin();
44203
44204 wxPyEndAllowThreads(__tstate);
44205 if (PyErr_Occurred()) SWIG_fail;
44206 }
44207 {
44208 resultobj = SWIG_From_int((int)(result));
44209 }
44210 return resultobj;
44211 fail:
44212 return NULL;
44213 }
44214
44215
44216 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44217 PyObject *resultobj;
44218 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44219 int arg2 ;
44220 PyObject * obj0 = 0 ;
44221 PyObject * obj1 = 0 ;
44222 char *kwnames[] = {
44223 (char *) "self",(char *) "m", NULL
44224 };
44225
44226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44228 if (SWIG_arg_fail(1)) SWIG_fail;
44229 {
44230 arg2 = (int)(SWIG_As_int(obj1));
44231 if (SWIG_arg_fail(2)) SWIG_fail;
44232 }
44233 {
44234 PyThreadState* __tstate = wxPyBeginAllowThreads();
44235 (arg1)->SetMargin(arg2);
44236
44237 wxPyEndAllowThreads(__tstate);
44238 if (PyErr_Occurred()) SWIG_fail;
44239 }
44240 Py_INCREF(Py_None); resultobj = Py_None;
44241 return resultobj;
44242 fail:
44243 return NULL;
44244 }
44245
44246
44247 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44248 PyObject *resultobj;
44249 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44250 int result;
44251 PyObject * obj0 = 0 ;
44252 char *kwnames[] = {
44253 (char *) "self", NULL
44254 };
44255
44256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44258 if (SWIG_arg_fail(1)) SWIG_fail;
44259 {
44260 PyThreadState* __tstate = wxPyBeginAllowThreads();
44261 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44262
44263 wxPyEndAllowThreads(__tstate);
44264 if (PyErr_Occurred()) SWIG_fail;
44265 }
44266 {
44267 resultobj = SWIG_From_int((int)(result));
44268 }
44269 return resultobj;
44270 fail:
44271 return NULL;
44272 }
44273
44274
44275 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44276 PyObject *resultobj;
44277 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44278 int result;
44279 PyObject * obj0 = 0 ;
44280 char *kwnames[] = {
44281 (char *) "self", NULL
44282 };
44283
44284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44286 if (SWIG_arg_fail(1)) SWIG_fail;
44287 {
44288 PyThreadState* __tstate = wxPyBeginAllowThreads();
44289 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44290
44291 wxPyEndAllowThreads(__tstate);
44292 if (PyErr_Occurred()) SWIG_fail;
44293 }
44294 {
44295 resultobj = SWIG_From_int((int)(result));
44296 }
44297 return resultobj;
44298 fail:
44299 return NULL;
44300 }
44301
44302
44303 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44304 PyObject *resultobj;
44305 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44306 int result;
44307 PyObject * obj0 = 0 ;
44308 char *kwnames[] = {
44309 (char *) "self", NULL
44310 };
44311
44312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44314 if (SWIG_arg_fail(1)) SWIG_fail;
44315 {
44316 PyThreadState* __tstate = wxPyBeginAllowThreads();
44317 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44318
44319 wxPyEndAllowThreads(__tstate);
44320 if (PyErr_Occurred()) SWIG_fail;
44321 }
44322 {
44323 resultobj = SWIG_From_int((int)(result));
44324 }
44325 return resultobj;
44326 fail:
44327 return NULL;
44328 }
44329
44330
44331 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44332 PyObject *resultobj;
44333 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44334 bool result;
44335 PyObject * obj0 = 0 ;
44336 char *kwnames[] = {
44337 (char *) "self", NULL
44338 };
44339
44340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44342 if (SWIG_arg_fail(1)) SWIG_fail;
44343 {
44344 PyThreadState* __tstate = wxPyBeginAllowThreads();
44345 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44346
44347 wxPyEndAllowThreads(__tstate);
44348 if (PyErr_Occurred()) SWIG_fail;
44349 }
44350 {
44351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44352 }
44353 return resultobj;
44354 fail:
44355 return NULL;
44356 }
44357
44358
44359 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44360 PyObject *resultobj;
44361 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44362 bool arg2 ;
44363 PyObject * obj0 = 0 ;
44364 PyObject * obj1 = 0 ;
44365 char *kwnames[] = {
44366 (char *) "self",(char *) "d", NULL
44367 };
44368
44369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44371 if (SWIG_arg_fail(1)) SWIG_fail;
44372 {
44373 arg2 = (bool)(SWIG_As_bool(obj1));
44374 if (SWIG_arg_fail(2)) SWIG_fail;
44375 }
44376 {
44377 PyThreadState* __tstate = wxPyBeginAllowThreads();
44378 (arg1)->SetDone(arg2);
44379
44380 wxPyEndAllowThreads(__tstate);
44381 if (PyErr_Occurred()) SWIG_fail;
44382 }
44383 Py_INCREF(Py_None); resultobj = Py_None;
44384 return resultobj;
44385 fail:
44386 return NULL;
44387 }
44388
44389
44390 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44391 PyObject *resultobj;
44392 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44393 wxRelationship result;
44394 PyObject * obj0 = 0 ;
44395 char *kwnames[] = {
44396 (char *) "self", NULL
44397 };
44398
44399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44401 if (SWIG_arg_fail(1)) SWIG_fail;
44402 {
44403 PyThreadState* __tstate = wxPyBeginAllowThreads();
44404 result = (wxRelationship)(arg1)->GetRelationship();
44405
44406 wxPyEndAllowThreads(__tstate);
44407 if (PyErr_Occurred()) SWIG_fail;
44408 }
44409 resultobj = SWIG_From_int((result));
44410 return resultobj;
44411 fail:
44412 return NULL;
44413 }
44414
44415
44416 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44417 PyObject *resultobj;
44418 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44419 wxRelationship arg2 ;
44420 PyObject * obj0 = 0 ;
44421 PyObject * obj1 = 0 ;
44422 char *kwnames[] = {
44423 (char *) "self",(char *) "r", NULL
44424 };
44425
44426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44428 if (SWIG_arg_fail(1)) SWIG_fail;
44429 {
44430 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44431 if (SWIG_arg_fail(2)) SWIG_fail;
44432 }
44433 {
44434 PyThreadState* __tstate = wxPyBeginAllowThreads();
44435 (arg1)->SetRelationship((wxRelationship )arg2);
44436
44437 wxPyEndAllowThreads(__tstate);
44438 if (PyErr_Occurred()) SWIG_fail;
44439 }
44440 Py_INCREF(Py_None); resultobj = Py_None;
44441 return resultobj;
44442 fail:
44443 return NULL;
44444 }
44445
44446
44447 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44448 PyObject *resultobj;
44449 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44450 wxWindow *arg2 = (wxWindow *) 0 ;
44451 bool result;
44452 PyObject * obj0 = 0 ;
44453 PyObject * obj1 = 0 ;
44454 char *kwnames[] = {
44455 (char *) "self",(char *) "otherW", NULL
44456 };
44457
44458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44460 if (SWIG_arg_fail(1)) SWIG_fail;
44461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44462 if (SWIG_arg_fail(2)) SWIG_fail;
44463 {
44464 PyThreadState* __tstate = wxPyBeginAllowThreads();
44465 result = (bool)(arg1)->ResetIfWin(arg2);
44466
44467 wxPyEndAllowThreads(__tstate);
44468 if (PyErr_Occurred()) SWIG_fail;
44469 }
44470 {
44471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44472 }
44473 return resultobj;
44474 fail:
44475 return NULL;
44476 }
44477
44478
44479 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44480 PyObject *resultobj;
44481 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44482 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44483 wxWindow *arg3 = (wxWindow *) 0 ;
44484 bool result;
44485 PyObject * obj0 = 0 ;
44486 PyObject * obj1 = 0 ;
44487 PyObject * obj2 = 0 ;
44488 char *kwnames[] = {
44489 (char *) "self",(char *) "constraints",(char *) "win", NULL
44490 };
44491
44492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44494 if (SWIG_arg_fail(1)) SWIG_fail;
44495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44496 if (SWIG_arg_fail(2)) SWIG_fail;
44497 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44498 if (SWIG_arg_fail(3)) SWIG_fail;
44499 {
44500 PyThreadState* __tstate = wxPyBeginAllowThreads();
44501 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44502
44503 wxPyEndAllowThreads(__tstate);
44504 if (PyErr_Occurred()) SWIG_fail;
44505 }
44506 {
44507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44508 }
44509 return resultobj;
44510 fail:
44511 return NULL;
44512 }
44513
44514
44515 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44516 PyObject *resultobj;
44517 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44518 wxEdge arg2 ;
44519 wxWindow *arg3 = (wxWindow *) 0 ;
44520 wxWindow *arg4 = (wxWindow *) 0 ;
44521 int result;
44522 PyObject * obj0 = 0 ;
44523 PyObject * obj1 = 0 ;
44524 PyObject * obj2 = 0 ;
44525 PyObject * obj3 = 0 ;
44526 char *kwnames[] = {
44527 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44528 };
44529
44530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44532 if (SWIG_arg_fail(1)) SWIG_fail;
44533 {
44534 arg2 = (wxEdge)(SWIG_As_int(obj1));
44535 if (SWIG_arg_fail(2)) SWIG_fail;
44536 }
44537 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44538 if (SWIG_arg_fail(3)) SWIG_fail;
44539 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44540 if (SWIG_arg_fail(4)) SWIG_fail;
44541 {
44542 PyThreadState* __tstate = wxPyBeginAllowThreads();
44543 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44544
44545 wxPyEndAllowThreads(__tstate);
44546 if (PyErr_Occurred()) SWIG_fail;
44547 }
44548 {
44549 resultobj = SWIG_From_int((int)(result));
44550 }
44551 return resultobj;
44552 fail:
44553 return NULL;
44554 }
44555
44556
44557 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44558 PyObject *obj;
44559 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44560 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44561 Py_INCREF(obj);
44562 return Py_BuildValue((char *)"");
44563 }
44564 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44565 PyObject *resultobj;
44566 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44567 wxIndividualLayoutConstraint *result;
44568 PyObject * obj0 = 0 ;
44569 char *kwnames[] = {
44570 (char *) "self", NULL
44571 };
44572
44573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44575 if (SWIG_arg_fail(1)) SWIG_fail;
44576 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44577
44578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44579 return resultobj;
44580 fail:
44581 return NULL;
44582 }
44583
44584
44585 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44586 PyObject *resultobj;
44587 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44588 wxIndividualLayoutConstraint *result;
44589 PyObject * obj0 = 0 ;
44590 char *kwnames[] = {
44591 (char *) "self", NULL
44592 };
44593
44594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44596 if (SWIG_arg_fail(1)) SWIG_fail;
44597 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44598
44599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44600 return resultobj;
44601 fail:
44602 return NULL;
44603 }
44604
44605
44606 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44607 PyObject *resultobj;
44608 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44609 wxIndividualLayoutConstraint *result;
44610 PyObject * obj0 = 0 ;
44611 char *kwnames[] = {
44612 (char *) "self", NULL
44613 };
44614
44615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44617 if (SWIG_arg_fail(1)) SWIG_fail;
44618 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44619
44620 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44621 return resultobj;
44622 fail:
44623 return NULL;
44624 }
44625
44626
44627 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44628 PyObject *resultobj;
44629 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44630 wxIndividualLayoutConstraint *result;
44631 PyObject * obj0 = 0 ;
44632 char *kwnames[] = {
44633 (char *) "self", NULL
44634 };
44635
44636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44638 if (SWIG_arg_fail(1)) SWIG_fail;
44639 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44640
44641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44642 return resultobj;
44643 fail:
44644 return NULL;
44645 }
44646
44647
44648 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44649 PyObject *resultobj;
44650 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44651 wxIndividualLayoutConstraint *result;
44652 PyObject * obj0 = 0 ;
44653 char *kwnames[] = {
44654 (char *) "self", NULL
44655 };
44656
44657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44659 if (SWIG_arg_fail(1)) SWIG_fail;
44660 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44661
44662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44663 return resultobj;
44664 fail:
44665 return NULL;
44666 }
44667
44668
44669 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44670 PyObject *resultobj;
44671 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44672 wxIndividualLayoutConstraint *result;
44673 PyObject * obj0 = 0 ;
44674 char *kwnames[] = {
44675 (char *) "self", NULL
44676 };
44677
44678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44680 if (SWIG_arg_fail(1)) SWIG_fail;
44681 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44682
44683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44684 return resultobj;
44685 fail:
44686 return NULL;
44687 }
44688
44689
44690 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44691 PyObject *resultobj;
44692 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44693 wxIndividualLayoutConstraint *result;
44694 PyObject * obj0 = 0 ;
44695 char *kwnames[] = {
44696 (char *) "self", NULL
44697 };
44698
44699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44701 if (SWIG_arg_fail(1)) SWIG_fail;
44702 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44703
44704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44705 return resultobj;
44706 fail:
44707 return NULL;
44708 }
44709
44710
44711 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44712 PyObject *resultobj;
44713 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44714 wxIndividualLayoutConstraint *result;
44715 PyObject * obj0 = 0 ;
44716 char *kwnames[] = {
44717 (char *) "self", NULL
44718 };
44719
44720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44722 if (SWIG_arg_fail(1)) SWIG_fail;
44723 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44724
44725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44726 return resultobj;
44727 fail:
44728 return NULL;
44729 }
44730
44731
44732 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44733 PyObject *resultobj;
44734 wxLayoutConstraints *result;
44735 char *kwnames[] = {
44736 NULL
44737 };
44738
44739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44740 {
44741 PyThreadState* __tstate = wxPyBeginAllowThreads();
44742 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44743
44744 wxPyEndAllowThreads(__tstate);
44745 if (PyErr_Occurred()) SWIG_fail;
44746 }
44747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44748 return resultobj;
44749 fail:
44750 return NULL;
44751 }
44752
44753
44754 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44755 PyObject *resultobj;
44756 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44757 wxWindow *arg2 = (wxWindow *) 0 ;
44758 int *arg3 = (int *) 0 ;
44759 bool result;
44760 int temp3 ;
44761 int res3 = 0 ;
44762 PyObject * obj0 = 0 ;
44763 PyObject * obj1 = 0 ;
44764 char *kwnames[] = {
44765 (char *) "self",(char *) "win", NULL
44766 };
44767
44768 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44771 if (SWIG_arg_fail(1)) SWIG_fail;
44772 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44773 if (SWIG_arg_fail(2)) SWIG_fail;
44774 {
44775 PyThreadState* __tstate = wxPyBeginAllowThreads();
44776 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44777
44778 wxPyEndAllowThreads(__tstate);
44779 if (PyErr_Occurred()) SWIG_fail;
44780 }
44781 {
44782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44783 }
44784 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44785 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44786 return resultobj;
44787 fail:
44788 return NULL;
44789 }
44790
44791
44792 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44793 PyObject *resultobj;
44794 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44795 bool result;
44796 PyObject * obj0 = 0 ;
44797 char *kwnames[] = {
44798 (char *) "self", NULL
44799 };
44800
44801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44803 if (SWIG_arg_fail(1)) SWIG_fail;
44804 {
44805 PyThreadState* __tstate = wxPyBeginAllowThreads();
44806 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44807
44808 wxPyEndAllowThreads(__tstate);
44809 if (PyErr_Occurred()) SWIG_fail;
44810 }
44811 {
44812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44813 }
44814 return resultobj;
44815 fail:
44816 return NULL;
44817 }
44818
44819
44820 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44821 PyObject *obj;
44822 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44823 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44824 Py_INCREF(obj);
44825 return Py_BuildValue((char *)"");
44826 }
44827 static PyMethodDef SwigMethods[] = {
44828 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44829 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44830 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44833 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44854 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44867 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44882 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44935 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44963 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44982 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44984 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44992 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44993 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45005 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45017 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45021 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45027 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45037 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45047 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45051 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45126 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45128 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45130 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45132 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45134 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45136 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45138 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45140 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45142 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45144 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45146 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45148 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45150 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45164 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45182 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45185 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45188 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45200 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45205 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45211 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45217 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45280 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45287 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45323 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45333 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45339 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45341 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45343 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45346 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45350 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45353 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45356 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45358 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45363 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45371 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45375 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45378 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45380 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45384 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45401 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45403 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45406 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45408 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45412 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45416 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45427 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45430 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45433 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45437 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45444 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45449 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45454 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45458 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45503 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45523 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45530 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45534 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45544 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45716 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45756 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45770 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45773 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45828 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45855 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45899 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45907 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45926 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45927 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45964 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45994 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45997 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46001 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46004 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46014 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46026 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46038 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46048 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46058 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46072 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46079 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46080 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46081 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46082 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46083 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46088 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46115 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46127 { NULL, NULL, 0, NULL }
46128 };
46129
46130
46131 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46132
46133 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46134 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46135 }
46136 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46137 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46138 }
46139 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46140 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46141 }
46142 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46143 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46144 }
46145 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46146 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46147 }
46148 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46149 return (void *)((wxSizer *) ((wxGridSizer *) x));
46150 }
46151 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46152 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46153 }
46154 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46155 return (void *)((wxSizer *) ((wxPySizer *) x));
46156 }
46157 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46158 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46159 }
46160 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46161 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46162 }
46163 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46164 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46165 }
46166 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46167 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46168 }
46169 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46170 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46171 }
46172 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46173 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46174 }
46175 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46176 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46177 }
46178 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46179 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46180 }
46181 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46182 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46183 }
46184 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46185 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46186 }
46187 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46188 return (void *)((wxEvent *) ((wxPyEvent *) x));
46189 }
46190 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46191 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46192 }
46193 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46194 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46195 }
46196 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46197 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46198 }
46199 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46200 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46201 }
46202 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46203 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46204 }
46205 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46206 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46207 }
46208 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46209 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46210 }
46211 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46212 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46213 }
46214 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46215 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46216 }
46217 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46218 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46219 }
46220 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46221 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46222 }
46223 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46224 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46225 }
46226 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46227 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46228 }
46229 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46230 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46231 }
46232 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46233 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46234 }
46235 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46236 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46237 }
46238 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46239 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46240 }
46241 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46242 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46243 }
46244 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46245 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46246 }
46247 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46248 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46249 }
46250 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46251 return (void *)((wxEvent *) ((wxShowEvent *) x));
46252 }
46253 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46254 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46255 }
46256 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46257 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46258 }
46259 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46260 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46261 }
46262 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46263 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46264 }
46265 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46266 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46267 }
46268 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46269 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46270 }
46271 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46272 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46273 }
46274 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46275 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46276 }
46277 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46278 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46279 }
46280 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46281 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46282 }
46283 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46284 return (void *)((wxControl *) ((wxControlWithItems *) x));
46285 }
46286 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46287 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46288 }
46289 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46290 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46291 }
46292 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46293 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46294 }
46295 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46296 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46297 }
46298 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46299 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46300 }
46301 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46302 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46303 }
46304 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46305 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46306 }
46307 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46308 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46309 }
46310 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46311 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46312 }
46313 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46314 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46315 }
46316 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46317 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46318 }
46319 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46320 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46321 }
46322 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46323 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46324 }
46325 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46326 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46327 }
46328 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46329 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46330 }
46331 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46332 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46333 }
46334 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46335 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46336 }
46337 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46338 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46339 }
46340 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46341 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46342 }
46343 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46344 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46345 }
46346 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46347 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46348 }
46349 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46350 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46351 }
46352 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46353 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46354 }
46355 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46356 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46357 }
46358 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46359 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46360 }
46361 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46362 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46363 }
46364 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46365 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46366 }
46367 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46368 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46369 }
46370 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46371 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46372 }
46373 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46374 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46375 }
46376 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46377 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46378 }
46379 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46380 return (void *)((wxObject *) ((wxSizerItem *) x));
46381 }
46382 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46383 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46384 }
46385 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46386 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46387 }
46388 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46389 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46390 }
46391 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46392 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46393 }
46394 static void *_p_wxSizerTo_p_wxObject(void *x) {
46395 return (void *)((wxObject *) ((wxSizer *) x));
46396 }
46397 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46398 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46399 }
46400 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46401 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46402 }
46403 static void *_p_wxEventTo_p_wxObject(void *x) {
46404 return (void *)((wxObject *) ((wxEvent *) x));
46405 }
46406 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46407 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46408 }
46409 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46410 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46411 }
46412 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46413 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46414 }
46415 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46416 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46417 }
46418 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46419 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46420 }
46421 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46422 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46423 }
46424 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46425 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46426 }
46427 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46428 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46429 }
46430 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46431 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46432 }
46433 static void *_p_wxControlTo_p_wxObject(void *x) {
46434 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46435 }
46436 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46437 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46438 }
46439 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46440 return (void *)((wxObject *) ((wxFSFile *) x));
46441 }
46442 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46443 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46444 }
46445 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46446 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46447 }
46448 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46449 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46450 }
46451 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46452 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46453 }
46454 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46455 return (void *)((wxObject *) ((wxMenuItem *) x));
46456 }
46457 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46458 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46459 }
46460 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46461 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46462 }
46463 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46464 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46465 }
46466 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46467 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46468 }
46469 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46470 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46471 }
46472 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46473 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46474 }
46475 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46476 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46477 }
46478 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46479 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46480 }
46481 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46482 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46483 }
46484 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46485 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46486 }
46487 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46488 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46489 }
46490 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46491 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46492 }
46493 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46494 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46495 }
46496 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46497 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46498 }
46499 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46500 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46501 }
46502 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46503 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46504 }
46505 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46506 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46507 }
46508 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46509 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46510 }
46511 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46512 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46513 }
46514 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46515 return (void *)((wxObject *) ((wxImageHandler *) x));
46516 }
46517 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46518 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46519 }
46520 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46521 return (void *)((wxObject *) ((wxEvtHandler *) x));
46522 }
46523 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46524 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46525 }
46526 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46527 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46528 }
46529 static void *_p_wxImageTo_p_wxObject(void *x) {
46530 return (void *)((wxObject *) ((wxImage *) x));
46531 }
46532 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46533 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46534 }
46535 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46536 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46537 }
46538 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46539 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46540 }
46541 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46542 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46543 }
46544 static void *_p_wxWindowTo_p_wxObject(void *x) {
46545 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46546 }
46547 static void *_p_wxMenuTo_p_wxObject(void *x) {
46548 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46549 }
46550 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46551 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46552 }
46553 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46554 return (void *)((wxObject *) ((wxFileSystem *) x));
46555 }
46556 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46557 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46558 }
46559 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46560 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46561 }
46562 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46563 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46564 }
46565 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46566 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46567 }
46568 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46569 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46570 }
46571 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46572 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46573 }
46574 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46575 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46576 }
46577 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46578 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46579 }
46580 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46581 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46582 }
46583 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46584 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46585 }
46586 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46587 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46588 }
46589 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46590 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46591 }
46592 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46593 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46594 }
46595 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46596 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46597 }
46598 static void *_p_wxControlTo_p_wxWindow(void *x) {
46599 return (void *)((wxWindow *) ((wxControl *) x));
46600 }
46601 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46602 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46603 }
46604 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46605 return (void *)((wxWindow *) ((wxMenuBar *) x));
46606 }
46607 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46608 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46609 }
46610 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46611 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46612 }
46613 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46614 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46615 }
46616 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46617 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46618 }
46619 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46620 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46621 }
46622 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46623 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46624 }
46625 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46626 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46627 }
46628 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46629 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46630 }
46631 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46632 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46633 }
46634 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46635 return (void *)((wxValidator *) ((wxPyValidator *) x));
46636 }
46637 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}};
46638 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}};
46639 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}};
46640 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}};
46641 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}};
46642 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}};
46643 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}};
46644 static swig_type_info _swigt__p_wxSizer[] = {{"_p_wxSizer", 0, "wxSizer *", 0, 0, 0, 0},{"_p_wxSizer", 0, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxSizer, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46645 static swig_type_info _swigt__p_wxBoxSizer[] = {{"_p_wxBoxSizer", 0, "wxBoxSizer *", 0, 0, 0, 0},{"_p_wxBoxSizer", 0, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxBoxSizer, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxBoxSizer, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46646 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}};
46647 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}};
46648 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}};
46649 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}};
46650 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46651 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}};
46652 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}};
46653 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}};
46654 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}};
46655 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}};
46656 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}};
46657 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}};
46658 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}};
46659 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}};
46660 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}};
46661 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}};
46662 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}};
46663 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}};
46664 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}};
46665 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}};
46666 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}};
46667 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}};
46668 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}};
46669 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}};
46670 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}};
46671 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}};
46672 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}};
46673 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}};
46674 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}};
46675 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}};
46676 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}};
46677 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}};
46678 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}};
46679 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}};
46680 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}};
46681 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}};
46682 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}};
46683 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}};
46684 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}};
46685 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}};
46686 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}};
46687 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}};
46688 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}};
46689 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}};
46690 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}};
46691 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}};
46692 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}};
46693 static swig_type_info _swigt__p_wxDateEvent[] = {{"_p_wxDateEvent", 0, "wxDateEvent *", 0, 0, 0, 0},{"_p_wxDateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46694 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}};
46695 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}};
46696 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}};
46697 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}};
46698 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}};
46699 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}};
46700 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}};
46701 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}};
46702 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}};
46703 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}};
46704 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}};
46705 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}};
46706 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}};
46707 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}};
46708 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}};
46709 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}};
46710 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}};
46711 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}};
46712 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}};
46713 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}};
46714 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}};
46715 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}};
46716 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}};
46717 static swig_type_info _swigt__p_wxButton[] = {{"_p_wxButton", 0, "wxButton *", 0, 0, 0, 0},{"_p_wxButton", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46718 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}};
46719 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}};
46720 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}};
46721 static swig_type_info _swigt__p_wxStdDialogButtonSizer[] = {{"_p_wxStdDialogButtonSizer", 0, "wxStdDialogButtonSizer *", 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46722 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}};
46723 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}};
46724 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}};
46725 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}};
46726 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}};
46727 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}};
46728 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}};
46729 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}};
46730 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}};
46731 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46732 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}};
46733 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}};
46734 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}};
46735 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}};
46736 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}};
46737 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}};
46738 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}};
46739 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}};
46740 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}};
46741 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}};
46742 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}};
46743 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}};
46744 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}};
46745 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}};
46746 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}};
46747 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}};
46748 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}};
46749 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}};
46750 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}};
46751 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}};
46752 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}};
46753 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46754 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}};
46755 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}};
46756 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}};
46757 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}};
46758 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}};
46759 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}};
46760 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}};
46761 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}};
46762 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}};
46763 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}};
46764
46765 static swig_type_info *swig_types_initial[] = {
46766 _swigt__p_wxLayoutConstraints,
46767 _swigt__p_wxRealPoint,
46768 _swigt__p_wxSizerItem,
46769 _swigt__p_wxGBSizerItem,
46770 _swigt__p_wxScrollEvent,
46771 _swigt__p_wxEventLoop,
46772 _swigt__p_wxIndividualLayoutConstraint,
46773 _swigt__p_wxSizer,
46774 _swigt__p_wxBoxSizer,
46775 _swigt__p_wxStaticBoxSizer,
46776 _swigt__p_wxGridBagSizer,
46777 _swigt__p_wxAcceleratorEntry,
46778 _swigt__p_wxUpdateUIEvent,
46779 _swigt__p_wxEvent,
46780 _swigt__p_wxMenu,
46781 _swigt__p_wxGridSizer,
46782 _swigt__p_wxFlexGridSizer,
46783 _swigt__p_wxInitDialogEvent,
46784 _swigt__p_wxItemContainer,
46785 _swigt__p_wxNcPaintEvent,
46786 _swigt__p_wxPaintEvent,
46787 _swigt__p_wxSysColourChangedEvent,
46788 _swigt__p_wxMouseCaptureChangedEvent,
46789 _swigt__p_wxDisplayChangedEvent,
46790 _swigt__p_wxPaletteChangedEvent,
46791 _swigt__p_wxControl,
46792 _swigt__p_wxFont,
46793 _swigt__p_wxMenuBarBase,
46794 _swigt__p_wxSetCursorEvent,
46795 _swigt__p_wxFSFile,
46796 _swigt__p_wxCaret,
46797 _swigt__ptrdiff_t,
46798 _swigt__std__ptrdiff_t,
46799 _swigt__p_wxRegion,
46800 _swigt__p_wxPoint2D,
46801 _swigt__p_int,
46802 _swigt__p_wxSize,
46803 _swigt__p_wxDC,
46804 _swigt__p_wxPySizer,
46805 _swigt__p_wxVisualAttributes,
46806 _swigt__p_wxNotifyEvent,
46807 _swigt__p_wxPyEvent,
46808 _swigt__p_wxPropagationDisabler,
46809 _swigt__p_form_ops_t,
46810 _swigt__p_wxAppTraits,
46811 _swigt__p_wxArrayString,
46812 _swigt__p_wxShowEvent,
46813 _swigt__p_wxToolTip,
46814 _swigt__p_wxMoveEvent,
46815 _swigt__p_wxSizeEvent,
46816 _swigt__p_wxActivateEvent,
46817 _swigt__p_wxIconizeEvent,
46818 _swigt__p_wxMaximizeEvent,
46819 _swigt__p_wxQueryNewPaletteEvent,
46820 _swigt__p_wxWindowCreateEvent,
46821 _swigt__p_wxIdleEvent,
46822 _swigt__p_wxDateEvent,
46823 _swigt__p_wxMenuItem,
46824 _swigt__p_wxStaticBox,
46825 _swigt__p_long,
46826 _swigt__p_wxDuplexMode,
46827 _swigt__p_wxTIFFHandler,
46828 _swigt__p_wxXPMHandler,
46829 _swigt__p_wxPNMHandler,
46830 _swigt__p_wxJPEGHandler,
46831 _swigt__p_wxPCXHandler,
46832 _swigt__p_wxGIFHandler,
46833 _swigt__p_wxPNGHandler,
46834 _swigt__p_wxANIHandler,
46835 _swigt__p_wxMemoryFSHandler,
46836 _swigt__p_wxZipFSHandler,
46837 _swigt__p_wxInternetFSHandler,
46838 _swigt__p_wxPyFileSystemHandler,
46839 _swigt__p_wxEvtHandler,
46840 _swigt__p_wxCURHandler,
46841 _swigt__p_wxICOHandler,
46842 _swigt__p_wxBMPHandler,
46843 _swigt__p_wxImageHandler,
46844 _swigt__p_wxFileSystemHandler,
46845 _swigt__p_wxRect,
46846 _swigt__p_wxButton,
46847 _swigt__p_wxGBSpan,
46848 _swigt__p_wxPropagateOnce,
46849 _swigt__p_wxAcceleratorTable,
46850 _swigt__p_wxStdDialogButtonSizer,
46851 _swigt__p_char,
46852 _swigt__p_wxGBPosition,
46853 _swigt__p_wxImage,
46854 _swigt__p_wxFrame,
46855 _swigt__p_wxScrollWinEvent,
46856 _swigt__p_wxPaperSize,
46857 _swigt__p_wxImageHistogram,
46858 _swigt__p_wxPoint,
46859 _swigt__p_wxCursor,
46860 _swigt__p_wxObject,
46861 _swigt__p_wxInputStream,
46862 _swigt__p_wxOutputStream,
46863 _swigt__p_wxPyInputStream,
46864 _swigt__p_wxDateTime,
46865 _swigt__p_wxKeyEvent,
46866 _swigt__p_wxNavigationKeyEvent,
46867 _swigt__p_wxWindowDestroyEvent,
46868 _swigt__p_unsigned_long,
46869 _swigt__p_wxWindow,
46870 _swigt__p_wxMenuBar,
46871 _swigt__p_wxFileSystem,
46872 _swigt__p_wxBitmap,
46873 _swigt__unsigned_int,
46874 _swigt__p_unsigned_int,
46875 _swigt__p_wxMenuEvent,
46876 _swigt__p_wxContextMenuEvent,
46877 _swigt__p_unsigned_char,
46878 _swigt__p_wxEraseEvent,
46879 _swigt__p_wxMouseEvent,
46880 _swigt__p_wxCloseEvent,
46881 _swigt__p_wxPyApp,
46882 _swigt__p_wxCommandEvent,
46883 _swigt__p_wxPyCommandEvent,
46884 _swigt__p_wxPyDropTarget,
46885 _swigt__p_wxQuantize,
46886 _swigt__p_wxChildFocusEvent,
46887 _swigt__p_wxFocusEvent,
46888 _swigt__p_wxDropFilesEvent,
46889 _swigt__p_wxControlWithItems,
46890 _swigt__p_wxColour,
46891 _swigt__p_wxValidator,
46892 _swigt__p_wxPyValidator,
46893 0
46894 };
46895
46896
46897 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46898
46899 static swig_const_info swig_const_table[] = {
46900 {0, 0, 0, 0.0, 0, 0}};
46901
46902 #ifdef __cplusplus
46903 }
46904 #endif
46905
46906
46907 #ifdef __cplusplus
46908 extern "C" {
46909 #endif
46910
46911 /* Python-specific SWIG API */
46912 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46913 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46914 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46915
46916 /* -----------------------------------------------------------------------------
46917 * global variable support code.
46918 * ----------------------------------------------------------------------------- */
46919
46920 typedef struct swig_globalvar {
46921 char *name; /* Name of global variable */
46922 PyObject *(*get_attr)(); /* Return the current value */
46923 int (*set_attr)(PyObject *); /* Set the value */
46924 struct swig_globalvar *next;
46925 } swig_globalvar;
46926
46927 typedef struct swig_varlinkobject {
46928 PyObject_HEAD
46929 swig_globalvar *vars;
46930 } swig_varlinkobject;
46931
46932 static PyObject *
46933 swig_varlink_repr(swig_varlinkobject *v) {
46934 v = v;
46935 return PyString_FromString("<Swig global variables>");
46936 }
46937
46938 static int
46939 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46940 swig_globalvar *var;
46941 flags = flags;
46942 fprintf(fp,"Swig global variables { ");
46943 for (var = v->vars; var; var=var->next) {
46944 fprintf(fp,"%s", var->name);
46945 if (var->next) fprintf(fp,", ");
46946 }
46947 fprintf(fp," }\n");
46948 return 0;
46949 }
46950
46951 static PyObject *
46952 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46953 swig_globalvar *var = v->vars;
46954 while (var) {
46955 if (strcmp(var->name,n) == 0) {
46956 return (*var->get_attr)();
46957 }
46958 var = var->next;
46959 }
46960 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46961 return NULL;
46962 }
46963
46964 static int
46965 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46966 swig_globalvar *var = v->vars;
46967 while (var) {
46968 if (strcmp(var->name,n) == 0) {
46969 return (*var->set_attr)(p);
46970 }
46971 var = var->next;
46972 }
46973 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46974 return 1;
46975 }
46976
46977 static PyTypeObject varlinktype = {
46978 PyObject_HEAD_INIT(0)
46979 0, /* Number of items in variable part (ob_size) */
46980 (char *)"swigvarlink", /* Type name (tp_name) */
46981 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46982 0, /* Itemsize (tp_itemsize) */
46983 0, /* Deallocator (tp_dealloc) */
46984 (printfunc) swig_varlink_print, /* Print (tp_print) */
46985 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46986 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46987 0, /* tp_compare */
46988 (reprfunc) swig_varlink_repr, /* tp_repr */
46989 0, /* tp_as_number */
46990 0, /* tp_as_sequence */
46991 0, /* tp_as_mapping */
46992 0, /* tp_hash */
46993 0, /* tp_call */
46994 0, /* tp_str */
46995 0, /* tp_getattro */
46996 0, /* tp_setattro */
46997 0, /* tp_as_buffer */
46998 0, /* tp_flags */
46999 0, /* tp_doc */
47000 #if PY_VERSION_HEX >= 0x02000000
47001 0, /* tp_traverse */
47002 0, /* tp_clear */
47003 #endif
47004 #if PY_VERSION_HEX >= 0x02010000
47005 0, /* tp_richcompare */
47006 0, /* tp_weaklistoffset */
47007 #endif
47008 #if PY_VERSION_HEX >= 0x02020000
47009 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47010 #endif
47011 #if PY_VERSION_HEX >= 0x02030000
47012 0, /* tp_del */
47013 #endif
47014 #ifdef COUNT_ALLOCS
47015 0,0,0,0 /* tp_alloc -> tp_next */
47016 #endif
47017 };
47018
47019 /* Create a variable linking object for use later */
47020 static PyObject *
47021 SWIG_Python_newvarlink(void) {
47022 swig_varlinkobject *result = 0;
47023 result = PyMem_NEW(swig_varlinkobject,1);
47024 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47025 result->ob_type = &varlinktype;
47026 result->vars = 0;
47027 result->ob_refcnt = 0;
47028 Py_XINCREF((PyObject *) result);
47029 return ((PyObject*) result);
47030 }
47031
47032 static void
47033 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47034 swig_varlinkobject *v;
47035 swig_globalvar *gv;
47036 v= (swig_varlinkobject *) p;
47037 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47038 gv->name = (char *) malloc(strlen(name)+1);
47039 strcpy(gv->name,name);
47040 gv->get_attr = get_attr;
47041 gv->set_attr = set_attr;
47042 gv->next = v->vars;
47043 v->vars = gv;
47044 }
47045
47046 /* -----------------------------------------------------------------------------
47047 * constants/methods manipulation
47048 * ----------------------------------------------------------------------------- */
47049
47050 /* Install Constants */
47051 static void
47052 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47053 PyObject *obj = 0;
47054 size_t i;
47055 for (i = 0; constants[i].type; i++) {
47056 switch(constants[i].type) {
47057 case SWIG_PY_INT:
47058 obj = PyInt_FromLong(constants[i].lvalue);
47059 break;
47060 case SWIG_PY_FLOAT:
47061 obj = PyFloat_FromDouble(constants[i].dvalue);
47062 break;
47063 case SWIG_PY_STRING:
47064 if (constants[i].pvalue) {
47065 obj = PyString_FromString((char *) constants[i].pvalue);
47066 } else {
47067 Py_INCREF(Py_None);
47068 obj = Py_None;
47069 }
47070 break;
47071 case SWIG_PY_POINTER:
47072 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47073 break;
47074 case SWIG_PY_BINARY:
47075 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47076 break;
47077 default:
47078 obj = 0;
47079 break;
47080 }
47081 if (obj) {
47082 PyDict_SetItemString(d,constants[i].name,obj);
47083 Py_DECREF(obj);
47084 }
47085 }
47086 }
47087
47088 /* -----------------------------------------------------------------------------*/
47089 /* Fix SwigMethods to carry the callback ptrs when needed */
47090 /* -----------------------------------------------------------------------------*/
47091
47092 static void
47093 SWIG_Python_FixMethods(PyMethodDef *methods,
47094 swig_const_info *const_table,
47095 swig_type_info **types,
47096 swig_type_info **types_initial) {
47097 size_t i;
47098 for (i = 0; methods[i].ml_name; ++i) {
47099 char *c = methods[i].ml_doc;
47100 if (c && (c = strstr(c, "swig_ptr: "))) {
47101 int j;
47102 swig_const_info *ci = 0;
47103 char *name = c + 10;
47104 for (j = 0; const_table[j].type; j++) {
47105 if (strncmp(const_table[j].name, name,
47106 strlen(const_table[j].name)) == 0) {
47107 ci = &(const_table[j]);
47108 break;
47109 }
47110 }
47111 if (ci) {
47112 size_t shift = (ci->ptype) - types;
47113 swig_type_info *ty = types_initial[shift];
47114 size_t ldoc = (c - methods[i].ml_doc);
47115 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47116 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47117 char *buff = ndoc;
47118 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47119 strncpy(buff, methods[i].ml_doc, ldoc);
47120 buff += ldoc;
47121 strncpy(buff, "swig_ptr: ", 10);
47122 buff += 10;
47123 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47124 methods[i].ml_doc = ndoc;
47125 }
47126 }
47127 }
47128 }
47129
47130 /* -----------------------------------------------------------------------------*
47131 * Initialize type list
47132 * -----------------------------------------------------------------------------*/
47133
47134 #if PY_MAJOR_VERSION < 2
47135 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47136 is copied out of Python/modsupport.c in python version 2.3.4 */
47137 static int
47138 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47139 {
47140 PyObject *dict;
47141 if (!PyModule_Check(m)) {
47142 PyErr_SetString(PyExc_TypeError,
47143 "PyModule_AddObject() needs module as first arg");
47144 return -1;
47145 }
47146 if (!o) {
47147 PyErr_SetString(PyExc_TypeError,
47148 "PyModule_AddObject() needs non-NULL value");
47149 return -1;
47150 }
47151
47152 dict = PyModule_GetDict(m);
47153 if (dict == NULL) {
47154 /* Internal error -- modules must have a dict! */
47155 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47156 PyModule_GetName(m));
47157 return -1;
47158 }
47159 if (PyDict_SetItemString(dict, name, o))
47160 return -1;
47161 Py_DECREF(o);
47162 return 0;
47163 }
47164 #endif
47165
47166 static swig_type_info **
47167 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47168 static PyMethodDef swig_empty_runtime_method_table[] = {
47169 {
47170 NULL, NULL, 0, NULL
47171 }
47172 };/* Sentinel */
47173
47174 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47175 swig_empty_runtime_method_table);
47176 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47177 if (pointer && module) {
47178 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47179 }
47180 return type_list_handle;
47181 }
47182
47183 static swig_type_info **
47184 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47185 swig_type_info **type_pointer;
47186
47187 /* first check if module already created */
47188 type_pointer = SWIG_Python_GetTypeListHandle();
47189 if (type_pointer) {
47190 return type_pointer;
47191 } else {
47192 /* create a new module and variable */
47193 return SWIG_Python_SetTypeListHandle(type_list_handle);
47194 }
47195 }
47196
47197 #ifdef __cplusplus
47198 }
47199 #endif
47200
47201 /* -----------------------------------------------------------------------------*
47202 * Partial Init method
47203 * -----------------------------------------------------------------------------*/
47204
47205 #ifdef SWIG_LINK_RUNTIME
47206 #ifdef __cplusplus
47207 extern "C"
47208 #endif
47209 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47210 #endif
47211
47212 #ifdef __cplusplus
47213 extern "C"
47214 #endif
47215 SWIGEXPORT(void) SWIG_init(void) {
47216 static PyObject *SWIG_globals = 0;
47217 static int typeinit = 0;
47218 PyObject *m, *d;
47219 int i;
47220 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47221
47222 /* Fix SwigMethods to carry the callback ptrs when needed */
47223 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47224
47225 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47226 d = PyModule_GetDict(m);
47227
47228 if (!typeinit) {
47229 #ifdef SWIG_LINK_RUNTIME
47230 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47231 #else
47232 # ifndef SWIG_STATIC_RUNTIME
47233 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47234 # endif
47235 #endif
47236 for (i = 0; swig_types_initial[i]; i++) {
47237 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47238 }
47239 typeinit = 1;
47240 }
47241 SWIG_InstallConstants(d,swig_const_table);
47242
47243
47244 #ifndef wxPyUSE_EXPORT
47245 // Make our API structure a CObject so other modules can import it
47246 // from this module.
47247 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47248 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47249 Py_XDECREF(cobj);
47250 #endif
47251
47252 {
47253 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47254 }
47255 {
47256 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47257 }
47258 {
47259 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47260 }
47261 {
47262 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47263 }
47264 {
47265 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47266 }
47267 {
47268 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47269 }
47270 {
47271 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47272 }
47273 {
47274 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47275 }
47276 {
47277 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47278 }
47279 {
47280 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47281 }
47282 {
47283 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47284 }
47285 {
47286 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47287 }
47288 {
47289 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47290 }
47291 {
47292 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47293 }
47294 {
47295 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47296 }
47297 {
47298 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47299 }
47300 {
47301 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47302 }
47303 {
47304 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47305 }
47306 {
47307 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
47308 }
47309 {
47310 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
47311 }
47312 {
47313 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
47314 }
47315 {
47316 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
47317 }
47318 {
47319 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
47320 }
47321 {
47322 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47323 }
47324 {
47325 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47326 }
47327 {
47328 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47329 }
47330 {
47331 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47332 }
47333 {
47334 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47335 }
47336 {
47337 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47338 }
47339 {
47340 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47341 }
47342 {
47343 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47344 }
47345 {
47346 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47347 }
47348 {
47349 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47350 }
47351 {
47352 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47353 }
47354 {
47355 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47356 }
47357 {
47358 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47359 }
47360 {
47361 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47362 }
47363 {
47364 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47365 }
47366 {
47367 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47368 }
47369 {
47370 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47371 }
47372 {
47373 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47374 }
47375 {
47376 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47377 }
47378 {
47379 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47380 }
47381 {
47382 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47383 }
47384 {
47385 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47386 }
47387 {
47388 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47389 }
47390 {
47391 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47392 }
47393 {
47394 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47395 }
47396 {
47397 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47398 }
47399 {
47400 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47401 }
47402 {
47403 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47404 }
47405 {
47406 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47407 }
47408 {
47409 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47410 }
47411 {
47412 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47413 }
47414 {
47415 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47416 }
47417 {
47418 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47419 }
47420 {
47421 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47422 }
47423 {
47424 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47425 }
47426 {
47427 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47428 }
47429 {
47430 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47431 }
47432 {
47433 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47434 }
47435 {
47436 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47437 }
47438 {
47439 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47440 }
47441 {
47442 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47443 }
47444 {
47445 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47446 }
47447 {
47448 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47449 }
47450 {
47451 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47452 }
47453 {
47454 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47455 }
47456 {
47457 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47458 }
47459 {
47460 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47461 }
47462 {
47463 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47464 }
47465 {
47466 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47467 }
47468 {
47469 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47470 }
47471 {
47472 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47473 }
47474 {
47475 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47476 }
47477 {
47478 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47479 }
47480 {
47481 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47482 }
47483 {
47484 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47485 }
47486 {
47487 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47488 }
47489 {
47490 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47491 }
47492 {
47493 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47494 }
47495 {
47496 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47497 }
47498 {
47499 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47500 }
47501 {
47502 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47503 }
47504 {
47505 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47506 }
47507 {
47508 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47509 }
47510 {
47511 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47512 }
47513 {
47514 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47515 }
47516 {
47517 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47518 }
47519 {
47520 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47521 }
47522 {
47523 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47524 }
47525 {
47526 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47527 }
47528 {
47529 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47530 }
47531 {
47532 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47533 }
47534 {
47535 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47536 }
47537 {
47538 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47539 }
47540 {
47541 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47542 }
47543 {
47544 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47545 }
47546 {
47547 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47548 }
47549 {
47550 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47551 }
47552 {
47553 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47554 }
47555 {
47556 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47557 }
47558 {
47559 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47560 }
47561 {
47562 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47563 }
47564 {
47565 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47566 }
47567 {
47568 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47569 }
47570 {
47571 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47572 }
47573 {
47574 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47575 }
47576 {
47577 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47578 }
47579 {
47580 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47581 }
47582 {
47583 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47584 }
47585 {
47586 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47587 }
47588 {
47589 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47590 }
47591 {
47592 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47593 }
47594 {
47595 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47596 }
47597 {
47598 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47599 }
47600 {
47601 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47602 }
47603 {
47604 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47605 }
47606 {
47607 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47608 }
47609 {
47610 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47611 }
47612 {
47613 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47614 }
47615 {
47616 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47617 }
47618 {
47619 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47620 }
47621 {
47622 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47623 }
47624 {
47625 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47626 }
47627 {
47628 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47629 }
47630 {
47631 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47632 }
47633 {
47634 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47635 }
47636 {
47637 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47638 }
47639 {
47640 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47641 }
47642 {
47643 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47644 }
47645 {
47646 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47647 }
47648 {
47649 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47650 }
47651 {
47652 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47653 }
47654 {
47655 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47656 }
47657 {
47658 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47659 }
47660 {
47661 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47662 }
47663 {
47664 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47665 }
47666 {
47667 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47668 }
47669 {
47670 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47671 }
47672 {
47673 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47674 }
47675 {
47676 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47677 }
47678 {
47679 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47680 }
47681 {
47682 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47683 }
47684 {
47685 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47686 }
47687 {
47688 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47689 }
47690 {
47691 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47692 }
47693 {
47694 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47695 }
47696 {
47697 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47698 }
47699 {
47700 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47701 }
47702 {
47703 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47704 }
47705 {
47706 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47707 }
47708 {
47709 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47710 }
47711 {
47712 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47713 }
47714 {
47715 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47716 }
47717 {
47718 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47719 }
47720 {
47721 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47722 }
47723 {
47724 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47725 }
47726 {
47727 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47728 }
47729 {
47730 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47731 }
47732 {
47733 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47734 }
47735 {
47736 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47737 }
47738 {
47739 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47740 }
47741 {
47742 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47743 }
47744 {
47745 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47746 }
47747 {
47748 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47749 }
47750 {
47751 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47752 }
47753 {
47754 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47755 }
47756 {
47757 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47758 }
47759 {
47760 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47761 }
47762 {
47763 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47764 }
47765 {
47766 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47767 }
47768 {
47769 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47770 }
47771 {
47772 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47773 }
47774 {
47775 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47776 }
47777 {
47778 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47779 }
47780 {
47781 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47782 }
47783 {
47784 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47785 }
47786 {
47787 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47788 }
47789 {
47790 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47791 }
47792 {
47793 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47794 }
47795 {
47796 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47797 }
47798 {
47799 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47800 }
47801 {
47802 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47803 }
47804 {
47805 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47806 }
47807 {
47808 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47809 }
47810 {
47811 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47812 }
47813 {
47814 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47815 }
47816 {
47817 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47818 }
47819 {
47820 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47821 }
47822 {
47823 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47824 }
47825 {
47826 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47827 }
47828 {
47829 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47830 }
47831 {
47832 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47833 }
47834 {
47835 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47836 }
47837 {
47838 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47839 }
47840 {
47841 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47842 }
47843 {
47844 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47845 }
47846 {
47847 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47848 }
47849 {
47850 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47851 }
47852 {
47853 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47854 }
47855 {
47856 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47857 }
47858 {
47859 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47860 }
47861 {
47862 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47863 }
47864 {
47865 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47866 }
47867 {
47868 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47869 }
47870 {
47871 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47872 }
47873 {
47874 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47875 }
47876 {
47877 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47878 }
47879 {
47880 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47881 }
47882 {
47883 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47884 }
47885 {
47886 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47887 }
47888 {
47889 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47890 }
47891 {
47892 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47893 }
47894 {
47895 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47896 }
47897 {
47898 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47899 }
47900 {
47901 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47902 }
47903 {
47904 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47905 }
47906 {
47907 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47908 }
47909 {
47910 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47911 }
47912 {
47913 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47914 }
47915 {
47916 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47917 }
47918 {
47919 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47920 }
47921 {
47922 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47923 }
47924 {
47925 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47926 }
47927 {
47928 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47929 }
47930 {
47931 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47932 }
47933 {
47934 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47935 }
47936 {
47937 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47938 }
47939 {
47940 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47959 }
47960 {
47961 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47962 }
47963 {
47964 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47965 }
47966 {
47967 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47968 }
47969 {
47970 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47971 }
47972 {
47973 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47974 }
47975 {
47976 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47983 }
47984 {
47985 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47986 }
47987 {
47988 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47989 }
47990 {
47991 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47992 }
47993 {
47994 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47995 }
47996 {
47997 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48040 }
48041 {
48042 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48043 }
48044 {
48045 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48046 }
48047 {
48048 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48049 }
48050 {
48051 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48052 }
48053 {
48054 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48055 }
48056 {
48057 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48058 }
48059 {
48060 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48061 }
48062 {
48063 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48064 }
48065 {
48066 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48067 }
48068 {
48069 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48070 }
48071 {
48072 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48073 }
48074 {
48075 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48076 }
48077 {
48078 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48079 }
48080 {
48081 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48082 }
48083 {
48084 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48085 }
48086 {
48087 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48088 }
48089 {
48090 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48091 }
48092 {
48093 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48094 }
48095 {
48096 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48097 }
48098 {
48099 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48100 }
48101 {
48102 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48103 }
48104 {
48105 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48106 }
48107 {
48108 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48109 }
48110 {
48111 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48112 }
48113 {
48114 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48115 }
48116 {
48117 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48118 }
48119 {
48120 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48121 }
48122 {
48123 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48124 }
48125 {
48126 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48127 }
48128 {
48129 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48130 }
48131 {
48132 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48133 }
48134 {
48135 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48136 }
48137 {
48138 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48139 }
48140 {
48141 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48142 }
48143 {
48144 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48145 }
48146 {
48147 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48148 }
48149 {
48150 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48151 }
48152 {
48153 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48154 }
48155 {
48156 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48157 }
48158 {
48159 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48160 }
48161 {
48162 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48163 }
48164 {
48165 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48166 }
48167 {
48168 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48169 }
48170 {
48171 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48172 }
48173 {
48174 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48175 }
48176 {
48177 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48178 }
48179 {
48180 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48181 }
48182 {
48183 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48190 }
48191 {
48192 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48193 }
48194 {
48195 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48196 }
48197 {
48198 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48199 }
48200 {
48201 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48202 }
48203 {
48204 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48208 }
48209 {
48210 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48211 }
48212 {
48213 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48226 }
48227 {
48228 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48229 }
48230 {
48231 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48232 }
48233 {
48234 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48235 }
48236 {
48237 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48238 }
48239 {
48240 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48247 }
48248 {
48249 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48250 }
48251 {
48252 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48259 }
48260 {
48261 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48262 }
48263 {
48264 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48265 }
48266 {
48267 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48268 }
48269 {
48270 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48271 }
48272 {
48273 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48295 }
48296 {
48297 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48298 }
48299 {
48300 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48301 }
48302 {
48303 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48304 }
48305 {
48306 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48307 }
48308 {
48309 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48310 }
48311 {
48312 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48313 }
48314 {
48315 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48316 }
48317 {
48318 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48319 }
48320 {
48321 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48322 }
48323 {
48324 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48325 }
48326 {
48327 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48328 }
48329 {
48330 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48331 }
48332 {
48333 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48334 }
48335 {
48336 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48337 }
48338 {
48339 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48340 }
48341 {
48342 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48343 }
48344 {
48345 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48346 }
48347 {
48348 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48349 }
48350 {
48351 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48352 }
48353 {
48354 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48355 }
48356 {
48357 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48358 }
48359 {
48360 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48361 }
48362 {
48363 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48364 }
48365 {
48366 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48367 }
48368 {
48369 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48370 }
48371 {
48372 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48373 }
48374 {
48375 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48376 }
48377 {
48378 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48379 }
48380 {
48381 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48382 }
48383 {
48384 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48385 }
48386 {
48387 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48388 }
48389 {
48390 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48391 }
48392 {
48393 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48394 }
48395 {
48396 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48397 }
48398 {
48399 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48400 }
48401 {
48402 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48403 }
48404 {
48405 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48406 }
48407 {
48408 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48409 }
48410 {
48411 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48412 }
48413 {
48414 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48415 }
48416 {
48417 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48418 }
48419 {
48420 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48424 }
48425 {
48426 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48427 }
48428 {
48429 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48430 }
48431 {
48432 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48433 }
48434 {
48435 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48436 }
48437 {
48438 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48439 }
48440 {
48441 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48445 }
48446 {
48447 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48484 }
48485 {
48486 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48487 }
48488 {
48489 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48490 }
48491 {
48492 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48493 }
48494 {
48495 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48496 }
48497 {
48498 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48499 }
48500 {
48501 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48502 }
48503 {
48504 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48505 }
48506 {
48507 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48508 }
48509 {
48510 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48511 }
48512 {
48513 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48514 }
48515 {
48516 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48517 }
48518 {
48519 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48520 }
48521 {
48522 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48523 }
48524 {
48525 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48526 }
48527 {
48528 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48529 }
48530 {
48531 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48532 }
48533 {
48534 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48535 }
48536 {
48537 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48538 }
48539 {
48540 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48541 }
48542 {
48543 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48544 }
48545 {
48546 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48547 }
48548 {
48549 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48550 }
48551 {
48552 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48553 }
48554 {
48555 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48556 }
48557 {
48558 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48559 }
48560 {
48561 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48562 }
48563 {
48564 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48565 }
48566 {
48567 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48568 }
48569 {
48570 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48571 }
48572 {
48573 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48574 }
48575 {
48576 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48577 }
48578 {
48579 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48580 }
48581 {
48582 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48583 }
48584 {
48585 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48586 }
48587 {
48588 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48589 }
48590 {
48591 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48592 }
48593 {
48594 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48595 }
48596 {
48597 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48598 }
48599 {
48600 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48601 }
48602 {
48603 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48604 }
48605 {
48606 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48607 }
48608 {
48609 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48610 }
48611 {
48612 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48613 }
48614 {
48615 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48616 }
48617 {
48618 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48619 }
48620 {
48621 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48622 }
48623 {
48624 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48625 }
48626 {
48627 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48628 }
48629 {
48630 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48631 }
48632 {
48633 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48634 }
48635 {
48636 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48637 }
48638 {
48639 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48640 }
48641 {
48642 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48643 }
48644 {
48645 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48646 }
48647 {
48648 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48649 }
48650 {
48651 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48652 }
48653 {
48654 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48655 }
48656 {
48657 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48658 }
48659 {
48660 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48661 }
48662 {
48663 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48664 }
48665 {
48666 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48667 }
48668 {
48669 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48670 }
48671 {
48672 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48673 }
48674 {
48675 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48676 }
48677 {
48678 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48679 }
48680 {
48681 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48688 }
48689 {
48690 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48691 }
48692 {
48693 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48694 }
48695 {
48696 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48697 }
48698 {
48699 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48700 }
48701 {
48702 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48703 }
48704 {
48705 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48706 }
48707 {
48708 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48709 }
48710 {
48711 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48712 }
48713 {
48714 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48715 }
48716 {
48717 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48718 }
48719 {
48720 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48721 }
48722 {
48723 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48724 }
48725 {
48726 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48727 }
48728 {
48729 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48730 }
48731 {
48732 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48733 }
48734 {
48735 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48736 }
48737 {
48738 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48739 }
48740 {
48741 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48742 }
48743 {
48744 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48745 }
48746 {
48747 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48748 }
48749 {
48750 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48751 }
48752 {
48753 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48754 }
48755 {
48756 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48757 }
48758 {
48759 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48760 }
48761 {
48762 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48763 }
48764 {
48765 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48766 }
48767 {
48768 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48769 }
48770 {
48771 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48772 }
48773 {
48774 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48775 }
48776 {
48777 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48778 }
48779 {
48780 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48781 }
48782 {
48783 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48784 }
48785 {
48786 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48787 }
48788 {
48789 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48790 }
48791 {
48792 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48793 }
48794 {
48795 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48796 }
48797 {
48798 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48799 }
48800 {
48801 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48802 }
48803 {
48804 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48805 }
48806 {
48807 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48808 }
48809 {
48810 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48811 }
48812 {
48813 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48814 }
48815 {
48816 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48817 }
48818 {
48819 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48820 }
48821 {
48822 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48823 }
48824 {
48825 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48826 }
48827 {
48828 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48829 }
48830 {
48831 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48832 }
48833 {
48834 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48835 }
48836 {
48837 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48838 }
48839 {
48840 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48841 }
48842 {
48843 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48844 }
48845 {
48846 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48847 }
48848 {
48849 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48850 }
48851 {
48852 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48853 }
48854 {
48855 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48856 }
48857 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48858 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48859 {
48860 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49011 }
49012 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49013 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49014 {
49015 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49016 }
49017 {
49018 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49019 }
49020 {
49021 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49022 }
49023
49024 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49025
49026
49027 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49028
49029 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49030 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49031 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49032 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49033 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49034 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49035 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49036 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49037 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49038 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49039 {
49040 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49044 }
49045 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49046 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49047 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49048 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49049 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49050 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49051 {
49052 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49098 }
49099 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49100 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49101 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49102 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49103 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49104 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49105 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49106 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49107 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49108 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49109 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49110 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49111 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49112 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49113 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49114 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49115 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49116 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49117 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49118 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49119 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49120 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49121 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49122 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49123 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49124 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49125 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49126 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49127 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49128 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49129 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49130 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49131 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49132 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49133 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49134 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49135 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49136 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49137 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49138 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49139 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49140 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49141 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49142 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49143 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49144 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49145 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49146 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49147 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49148 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49149 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49150 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49151 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49152 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49153 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49154 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49155 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49156 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49157 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49158 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49159 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49160 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49161 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49162 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49163 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49164 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49165 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49166 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49167 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49168 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49169 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49170 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49171 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49172 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49173 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49174 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49175 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49176 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49177 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49178 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49179 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49180 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49181 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49182 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49183 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49184 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49185 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49186 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49187 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49188 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49189 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49190 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49191 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49192 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49193 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49194 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49195 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49196 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49197 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49198 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49199 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49200 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49201 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49202 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49203 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49204 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49205 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49206 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49207 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49208 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49209 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49210 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49211 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49212 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49213 {
49214 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49251 }
49252 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49253 {
49254 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49255 }
49256 {
49257 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49258 }
49259 {
49260 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49261 }
49262 {
49263 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49264 }
49265 {
49266 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49267 }
49268 {
49269 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49270 }
49271 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49272 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49273 {
49274 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49287 }
49288 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49289 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49290 {
49291 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49292 }
49293 {
49294 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49295 }
49296 {
49297 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49298 }
49299 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49300 {
49301 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49356 }
49357
49358 // Initialize threading, some globals and such
49359 __wxPyPreStart(d);
49360
49361
49362 // Although these are defined in __version__ they need to be here too so
49363 // that an assert can be done to ensure that the wxPython and the wxWindows
49364 // versions match.
49365 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49366 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49367 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49368
49369 }
49370
wxWidgets (Impactor)