]> 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
reSWIGged
[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 wxPyCBInputStream_copy,
1653
1654 wxPyInstance_Check,
1655 wxPySwigInstance_Check,
1656
1657 wxPyCheckForApp
1658
1659 };
1660
1661 #endif
1662
1663
1664 #if !WXWIN_COMPATIBILITY_2_4
1665 #define wxHIDE_READONLY 0
1666 #endif
1667
1668
1669 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1670 #define SWIG_From_int PyInt_FromLong
1671 /*@@*/
1672
1673
1674 #if ! wxUSE_HOTKEY
1675 enum wxHotkeyModifier
1676 {
1677 wxMOD_NONE = 0,
1678 wxMOD_ALT = 1,
1679 wxMOD_CONTROL = 2,
1680 wxMOD_SHIFT = 4,
1681 wxMOD_WIN = 8
1682 };
1683 #define wxEVT_HOTKEY 9999
1684 #endif
1685
1686 static const wxString wxPyEmptyString(wxEmptyString);
1687 static wxString wxObject_GetClassName(wxObject *self){
1688 return self->GetClassInfo()->GetClassName();
1689 }
1690 static void wxObject_Destroy(wxObject *self){
1691 delete self;
1692 }
1693
1694 #ifndef __WXMAC__
1695 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1696 #endif
1697
1698
1699 #include <limits.h>
1700
1701
1702 SWIGINTERN int
1703 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1704 const char *errmsg)
1705 {
1706 if (value < min_value) {
1707 if (errmsg) {
1708 PyErr_Format(PyExc_OverflowError,
1709 "value %ld is less than '%s' minimum %ld",
1710 value, errmsg, min_value);
1711 }
1712 return 0;
1713 } else if (value > max_value) {
1714 if (errmsg) {
1715 PyErr_Format(PyExc_OverflowError,
1716 "value %ld is greater than '%s' maximum %ld",
1717 value, errmsg, max_value);
1718 }
1719 return 0;
1720 }
1721 return 1;
1722 }
1723
1724
1725 SWIGINTERN int
1726 SWIG_AsVal_long(PyObject* obj, long* val)
1727 {
1728 if (PyNumber_Check(obj)) {
1729 if (val) *val = PyInt_AsLong(obj);
1730 return 1;
1731 }
1732 else {
1733 SWIG_type_error("number", obj);
1734 }
1735 return 0;
1736 }
1737
1738
1739 #if INT_MAX != LONG_MAX
1740 SWIGINTERN int
1741 SWIG_AsVal_int(PyObject *obj, int *val)
1742 {
1743 const char* errmsg = val ? "int" : (char*)0;
1744 long v;
1745 if (SWIG_AsVal_long(obj, &v)) {
1746 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1747 if (val) *val = (int)(v);
1748 return 1;
1749 } else {
1750 return 0;
1751 }
1752 } else {
1753 PyErr_Clear();
1754 }
1755 if (val) {
1756 SWIG_type_error(errmsg, obj);
1757 }
1758 return 0;
1759 }
1760 #else
1761 SWIGINTERNSHORT int
1762 SWIG_AsVal_int(PyObject *obj, int *val)
1763 {
1764 return SWIG_AsVal_long(obj,(long*)val);
1765 }
1766 #endif
1767
1768
1769 SWIGINTERNSHORT int
1770 SWIG_As_int(PyObject* obj)
1771 {
1772 int v;
1773 if (!SWIG_AsVal_int(obj, &v)) {
1774 /*
1775 this is needed to make valgrind/purify happier.
1776 */
1777 memset((void*)&v, 0, sizeof(int));
1778 }
1779 return v;
1780 }
1781
1782
1783 SWIGINTERNSHORT int
1784 SWIG_Check_int(PyObject* obj)
1785 {
1786 return SWIG_AsVal_int(obj, (int*)0);
1787 }
1788
1789 static PyObject *wxSize_Get(wxSize *self){
1790 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1791 PyObject* tup = PyTuple_New(2);
1792 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1793 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1794 wxPyEndBlockThreads(blocked);
1795 return tup;
1796 }
1797
1798 SWIGINTERN int
1799 SWIG_AsVal_double(PyObject *obj, double* val)
1800 {
1801 if (PyNumber_Check(obj)) {
1802 if (val) *val = PyFloat_AsDouble(obj);
1803 return 1;
1804 }
1805 else {
1806 SWIG_type_error("number", obj);
1807 }
1808 return 0;
1809 }
1810
1811
1812 SWIGINTERNSHORT double
1813 SWIG_As_double(PyObject* obj)
1814 {
1815 double v;
1816 if (!SWIG_AsVal_double(obj, &v)) {
1817 /*
1818 this is needed to make valgrind/purify happier.
1819 */
1820 memset((void*)&v, 0, sizeof(double));
1821 }
1822 return v;
1823 }
1824
1825
1826 SWIGINTERNSHORT int
1827 SWIG_Check_double(PyObject* obj)
1828 {
1829 return SWIG_AsVal_double(obj, (double*)0);
1830 }
1831
1832
1833 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1834 #define SWIG_From_double PyFloat_FromDouble
1835 /*@@*/
1836
1837 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1838 self->x = x;
1839 self->y = y;
1840 }
1841 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1842 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1843 PyObject* tup = PyTuple_New(2);
1844 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1845 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1846 wxPyEndBlockThreads(blocked);
1847 return tup;
1848 }
1849
1850 SWIGINTERNSHORT long
1851 SWIG_As_long(PyObject* obj)
1852 {
1853 long v;
1854 if (!SWIG_AsVal_long(obj, &v)) {
1855 /*
1856 this is needed to make valgrind/purify happier.
1857 */
1858 memset((void*)&v, 0, sizeof(long));
1859 }
1860 return v;
1861 }
1862
1863
1864 SWIGINTERNSHORT int
1865 SWIG_Check_long(PyObject* obj)
1866 {
1867 return SWIG_AsVal_long(obj, (long*)0);
1868 }
1869
1870 static void wxPoint_Set(wxPoint *self,long x,long y){
1871 self->x = x;
1872 self->y = y;
1873 }
1874 static PyObject *wxPoint_Get(wxPoint *self){
1875 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1876 PyObject* tup = PyTuple_New(2);
1877 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1878 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1879 wxPyEndBlockThreads(blocked);
1880 return tup;
1881 }
1882 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1883 self->x = x;
1884 self->y = y;
1885 self->width = width;
1886 self->height = height;
1887 }
1888 static PyObject *wxRect_Get(wxRect *self){
1889 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1890 PyObject* tup = PyTuple_New(4);
1891 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1892 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1893 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1894 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1895 wxPyEndBlockThreads(blocked);
1896 return tup;
1897 }
1898
1899 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1900 wxRegion reg1(*r1);
1901 wxRegion reg2(*r2);
1902 wxRect dest(0,0,0,0);
1903 PyObject* obj;
1904
1905 reg1.Intersect(reg2);
1906 dest = reg1.GetBox();
1907
1908 if (dest != wxRect(0,0,0,0)) {
1909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1910 wxRect* newRect = new wxRect(dest);
1911 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1912 wxPyEndBlockThreads(blocked);
1913 return obj;
1914 }
1915 Py_INCREF(Py_None);
1916 return Py_None;
1917 }
1918
1919
1920 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1921 PyObject* o2;
1922 PyObject* o3;
1923
1924 if (!target) {
1925 target = o;
1926 } else if (target == Py_None) {
1927 Py_DECREF(Py_None);
1928 target = o;
1929 } else {
1930 if (!PyTuple_Check(target)) {
1931 o2 = target;
1932 target = PyTuple_New(1);
1933 PyTuple_SetItem(target, 0, o2);
1934 }
1935 o3 = PyTuple_New(1);
1936 PyTuple_SetItem(o3, 0, o);
1937
1938 o2 = target;
1939 target = PySequence_Concat(o2, o3);
1940 Py_DECREF(o2);
1941 Py_DECREF(o3);
1942 }
1943 return target;
1944 }
1945
1946
1947 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1948 self->m_x = x;
1949 self->m_y = y;
1950 }
1951 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1952 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1953 PyObject* tup = PyTuple_New(2);
1954 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1955 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1956 wxPyEndBlockThreads(blocked);
1957 return tup;
1958 }
1959
1960 #include "wx/wxPython/pyistream.h"
1961
1962 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1963 wxInputStream* wxis = wxPyCBInputStream::create(p);
1964 if (wxis)
1965 return new wxPyInputStream(wxis);
1966 else
1967 return NULL;
1968 }
1969
1970 SWIGINTERNSHORT PyObject*
1971 SWIG_From_char(char c)
1972 {
1973 return PyString_FromStringAndSize(&c,1);
1974 }
1975
1976
1977 SWIGINTERNSHORT PyObject*
1978 SWIG_From_unsigned_SS_long(unsigned long value)
1979 {
1980 return (value > LONG_MAX) ?
1981 PyLong_FromUnsignedLong(value)
1982 : PyInt_FromLong((long)(value));
1983 }
1984
1985
1986 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1987 SWIGINTERN int
1988 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1989 {
1990 static swig_type_info* pchar_info = 0;
1991 char* vptr = 0;
1992 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1993 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1994 if (cptr) *cptr = vptr;
1995 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1996 return SWIG_OLDOBJ;
1997 } else {
1998 PyErr_Clear();
1999 if (PyString_Check(obj)) {
2000 if (cptr) {
2001 *cptr = PyString_AS_STRING(obj);
2002 if (psize) {
2003 *psize = PyString_GET_SIZE(obj) + 1;
2004 }
2005 }
2006 return SWIG_PYSTR;
2007 }
2008 }
2009 if (cptr) {
2010 SWIG_type_error("char *", obj);
2011 }
2012 return 0;
2013 }
2014
2015
2016 SWIGINTERN int
2017 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2018 {
2019 char* cptr; size_t csize;
2020 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2021 /* in C you can do:
2022
2023 char x[5] = "hello";
2024
2025 ie, assing the array using an extra '0' char.
2026 */
2027 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2028 if (csize <= size) {
2029 if (val) {
2030 if (csize) memcpy(val, cptr, csize);
2031 if (csize < size) memset(val + csize, 0, size - csize);
2032 }
2033 return 1;
2034 }
2035 }
2036 if (val) {
2037 PyErr_Format(PyExc_TypeError,
2038 "a char array of maximum size %lu is expected",
2039 (unsigned long) size);
2040 }
2041 return 0;
2042 }
2043
2044
2045 SWIGINTERN int
2046 SWIG_AsVal_char(PyObject *obj, char *val)
2047 {
2048 const char* errmsg = val ? "char" : (char*)0;
2049 long v;
2050 if (SWIG_AsVal_long(obj, &v)) {
2051 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2052 if (val) *val = (char)(v);
2053 return 1;
2054 } else {
2055 return 0;
2056 }
2057 } else {
2058 PyErr_Clear();
2059 return SWIG_AsCharArray(obj, val, 1);
2060 }
2061 }
2062
2063
2064 SWIGINTERNSHORT char
2065 SWIG_As_char(PyObject* obj)
2066 {
2067 char v;
2068 if (!SWIG_AsVal_char(obj, &v)) {
2069 /*
2070 this is needed to make valgrind/purify happier.
2071 */
2072 memset((void*)&v, 0, sizeof(char));
2073 }
2074 return v;
2075 }
2076
2077
2078 SWIGINTERNSHORT int
2079 SWIG_Check_char(PyObject* obj)
2080 {
2081 return SWIG_AsVal_char(obj, (char*)0);
2082 }
2083
2084
2085 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2086 #define SWIG_From_long PyInt_FromLong
2087 /*@@*/
2088
2089 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2090 // We use only strings for the streams, not unicode
2091 PyObject* str = PyObject_Str(obj);
2092 if (! str) {
2093 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2094 return;
2095 }
2096 self->Write(PyString_AS_STRING(str),
2097 PyString_GET_SIZE(str));
2098 Py_DECREF(str);
2099 }
2100
2101 #include "wx/wxPython/pyistream.h"
2102
2103
2104 class wxPyFileSystemHandler : public wxFileSystemHandler
2105 {
2106 public:
2107 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2108
2109 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2110 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2111 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2112 DEC_PYCALLBACK_STRING__pure(FindNext);
2113
2114 wxString GetProtocol(const wxString& location) {
2115 return wxFileSystemHandler::GetProtocol(location);
2116 }
2117
2118 wxString GetLeftLocation(const wxString& location) {
2119 return wxFileSystemHandler::GetLeftLocation(location);
2120 }
2121
2122 wxString GetAnchor(const wxString& location) {
2123 return wxFileSystemHandler::GetAnchor(location);
2124 }
2125
2126 wxString GetRightLocation(const wxString& location) {
2127 return wxFileSystemHandler::GetRightLocation(location);
2128 }
2129
2130 wxString GetMimeTypeFromExt(const wxString& location) {
2131 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2132 }
2133
2134 PYPRIVATE;
2135 };
2136
2137
2138 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2139 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2140 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2141 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2142
2143
2144 SWIGINTERN int
2145 SWIG_AsVal_bool(PyObject *obj, bool *val)
2146 {
2147 if (obj == Py_True) {
2148 if (val) *val = true;
2149 return 1;
2150 }
2151 if (obj == Py_False) {
2152 if (val) *val = false;
2153 return 1;
2154 }
2155 int res = 0;
2156 if (SWIG_AsVal_int(obj, &res)) {
2157 if (val) *val = res ? true : false;
2158 return 1;
2159 } else {
2160 PyErr_Clear();
2161 }
2162 if (val) {
2163 SWIG_type_error("bool", obj);
2164 }
2165 return 0;
2166 }
2167
2168
2169 SWIGINTERNSHORT bool
2170 SWIG_As_bool(PyObject* obj)
2171 {
2172 bool v;
2173 if (!SWIG_AsVal_bool(obj, &v)) {
2174 /*
2175 this is needed to make valgrind/purify happier.
2176 */
2177 memset((void*)&v, 0, sizeof(bool));
2178 }
2179 return v;
2180 }
2181
2182
2183 SWIGINTERNSHORT int
2184 SWIG_Check_bool(PyObject* obj)
2185 {
2186 return SWIG_AsVal_bool(obj, (bool*)0);
2187 }
2188
2189 static wxString FileSystem_URLToFileName(wxString const &url){
2190 wxFileName fname = wxFileSystem::URLToFileName(url);
2191 return fname.GetFullPath();
2192 }
2193
2194 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2195 wxImage& image,
2196 long type) {
2197 wxMemoryFSHandler::AddFile(filename, image, type);
2198 }
2199
2200 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2201 const wxBitmap& bitmap,
2202 long type) {
2203 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2204 }
2205
2206 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2207 PyObject* data) {
2208 if (! PyString_Check(data)) {
2209 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2210 "Expected string object"));
2211 return;
2212 }
2213
2214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2215 void* ptr = (void*)PyString_AsString(data);
2216 size_t size = PyString_Size(data);
2217 wxPyEndBlockThreads(blocked);
2218
2219 wxMemoryFSHandler::AddFile(filename, ptr, size);
2220 }
2221
2222
2223 #include "wx/wxPython/pyistream.h"
2224
2225
2226 SWIGINTERN int
2227 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2228 {
2229 long v = 0;
2230 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2231 SWIG_type_error("unsigned number", obj);
2232 }
2233 else if (val)
2234 *val = (unsigned long)v;
2235 return 1;
2236 }
2237
2238
2239 SWIGINTERNSHORT int
2240 SWIG_CheckUnsignedLongInRange(unsigned long value,
2241 unsigned long max_value,
2242 const char *errmsg)
2243 {
2244 if (value > max_value) {
2245 if (errmsg) {
2246 PyErr_Format(PyExc_OverflowError,
2247 "value %lu is greater than '%s' minimum %lu",
2248 value, errmsg, max_value);
2249 }
2250 return 0;
2251 }
2252 return 1;
2253 }
2254
2255
2256 SWIGINTERN int
2257 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2258 {
2259 const char* errmsg = val ? "unsigned char" : (char*)0;
2260 unsigned long v;
2261 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2262 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2263 if (val) *val = (unsigned char)(v);
2264 return 1;
2265 } else {
2266 return 0;
2267 }
2268 } else {
2269 PyErr_Clear();
2270 }
2271 if (val) {
2272 SWIG_type_error(errmsg, obj);
2273 }
2274 return 0;
2275 }
2276
2277
2278 SWIGINTERNSHORT unsigned char
2279 SWIG_As_unsigned_SS_char(PyObject* obj)
2280 {
2281 unsigned char v;
2282 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2283 /*
2284 this is needed to make valgrind/purify happier.
2285 */
2286 memset((void*)&v, 0, sizeof(unsigned char));
2287 }
2288 return v;
2289 }
2290
2291
2292 SWIGINTERNSHORT int
2293 SWIG_Check_unsigned_SS_char(PyObject* obj)
2294 {
2295 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2296 }
2297
2298
2299 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2300 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2301 /*@@*/
2302
2303
2304 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2305 if (width > 0 && height > 0)
2306 return new wxImage(width, height, clear);
2307 else
2308 return new wxImage;
2309 }
2310 static wxImage *new_wxImage(wxBitmap const &bitmap){
2311 return new wxImage(bitmap.ConvertToImage());
2312 }
2313 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2314 // Copy the source data so the wxImage can clean it up later
2315 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2316 if (copy == NULL) {
2317 PyErr_NoMemory();
2318 return NULL;
2319 }
2320 memcpy(copy, data, width*height*3);
2321 return new wxImage(width, height, copy, false);
2322 }
2323 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2324 // Copy the source data so the wxImage can clean it up later
2325 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2326 if (dcopy == NULL) {
2327 PyErr_NoMemory();
2328 return NULL;
2329 }
2330 memcpy(dcopy, data, width*height*3);
2331 unsigned char* acopy = (unsigned char*)malloc(width*height);
2332 if (acopy == NULL) {
2333 PyErr_NoMemory();
2334 return NULL;
2335 }
2336 memcpy(acopy, alpha, width*height);
2337
2338 return new wxImage(width, height, dcopy, acopy, false);
2339 }
2340 static wxSize wxImage_GetSize(wxImage *self){
2341 wxSize size(self->GetWidth(), self->GetHeight());
2342 return size;
2343 }
2344 static PyObject *wxImage_GetData(wxImage *self){
2345 unsigned char* data = self->GetData();
2346 int len = self->GetWidth() * self->GetHeight() * 3;
2347 PyObject* rv;
2348 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2349 return rv;
2350 }
2351 static void wxImage_SetData(wxImage *self,PyObject *data){
2352 unsigned char* dataPtr;
2353
2354 if (! PyString_Check(data)) {
2355 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2356 "Expected string object"));
2357 return /* NULL */ ;
2358 }
2359
2360 size_t len = self->GetWidth() * self->GetHeight() * 3;
2361 dataPtr = (unsigned char*) malloc(len);
2362 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2363 self->SetData(dataPtr);
2364 // wxImage takes ownership of dataPtr...
2365 }
2366 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2367 unsigned char* data = self->GetData();
2368 int len = self->GetWidth() * self->GetHeight() * 3;
2369 PyObject* rv;
2370 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2371 return rv;
2372 }
2373 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2374 unsigned char* buffer;
2375 int size;
2376
2377 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2378 if (!PyArg_Parse(data, "t#", &buffer, &size))
2379 goto done;
2380
2381 if (size != self->GetWidth() * self->GetHeight() * 3) {
2382 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2383 goto done;
2384 }
2385 self->SetData(buffer);
2386 done:
2387 wxPyEndBlockThreads(blocked);
2388 }
2389 static PyObject *wxImage_GetAlphaData(wxImage *self){
2390 unsigned char* data = self->GetAlpha();
2391 if (! data) {
2392 RETURN_NONE();
2393 } else {
2394 int len = self->GetWidth() * self->GetHeight();
2395 PyObject* rv;
2396 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2397 return rv;
2398 }
2399 }
2400 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2401 unsigned char* dataPtr;
2402
2403 if (! PyString_Check(data)) {
2404 PyErr_SetString(PyExc_TypeError, "Expected string object");
2405 return /* NULL */ ;
2406 }
2407
2408 size_t len = self->GetWidth() * self->GetHeight();
2409 dataPtr = (unsigned char*) malloc(len);
2410 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2411 self->SetAlpha(dataPtr);
2412 // wxImage takes ownership of dataPtr...
2413 }
2414 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2415 unsigned char* data = self->GetAlpha();
2416 int len = self->GetWidth() * self->GetHeight();
2417 PyObject* rv;
2418 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2419 return rv;
2420 }
2421 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2422 unsigned char* buffer;
2423 int size;
2424
2425 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2426 if (!PyArg_Parse(data, "t#", &buffer, &size))
2427 goto done;
2428
2429 if (size != self->GetWidth() * self->GetHeight()) {
2430 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2431 goto done;
2432 }
2433 self->SetAlpha(buffer);
2434 done:
2435 wxPyEndBlockThreads(blocked);
2436 }
2437
2438 SWIGINTERNSHORT unsigned long
2439 SWIG_As_unsigned_SS_long(PyObject* obj)
2440 {
2441 unsigned long v;
2442 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2443 /*
2444 this is needed to make valgrind/purify happier.
2445 */
2446 memset((void*)&v, 0, sizeof(unsigned long));
2447 }
2448 return v;
2449 }
2450
2451
2452 SWIGINTERNSHORT int
2453 SWIG_Check_unsigned_SS_long(PyObject* obj)
2454 {
2455 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2456 }
2457
2458 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2459 wxBitmap bitmap(*self, depth);
2460 return bitmap;
2461 }
2462 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2463 wxImage mono = self->ConvertToMono( red, green, blue );
2464 wxBitmap bitmap( mono, 1 );
2465 return bitmap;
2466 }
2467 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2468 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2470 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2474 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2475 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2476 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2477 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2478 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2479 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2480 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2481 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2482
2483 #include <wx/quantize.h>
2484
2485 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2486 return wxQuantize::Quantize(src, dest,
2487 //NULL, // palette
2488 desiredNoColours,
2489 NULL, // eightBitData
2490 flags);
2491 }
2492 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2493 if (PyCallable_Check(func)) {
2494 self->Connect(id, lastId, eventType,
2495 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2496 new wxPyCallback(func));
2497 }
2498 else if (func == Py_None) {
2499 self->Disconnect(id, lastId, eventType,
2500 (wxObjectEventFunction)
2501 &wxPyCallback::EventThunker);
2502 }
2503 else {
2504 wxPyBLOCK_THREADS(
2505 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2506 }
2507 }
2508 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2509 return self->Disconnect(id, lastId, eventType,
2510 (wxObjectEventFunction)
2511 &wxPyCallback::EventThunker);
2512 }
2513 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2514 if (_self && _self != Py_None) {
2515 self->SetClientObject(new wxPyOORClientData(_self, incref));
2516 }
2517 else {
2518 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2519 if (data) {
2520 self->SetClientObject(NULL); // This will delete it too
2521 }
2522 }
2523 }
2524
2525 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2526 #if wxUSE_UNICODE
2527 return self->GetUnicodeKey();
2528 #else
2529 return 0;
2530 #endif
2531 }
2532
2533 #if UINT_MAX < LONG_MAX
2534 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2535 #define SWIG_From_unsigned_SS_int SWIG_From_long
2536 /*@@*/
2537 #else
2538 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2539 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2540 /*@@*/
2541 #endif
2542
2543
2544 #if UINT_MAX != ULONG_MAX
2545 SWIGINTERN int
2546 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2547 {
2548 const char* errmsg = val ? "unsigned int" : (char*)0;
2549 unsigned long v;
2550 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2551 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2552 if (val) *val = (unsigned int)(v);
2553 return 1;
2554 }
2555 } else {
2556 PyErr_Clear();
2557 }
2558 if (val) {
2559 SWIG_type_error(errmsg, obj);
2560 }
2561 return 0;
2562 }
2563 #else
2564 SWIGINTERNSHORT unsigned int
2565 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2566 {
2567 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2568 }
2569 #endif
2570
2571
2572 SWIGINTERNSHORT unsigned int
2573 SWIG_As_unsigned_SS_int(PyObject* obj)
2574 {
2575 unsigned int v;
2576 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2577 /*
2578 this is needed to make valgrind/purify happier.
2579 */
2580 memset((void*)&v, 0, sizeof(unsigned int));
2581 }
2582 return v;
2583 }
2584
2585
2586 SWIGINTERNSHORT int
2587 SWIG_Check_unsigned_SS_int(PyObject* obj)
2588 {
2589 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2590 }
2591
2592 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2593 self->m_size = size;
2594 }
2595 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2596 int count = self->GetNumberOfFiles();
2597 wxString* files = self->GetFiles();
2598 PyObject* list = PyList_New(count);
2599
2600 if (!list) {
2601 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2602 return NULL;
2603 }
2604
2605 for (int i=0; i<count; i++) {
2606 PyList_SetItem(list, i, wx2PyString(files[i]));
2607 }
2608 return list;
2609 }
2610
2611
2612 static wxPyApp *new_wxPyApp(){
2613 wxPythonApp = new wxPyApp();
2614 return wxPythonApp;
2615 }
2616 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2617
2618 void wxApp_CleanUp() {
2619 __wxPyCleanup();
2620 }
2621
2622
2623 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2624
2625
2626 SWIGINTERNSHORT int
2627 SWIG_AsCharPtr(PyObject *obj, char **val)
2628 {
2629 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2630 return 1;
2631 }
2632 if (val) {
2633 PyErr_Clear();
2634 SWIG_type_error("char *", obj);
2635 }
2636 return 0;
2637 }
2638
2639
2640 SWIGINTERN PyObject *
2641 SWIG_FromCharPtr(const char* cptr)
2642 {
2643 if (cptr) {
2644 size_t size = strlen(cptr);
2645 if (size > INT_MAX) {
2646 return SWIG_NewPointerObj((char*)(cptr),
2647 SWIG_TypeQuery("char *"), 0);
2648 } else {
2649 if (size != 0) {
2650 return PyString_FromStringAndSize(cptr, size);
2651 } else {
2652 return PyString_FromString(cptr);
2653 }
2654 }
2655 }
2656 Py_INCREF(Py_None);
2657 return Py_None;
2658 }
2659
2660
2661 #ifdef __WXMAC__
2662
2663 // A dummy class that raises an exception if used...
2664 class wxEventLoop
2665 {
2666 public:
2667 wxEventLoop() { wxPyRaiseNotImplemented(); }
2668 int Run() { return 0; }
2669 void Exit(int rc = 0) {}
2670 bool Pending() const { return false; }
2671 bool Dispatch() { return false; }
2672 bool IsRunning() const { return false; }
2673 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2674 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2675 };
2676
2677 #else
2678
2679 #include <wx/evtloop.h>
2680
2681 #endif
2682
2683
2684
2685 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2686 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2687 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2688 static PyObject *wxWindow_GetChildren(wxWindow *self){
2689 wxWindowList& list = self->GetChildren();
2690 return wxPy_ConvertList(&list);
2691 }
2692 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2693 #if wxUSE_HOTKEY
2694 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2695 #else
2696 return false;
2697 #endif
2698 }
2699 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2700
2701
2702
2703 return false;
2704
2705 }
2706 static long wxWindow_GetHandle(wxWindow *self){
2707 return wxPyGetWinHandle(self);
2708 }
2709 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2710 self->AssociateHandle((WXWidget)handle);
2711 }
2712
2713 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2714 return wxWindow::FindWindowById(id, parent);
2715 }
2716
2717 wxWindow* wxFindWindowByName( const wxString& name,
2718 const wxWindow *parent = NULL ) {
2719 return wxWindow::FindWindowByName(name, parent);
2720 }
2721
2722 wxWindow* wxFindWindowByLabel( const wxString& label,
2723 const wxWindow *parent = NULL ) {
2724 return wxWindow::FindWindowByLabel(label, parent);
2725 }
2726
2727
2728 #ifdef __WXMSW__
2729 #include <wx/msw/private.h> // to get wxGetWindowId
2730 #endif
2731
2732
2733 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2734 #ifdef __WXMSW__
2735 WXHWND hWnd = (WXHWND)_hWnd;
2736 long id = wxGetWindowId(hWnd);
2737 wxWindow* win = new wxWindow;
2738 parent->AddChild(win);
2739 win->SetEventHandler(win);
2740 win->SetHWND(hWnd);
2741 win->SetId(id);
2742 win->SubclassWin(hWnd);
2743 win->AdoptAttributesFromHWND();
2744 win->SetupColours();
2745 return win;
2746 #else
2747 wxPyRaiseNotImplemented();
2748 return NULL;
2749 #endif
2750 }
2751
2752
2753 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2754 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2755 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2756
2757 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2758
2759 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2760 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2761 wxMenuItemList& list = self->GetMenuItems();
2762 return wxPy_ConvertList(&list);
2763 }
2764 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2765 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2766 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2767 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2768 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2769 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2770 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2771 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2772 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2773 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2774 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2775 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2776 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2777 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2778 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2779 static const wxString wxPyControlNameStr(wxControlNameStr);
2780 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2781 if (clientData) {
2782 wxPyClientData* data = new wxPyClientData(clientData);
2783 return self->Append(item, data);
2784 } else
2785 return self->Append(item);
2786 }
2787 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2788 if (clientData) {
2789 wxPyClientData* data = new wxPyClientData(clientData);
2790 return self->Insert(item, pos, data);
2791 } else
2792 return self->Insert(item, pos);
2793 }
2794 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2795 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2796 if (data) {
2797 Py_INCREF(data->m_obj);
2798 return data->m_obj;
2799 } else {
2800 Py_INCREF(Py_None);
2801 return Py_None;
2802 }
2803 }
2804 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2805 wxPyClientData* data = new wxPyClientData(clientData);
2806 self->SetClientObject(n, data);
2807 }
2808
2809
2810 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2811 wxPyUserData* data = NULL;
2812 if ( userData ) {
2813 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2814 data = new wxPyUserData(userData);
2815 wxPyEndBlockThreads(blocked);
2816 }
2817 return new wxSizerItem(window, proportion, flag, border, data);
2818 }
2819 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2820 wxPyUserData* data = NULL;
2821 if ( userData ) {
2822 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2823 data = new wxPyUserData(userData);
2824 wxPyEndBlockThreads(blocked);
2825 }
2826 return new wxSizerItem(width, height, proportion, flag, border, data);
2827 }
2828 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2829 wxPyUserData* data = NULL;
2830 if ( userData ) {
2831 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2832 data = new wxPyUserData(userData);
2833 wxPyEndBlockThreads(blocked);
2834 }
2835 return new wxSizerItem(sizer, proportion, flag, border, data);
2836 }
2837
2838 #include <float.h>
2839 SWIGINTERN int
2840 SWIG_CheckDoubleInRange(double value, double min_value,
2841 double max_value, const char* errmsg)
2842 {
2843 if (value < min_value) {
2844 if (errmsg) {
2845 PyErr_Format(PyExc_OverflowError,
2846 "value %g is less than %s minimum %g",
2847 value, errmsg, min_value);
2848 }
2849 return 0;
2850 } else if (value > max_value) {
2851 if (errmsg) {
2852 PyErr_Format(PyExc_OverflowError,
2853 "value %g is greater than %s maximum %g",
2854 value, errmsg, max_value);
2855 }
2856 return 0;
2857 }
2858 return 1;
2859 }
2860
2861
2862 SWIGINTERN int
2863 SWIG_AsVal_float(PyObject *obj, float *val)
2864 {
2865 const char* errmsg = val ? "float" : (char*)0;
2866 double v;
2867 if (SWIG_AsVal_double(obj, &v)) {
2868 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2869 if (val) *val = (float)(v);
2870 return 1;
2871 } else {
2872 return 0;
2873 }
2874 } else {
2875 PyErr_Clear();
2876 }
2877 if (val) {
2878 SWIG_type_error(errmsg, obj);
2879 }
2880 return 0;
2881 }
2882
2883
2884 SWIGINTERNSHORT float
2885 SWIG_As_float(PyObject* obj)
2886 {
2887 float v;
2888 if (!SWIG_AsVal_float(obj, &v)) {
2889 /*
2890 this is needed to make valgrind/purify happier.
2891 */
2892 memset((void*)&v, 0, sizeof(float));
2893 }
2894 return v;
2895 }
2896
2897
2898 SWIGINTERNSHORT int
2899 SWIG_Check_float(PyObject* obj)
2900 {
2901 return SWIG_AsVal_float(obj, (float*)0);
2902 }
2903
2904
2905 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2906 #define SWIG_From_float PyFloat_FromDouble
2907 /*@@*/
2908
2909 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2910 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2911 if (data) {
2912 Py_INCREF(data->m_obj);
2913 return data->m_obj;
2914 } else {
2915 Py_INCREF(Py_None);
2916 return Py_None;
2917 }
2918 }
2919
2920 // Figure out the type of the sizer item
2921
2922 struct wxPySizerItemInfo {
2923 wxPySizerItemInfo()
2924 : window(NULL), sizer(NULL), gotSize(false),
2925 size(wxDefaultSize), gotPos(false), pos(-1)
2926 {}
2927
2928 wxWindow* window;
2929 wxSizer* sizer;
2930 bool gotSize;
2931 wxSize size;
2932 bool gotPos;
2933 int pos;
2934 };
2935
2936 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2937
2938 wxPySizerItemInfo info;
2939 wxSize size;
2940 wxSize* sizePtr = &size;
2941
2942 // Find out what the type of the item is
2943 // try wxWindow
2944 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2945 PyErr_Clear();
2946 info.window = NULL;
2947
2948 // try wxSizer
2949 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2950 PyErr_Clear();
2951 info.sizer = NULL;
2952
2953 // try wxSize or (w,h)
2954 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2955 info.size = *sizePtr;
2956 info.gotSize = true;
2957 }
2958
2959 // or a single int
2960 if (checkIdx && PyInt_Check(item)) {
2961 info.pos = PyInt_AsLong(item);
2962 info.gotPos = true;
2963 }
2964 }
2965 }
2966
2967 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2968 // no expected type, figure out what kind of error message to generate
2969 if ( !checkSize && !checkIdx )
2970 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2971 else if ( checkSize && !checkIdx )
2972 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2973 else if ( !checkSize && checkIdx)
2974 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2975 else
2976 // can this one happen?
2977 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2978 }
2979
2980 return info;
2981 }
2982
2983 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2984 if (!self->GetClientObject())
2985 self->SetClientObject(new wxPyOORClientData(_self));
2986 }
2987 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2988
2989 wxPyUserData* data = NULL;
2990 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2991 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2992 if ( userData && (info.window || info.sizer || info.gotSize) )
2993 data = new wxPyUserData(userData);
2994 wxPyEndBlockThreads(blocked);
2995
2996 // Now call the real Add method if a valid item type was found
2997 if ( info.window )
2998 return self->Add(info.window, proportion, flag, border, data);
2999 else if ( info.sizer )
3000 return self->Add(info.sizer, proportion, flag, border, data);
3001 else if (info.gotSize)
3002 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3003 proportion, flag, border, data);
3004 else
3005 return NULL;
3006 }
3007 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3008
3009 wxPyUserData* data = NULL;
3010 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3011 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3012 if ( userData && (info.window || info.sizer || info.gotSize) )
3013 data = new wxPyUserData(userData);
3014 wxPyEndBlockThreads(blocked);
3015
3016 // Now call the real Insert method if a valid item type was found
3017 if ( info.window )
3018 return self->Insert(before, info.window, proportion, flag, border, data);
3019 else if ( info.sizer )
3020 return self->Insert(before, info.sizer, proportion, flag, border, data);
3021 else if (info.gotSize)
3022 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3023 proportion, flag, border, data);
3024 else
3025 return NULL;
3026 }
3027 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3028
3029 wxPyUserData* data = NULL;
3030 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3031 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3032 if ( userData && (info.window || info.sizer || info.gotSize) )
3033 data = new wxPyUserData(userData);
3034 wxPyEndBlockThreads(blocked);
3035
3036 // Now call the real Prepend method if a valid item type was found
3037 if ( info.window )
3038 return self->Prepend(info.window, proportion, flag, border, data);
3039 else if ( info.sizer )
3040 return self->Prepend(info.sizer, proportion, flag, border, data);
3041 else if (info.gotSize)
3042 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3043 proportion, flag, border, data);
3044 else
3045 return NULL;
3046 }
3047 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3048 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3049 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3050 wxPyEndBlockThreads(blocked);
3051 if ( info.window )
3052 return self->Remove(info.window);
3053 else if ( info.sizer )
3054 return self->Remove(info.sizer);
3055 else if ( info.gotPos )
3056 return self->Remove(info.pos);
3057 else
3058 return false;
3059 }
3060 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3061 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3062 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3063 wxPyEndBlockThreads(blocked);
3064 if ( info.window )
3065 return self->Detach(info.window);
3066 else if ( info.sizer )
3067 return self->Detach(info.sizer);
3068 else if ( info.gotPos )
3069 return self->Detach(info.pos);
3070 else
3071 return false;
3072 }
3073 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3074 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3075 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3076 wxPyEndBlockThreads(blocked);
3077 if ( info.window )
3078 return self->GetItem(info.window);
3079 else if ( info.sizer )
3080 return self->GetItem(info.sizer);
3081 else if ( info.gotPos )
3082 return self->GetItem(info.pos);
3083 else
3084 return NULL;
3085 }
3086 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3087 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3088 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3089 wxPyEndBlockThreads(blocked);
3090 if ( info.window )
3091 self->SetItemMinSize(info.window, size);
3092 else if ( info.sizer )
3093 self->SetItemMinSize(info.sizer, size);
3094 else if ( info.gotPos )
3095 self->SetItemMinSize(info.pos, size);
3096 }
3097 static PyObject *wxSizer_GetChildren(wxSizer *self){
3098 wxSizerItemList& list = self->GetChildren();
3099 return wxPy_ConvertList(&list);
3100 }
3101 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3102 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3103 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3104 wxPyEndBlockThreads(blocked);
3105 if ( info.window )
3106 return self->Show(info.window, show, recursive);
3107 else if ( info.sizer )
3108 return self->Show(info.sizer, show, recursive);
3109 else if ( info.gotPos )
3110 return self->Show(info.pos, show);
3111 else
3112 return false;
3113 }
3114 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3115 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3116 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3117 wxPyEndBlockThreads(blocked);
3118 if ( info.window )
3119 return self->IsShown(info.window);
3120 else if ( info.sizer )
3121 return self->IsShown(info.sizer);
3122 else if ( info.gotPos )
3123 return self->IsShown(info.pos);
3124 else
3125 return false;
3126 }
3127
3128 // See pyclasses.h
3129 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3130 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3131 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3132
3133
3134
3135
3136 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3137 {
3138 if (source == Py_None) {
3139 **obj = wxGBPosition(-1,-1);
3140 return true;
3141 }
3142 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3143 }
3144
3145 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3146 {
3147 if (source == Py_None) {
3148 **obj = wxGBSpan(-1,-1);
3149 return true;
3150 }
3151 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3152 }
3153
3154
3155 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3156 self->SetRow(row);
3157 self->SetCol(col);
3158 }
3159 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3161 PyObject* tup = PyTuple_New(2);
3162 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3163 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3164 wxPyEndBlockThreads(blocked);
3165 return tup;
3166 }
3167 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3168 self->SetRowspan(rowspan);
3169 self->SetColspan(colspan);
3170 }
3171 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3173 PyObject* tup = PyTuple_New(2);
3174 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3175 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3176 wxPyEndBlockThreads(blocked);
3177 return tup;
3178 }
3179 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3180 wxPyUserData* data = NULL;
3181 if ( userData ) {
3182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3183 data = new wxPyUserData(userData);
3184 wxPyEndBlockThreads(blocked);
3185 }
3186 return new wxGBSizerItem(window, pos, span, flag, border, data);
3187 }
3188 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3189 wxPyUserData* data = NULL;
3190 if ( userData ) {
3191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3192 data = new wxPyUserData(userData);
3193 wxPyEndBlockThreads(blocked);
3194 }
3195 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3196 }
3197 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3198 wxPyUserData* data = NULL;
3199 if ( userData ) {
3200 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 data = new wxPyUserData(userData);
3202 wxPyEndBlockThreads(blocked);
3203 }
3204 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3205 }
3206 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3207 int row, col;
3208 self->GetEndPos(row, col);
3209 return wxGBPosition(row, col);
3210 }
3211 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3212
3213 wxPyUserData* data = NULL;
3214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3215 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3216 if ( userData && (info.window || info.sizer || info.gotSize) )
3217 data = new wxPyUserData(userData);
3218 wxPyEndBlockThreads(blocked);
3219
3220 // Now call the real Add method if a valid item type was found
3221 if ( info.window )
3222 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3223 else if ( info.sizer )
3224 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3225 else if (info.gotSize)
3226 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3227 pos, span, flag, border, data);
3228 return NULL;
3229 }
3230
3231
3232 #ifdef __cplusplus
3233 extern "C" {
3234 #endif
3235 static int _wrap_EmptyString_set(PyObject *) {
3236 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3237 return 1;
3238 }
3239
3240
3241 static PyObject *_wrap_EmptyString_get(void) {
3242 PyObject *pyobj;
3243
3244 {
3245 #if wxUSE_UNICODE
3246 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3247 #else
3248 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3249 #endif
3250 }
3251 return pyobj;
3252 }
3253
3254
3255 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3256 PyObject *resultobj;
3257 wxObject *arg1 = (wxObject *) 0 ;
3258 wxString result;
3259 PyObject * obj0 = 0 ;
3260 char *kwnames[] = {
3261 (char *) "self", NULL
3262 };
3263
3264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3266 if (SWIG_arg_fail(1)) SWIG_fail;
3267 {
3268 PyThreadState* __tstate = wxPyBeginAllowThreads();
3269 result = wxObject_GetClassName(arg1);
3270
3271 wxPyEndAllowThreads(__tstate);
3272 if (PyErr_Occurred()) SWIG_fail;
3273 }
3274 {
3275 #if wxUSE_UNICODE
3276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3277 #else
3278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3279 #endif
3280 }
3281 return resultobj;
3282 fail:
3283 return NULL;
3284 }
3285
3286
3287 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3288 PyObject *resultobj;
3289 wxObject *arg1 = (wxObject *) 0 ;
3290 PyObject * obj0 = 0 ;
3291 char *kwnames[] = {
3292 (char *) "self", NULL
3293 };
3294
3295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3297 if (SWIG_arg_fail(1)) SWIG_fail;
3298 {
3299 PyThreadState* __tstate = wxPyBeginAllowThreads();
3300 wxObject_Destroy(arg1);
3301
3302 wxPyEndAllowThreads(__tstate);
3303 if (PyErr_Occurred()) SWIG_fail;
3304 }
3305 Py_INCREF(Py_None); resultobj = Py_None;
3306 return resultobj;
3307 fail:
3308 return NULL;
3309 }
3310
3311
3312 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3313 PyObject *obj;
3314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3315 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3316 Py_INCREF(obj);
3317 return Py_BuildValue((char *)"");
3318 }
3319 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3320 PyObject *resultobj;
3321 wxSize *arg1 = (wxSize *) 0 ;
3322 int arg2 ;
3323 PyObject * obj0 = 0 ;
3324 PyObject * obj1 = 0 ;
3325 char *kwnames[] = {
3326 (char *) "self",(char *) "x", NULL
3327 };
3328
3329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3331 if (SWIG_arg_fail(1)) SWIG_fail;
3332 {
3333 arg2 = (int)(SWIG_As_int(obj1));
3334 if (SWIG_arg_fail(2)) SWIG_fail;
3335 }
3336 if (arg1) (arg1)->x = arg2;
3337
3338 Py_INCREF(Py_None); resultobj = Py_None;
3339 return resultobj;
3340 fail:
3341 return NULL;
3342 }
3343
3344
3345 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3346 PyObject *resultobj;
3347 wxSize *arg1 = (wxSize *) 0 ;
3348 int result;
3349 PyObject * obj0 = 0 ;
3350 char *kwnames[] = {
3351 (char *) "self", NULL
3352 };
3353
3354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3356 if (SWIG_arg_fail(1)) SWIG_fail;
3357 result = (int) ((arg1)->x);
3358
3359 {
3360 resultobj = SWIG_From_int((int)(result));
3361 }
3362 return resultobj;
3363 fail:
3364 return NULL;
3365 }
3366
3367
3368 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3369 PyObject *resultobj;
3370 wxSize *arg1 = (wxSize *) 0 ;
3371 int arg2 ;
3372 PyObject * obj0 = 0 ;
3373 PyObject * obj1 = 0 ;
3374 char *kwnames[] = {
3375 (char *) "self",(char *) "y", NULL
3376 };
3377
3378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3380 if (SWIG_arg_fail(1)) SWIG_fail;
3381 {
3382 arg2 = (int)(SWIG_As_int(obj1));
3383 if (SWIG_arg_fail(2)) SWIG_fail;
3384 }
3385 if (arg1) (arg1)->y = arg2;
3386
3387 Py_INCREF(Py_None); resultobj = Py_None;
3388 return resultobj;
3389 fail:
3390 return NULL;
3391 }
3392
3393
3394 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3395 PyObject *resultobj;
3396 wxSize *arg1 = (wxSize *) 0 ;
3397 int result;
3398 PyObject * obj0 = 0 ;
3399 char *kwnames[] = {
3400 (char *) "self", NULL
3401 };
3402
3403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3405 if (SWIG_arg_fail(1)) SWIG_fail;
3406 result = (int) ((arg1)->y);
3407
3408 {
3409 resultobj = SWIG_From_int((int)(result));
3410 }
3411 return resultobj;
3412 fail:
3413 return NULL;
3414 }
3415
3416
3417 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3418 PyObject *resultobj;
3419 int arg1 = (int) 0 ;
3420 int arg2 = (int) 0 ;
3421 wxSize *result;
3422 PyObject * obj0 = 0 ;
3423 PyObject * obj1 = 0 ;
3424 char *kwnames[] = {
3425 (char *) "w",(char *) "h", NULL
3426 };
3427
3428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3429 if (obj0) {
3430 {
3431 arg1 = (int)(SWIG_As_int(obj0));
3432 if (SWIG_arg_fail(1)) SWIG_fail;
3433 }
3434 }
3435 if (obj1) {
3436 {
3437 arg2 = (int)(SWIG_As_int(obj1));
3438 if (SWIG_arg_fail(2)) SWIG_fail;
3439 }
3440 }
3441 {
3442 PyThreadState* __tstate = wxPyBeginAllowThreads();
3443 result = (wxSize *)new wxSize(arg1,arg2);
3444
3445 wxPyEndAllowThreads(__tstate);
3446 if (PyErr_Occurred()) SWIG_fail;
3447 }
3448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3449 return resultobj;
3450 fail:
3451 return NULL;
3452 }
3453
3454
3455 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3456 PyObject *resultobj;
3457 wxSize *arg1 = (wxSize *) 0 ;
3458 PyObject * obj0 = 0 ;
3459 char *kwnames[] = {
3460 (char *) "self", NULL
3461 };
3462
3463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3465 if (SWIG_arg_fail(1)) SWIG_fail;
3466 {
3467 PyThreadState* __tstate = wxPyBeginAllowThreads();
3468 delete arg1;
3469
3470 wxPyEndAllowThreads(__tstate);
3471 if (PyErr_Occurred()) SWIG_fail;
3472 }
3473 Py_INCREF(Py_None); resultobj = Py_None;
3474 return resultobj;
3475 fail:
3476 return NULL;
3477 }
3478
3479
3480 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3481 PyObject *resultobj;
3482 wxSize *arg1 = (wxSize *) 0 ;
3483 wxSize *arg2 = 0 ;
3484 bool result;
3485 wxSize temp2 ;
3486 PyObject * obj0 = 0 ;
3487 PyObject * obj1 = 0 ;
3488 char *kwnames[] = {
3489 (char *) "self",(char *) "sz", NULL
3490 };
3491
3492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3494 if (SWIG_arg_fail(1)) SWIG_fail;
3495 {
3496 arg2 = &temp2;
3497 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3498 }
3499 {
3500 PyThreadState* __tstate = wxPyBeginAllowThreads();
3501 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3502
3503 wxPyEndAllowThreads(__tstate);
3504 if (PyErr_Occurred()) SWIG_fail;
3505 }
3506 {
3507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3508 }
3509 return resultobj;
3510 fail:
3511 return NULL;
3512 }
3513
3514
3515 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3516 PyObject *resultobj;
3517 wxSize *arg1 = (wxSize *) 0 ;
3518 wxSize *arg2 = 0 ;
3519 bool result;
3520 wxSize temp2 ;
3521 PyObject * obj0 = 0 ;
3522 PyObject * obj1 = 0 ;
3523 char *kwnames[] = {
3524 (char *) "self",(char *) "sz", NULL
3525 };
3526
3527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3529 if (SWIG_arg_fail(1)) SWIG_fail;
3530 {
3531 arg2 = &temp2;
3532 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3533 }
3534 {
3535 PyThreadState* __tstate = wxPyBeginAllowThreads();
3536 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3537
3538 wxPyEndAllowThreads(__tstate);
3539 if (PyErr_Occurred()) SWIG_fail;
3540 }
3541 {
3542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3543 }
3544 return resultobj;
3545 fail:
3546 return NULL;
3547 }
3548
3549
3550 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3551 PyObject *resultobj;
3552 wxSize *arg1 = (wxSize *) 0 ;
3553 wxSize *arg2 = 0 ;
3554 wxSize result;
3555 wxSize temp2 ;
3556 PyObject * obj0 = 0 ;
3557 PyObject * obj1 = 0 ;
3558 char *kwnames[] = {
3559 (char *) "self",(char *) "sz", NULL
3560 };
3561
3562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3564 if (SWIG_arg_fail(1)) SWIG_fail;
3565 {
3566 arg2 = &temp2;
3567 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3568 }
3569 {
3570 PyThreadState* __tstate = wxPyBeginAllowThreads();
3571 result = (arg1)->operator +((wxSize const &)*arg2);
3572
3573 wxPyEndAllowThreads(__tstate);
3574 if (PyErr_Occurred()) SWIG_fail;
3575 }
3576 {
3577 wxSize * resultptr;
3578 resultptr = new wxSize((wxSize &)(result));
3579 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3580 }
3581 return resultobj;
3582 fail:
3583 return NULL;
3584 }
3585
3586
3587 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3588 PyObject *resultobj;
3589 wxSize *arg1 = (wxSize *) 0 ;
3590 wxSize *arg2 = 0 ;
3591 wxSize result;
3592 wxSize temp2 ;
3593 PyObject * obj0 = 0 ;
3594 PyObject * obj1 = 0 ;
3595 char *kwnames[] = {
3596 (char *) "self",(char *) "sz", NULL
3597 };
3598
3599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3601 if (SWIG_arg_fail(1)) SWIG_fail;
3602 {
3603 arg2 = &temp2;
3604 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3605 }
3606 {
3607 PyThreadState* __tstate = wxPyBeginAllowThreads();
3608 result = (arg1)->operator -((wxSize const &)*arg2);
3609
3610 wxPyEndAllowThreads(__tstate);
3611 if (PyErr_Occurred()) SWIG_fail;
3612 }
3613 {
3614 wxSize * resultptr;
3615 resultptr = new wxSize((wxSize &)(result));
3616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3617 }
3618 return resultobj;
3619 fail:
3620 return NULL;
3621 }
3622
3623
3624 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3625 PyObject *resultobj;
3626 wxSize *arg1 = (wxSize *) 0 ;
3627 wxSize *arg2 = 0 ;
3628 wxSize temp2 ;
3629 PyObject * obj0 = 0 ;
3630 PyObject * obj1 = 0 ;
3631 char *kwnames[] = {
3632 (char *) "self",(char *) "sz", NULL
3633 };
3634
3635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3637 if (SWIG_arg_fail(1)) SWIG_fail;
3638 {
3639 arg2 = &temp2;
3640 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3641 }
3642 {
3643 PyThreadState* __tstate = wxPyBeginAllowThreads();
3644 (arg1)->IncTo((wxSize const &)*arg2);
3645
3646 wxPyEndAllowThreads(__tstate);
3647 if (PyErr_Occurred()) SWIG_fail;
3648 }
3649 Py_INCREF(Py_None); resultobj = Py_None;
3650 return resultobj;
3651 fail:
3652 return NULL;
3653 }
3654
3655
3656 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3657 PyObject *resultobj;
3658 wxSize *arg1 = (wxSize *) 0 ;
3659 wxSize *arg2 = 0 ;
3660 wxSize temp2 ;
3661 PyObject * obj0 = 0 ;
3662 PyObject * obj1 = 0 ;
3663 char *kwnames[] = {
3664 (char *) "self",(char *) "sz", NULL
3665 };
3666
3667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3669 if (SWIG_arg_fail(1)) SWIG_fail;
3670 {
3671 arg2 = &temp2;
3672 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3673 }
3674 {
3675 PyThreadState* __tstate = wxPyBeginAllowThreads();
3676 (arg1)->DecTo((wxSize const &)*arg2);
3677
3678 wxPyEndAllowThreads(__tstate);
3679 if (PyErr_Occurred()) SWIG_fail;
3680 }
3681 Py_INCREF(Py_None); resultobj = Py_None;
3682 return resultobj;
3683 fail:
3684 return NULL;
3685 }
3686
3687
3688 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3689 PyObject *resultobj;
3690 wxSize *arg1 = (wxSize *) 0 ;
3691 int arg2 ;
3692 int arg3 ;
3693 PyObject * obj0 = 0 ;
3694 PyObject * obj1 = 0 ;
3695 PyObject * obj2 = 0 ;
3696 char *kwnames[] = {
3697 (char *) "self",(char *) "w",(char *) "h", NULL
3698 };
3699
3700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3702 if (SWIG_arg_fail(1)) SWIG_fail;
3703 {
3704 arg2 = (int)(SWIG_As_int(obj1));
3705 if (SWIG_arg_fail(2)) SWIG_fail;
3706 }
3707 {
3708 arg3 = (int)(SWIG_As_int(obj2));
3709 if (SWIG_arg_fail(3)) SWIG_fail;
3710 }
3711 {
3712 PyThreadState* __tstate = wxPyBeginAllowThreads();
3713 (arg1)->Set(arg2,arg3);
3714
3715 wxPyEndAllowThreads(__tstate);
3716 if (PyErr_Occurred()) SWIG_fail;
3717 }
3718 Py_INCREF(Py_None); resultobj = Py_None;
3719 return resultobj;
3720 fail:
3721 return NULL;
3722 }
3723
3724
3725 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3726 PyObject *resultobj;
3727 wxSize *arg1 = (wxSize *) 0 ;
3728 int arg2 ;
3729 PyObject * obj0 = 0 ;
3730 PyObject * obj1 = 0 ;
3731 char *kwnames[] = {
3732 (char *) "self",(char *) "w", NULL
3733 };
3734
3735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3737 if (SWIG_arg_fail(1)) SWIG_fail;
3738 {
3739 arg2 = (int)(SWIG_As_int(obj1));
3740 if (SWIG_arg_fail(2)) SWIG_fail;
3741 }
3742 {
3743 PyThreadState* __tstate = wxPyBeginAllowThreads();
3744 (arg1)->SetWidth(arg2);
3745
3746 wxPyEndAllowThreads(__tstate);
3747 if (PyErr_Occurred()) SWIG_fail;
3748 }
3749 Py_INCREF(Py_None); resultobj = Py_None;
3750 return resultobj;
3751 fail:
3752 return NULL;
3753 }
3754
3755
3756 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3757 PyObject *resultobj;
3758 wxSize *arg1 = (wxSize *) 0 ;
3759 int arg2 ;
3760 PyObject * obj0 = 0 ;
3761 PyObject * obj1 = 0 ;
3762 char *kwnames[] = {
3763 (char *) "self",(char *) "h", NULL
3764 };
3765
3766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(1)) SWIG_fail;
3769 {
3770 arg2 = (int)(SWIG_As_int(obj1));
3771 if (SWIG_arg_fail(2)) SWIG_fail;
3772 }
3773 {
3774 PyThreadState* __tstate = wxPyBeginAllowThreads();
3775 (arg1)->SetHeight(arg2);
3776
3777 wxPyEndAllowThreads(__tstate);
3778 if (PyErr_Occurred()) SWIG_fail;
3779 }
3780 Py_INCREF(Py_None); resultobj = Py_None;
3781 return resultobj;
3782 fail:
3783 return NULL;
3784 }
3785
3786
3787 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3788 PyObject *resultobj;
3789 wxSize *arg1 = (wxSize *) 0 ;
3790 int result;
3791 PyObject * obj0 = 0 ;
3792 char *kwnames[] = {
3793 (char *) "self", NULL
3794 };
3795
3796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3798 if (SWIG_arg_fail(1)) SWIG_fail;
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 result = (int)((wxSize const *)arg1)->GetWidth();
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 {
3807 resultobj = SWIG_From_int((int)(result));
3808 }
3809 return resultobj;
3810 fail:
3811 return NULL;
3812 }
3813
3814
3815 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3816 PyObject *resultobj;
3817 wxSize *arg1 = (wxSize *) 0 ;
3818 int result;
3819 PyObject * obj0 = 0 ;
3820 char *kwnames[] = {
3821 (char *) "self", NULL
3822 };
3823
3824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3826 if (SWIG_arg_fail(1)) SWIG_fail;
3827 {
3828 PyThreadState* __tstate = wxPyBeginAllowThreads();
3829 result = (int)((wxSize const *)arg1)->GetHeight();
3830
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 {
3835 resultobj = SWIG_From_int((int)(result));
3836 }
3837 return resultobj;
3838 fail:
3839 return NULL;
3840 }
3841
3842
3843 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3844 PyObject *resultobj;
3845 wxSize *arg1 = (wxSize *) 0 ;
3846 bool result;
3847 PyObject * obj0 = 0 ;
3848 char *kwnames[] = {
3849 (char *) "self", NULL
3850 };
3851
3852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3854 if (SWIG_arg_fail(1)) SWIG_fail;
3855 {
3856 PyThreadState* __tstate = wxPyBeginAllowThreads();
3857 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3858
3859 wxPyEndAllowThreads(__tstate);
3860 if (PyErr_Occurred()) SWIG_fail;
3861 }
3862 {
3863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3864 }
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj;
3873 wxSize *arg1 = (wxSize *) 0 ;
3874 wxSize *arg2 = 0 ;
3875 wxSize temp2 ;
3876 PyObject * obj0 = 0 ;
3877 PyObject * obj1 = 0 ;
3878 char *kwnames[] = {
3879 (char *) "self",(char *) "size", NULL
3880 };
3881
3882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3884 if (SWIG_arg_fail(1)) SWIG_fail;
3885 {
3886 arg2 = &temp2;
3887 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3888 }
3889 {
3890 PyThreadState* __tstate = wxPyBeginAllowThreads();
3891 (arg1)->SetDefaults((wxSize const &)*arg2);
3892
3893 wxPyEndAllowThreads(__tstate);
3894 if (PyErr_Occurred()) SWIG_fail;
3895 }
3896 Py_INCREF(Py_None); resultobj = Py_None;
3897 return resultobj;
3898 fail:
3899 return NULL;
3900 }
3901
3902
3903 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3904 PyObject *resultobj;
3905 wxSize *arg1 = (wxSize *) 0 ;
3906 PyObject *result;
3907 PyObject * obj0 = 0 ;
3908 char *kwnames[] = {
3909 (char *) "self", NULL
3910 };
3911
3912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3914 if (SWIG_arg_fail(1)) SWIG_fail;
3915 {
3916 PyThreadState* __tstate = wxPyBeginAllowThreads();
3917 result = (PyObject *)wxSize_Get(arg1);
3918
3919 wxPyEndAllowThreads(__tstate);
3920 if (PyErr_Occurred()) SWIG_fail;
3921 }
3922 resultobj = result;
3923 return resultobj;
3924 fail:
3925 return NULL;
3926 }
3927
3928
3929 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3930 PyObject *obj;
3931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3932 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3933 Py_INCREF(obj);
3934 return Py_BuildValue((char *)"");
3935 }
3936 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3937 PyObject *resultobj;
3938 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3939 double arg2 ;
3940 PyObject * obj0 = 0 ;
3941 PyObject * obj1 = 0 ;
3942 char *kwnames[] = {
3943 (char *) "self",(char *) "x", NULL
3944 };
3945
3946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3948 if (SWIG_arg_fail(1)) SWIG_fail;
3949 {
3950 arg2 = (double)(SWIG_As_double(obj1));
3951 if (SWIG_arg_fail(2)) SWIG_fail;
3952 }
3953 if (arg1) (arg1)->x = arg2;
3954
3955 Py_INCREF(Py_None); resultobj = Py_None;
3956 return resultobj;
3957 fail:
3958 return NULL;
3959 }
3960
3961
3962 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3963 PyObject *resultobj;
3964 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3965 double result;
3966 PyObject * obj0 = 0 ;
3967 char *kwnames[] = {
3968 (char *) "self", NULL
3969 };
3970
3971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3973 if (SWIG_arg_fail(1)) SWIG_fail;
3974 result = (double) ((arg1)->x);
3975
3976 {
3977 resultobj = SWIG_From_double((double)(result));
3978 }
3979 return resultobj;
3980 fail:
3981 return NULL;
3982 }
3983
3984
3985 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3986 PyObject *resultobj;
3987 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3988 double arg2 ;
3989 PyObject * obj0 = 0 ;
3990 PyObject * obj1 = 0 ;
3991 char *kwnames[] = {
3992 (char *) "self",(char *) "y", NULL
3993 };
3994
3995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3997 if (SWIG_arg_fail(1)) SWIG_fail;
3998 {
3999 arg2 = (double)(SWIG_As_double(obj1));
4000 if (SWIG_arg_fail(2)) SWIG_fail;
4001 }
4002 if (arg1) (arg1)->y = arg2;
4003
4004 Py_INCREF(Py_None); resultobj = Py_None;
4005 return resultobj;
4006 fail:
4007 return NULL;
4008 }
4009
4010
4011 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4012 PyObject *resultobj;
4013 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4014 double result;
4015 PyObject * obj0 = 0 ;
4016 char *kwnames[] = {
4017 (char *) "self", NULL
4018 };
4019
4020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4022 if (SWIG_arg_fail(1)) SWIG_fail;
4023 result = (double) ((arg1)->y);
4024
4025 {
4026 resultobj = SWIG_From_double((double)(result));
4027 }
4028 return resultobj;
4029 fail:
4030 return NULL;
4031 }
4032
4033
4034 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4035 PyObject *resultobj;
4036 double arg1 = (double) 0.0 ;
4037 double arg2 = (double) 0.0 ;
4038 wxRealPoint *result;
4039 PyObject * obj0 = 0 ;
4040 PyObject * obj1 = 0 ;
4041 char *kwnames[] = {
4042 (char *) "x",(char *) "y", NULL
4043 };
4044
4045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4046 if (obj0) {
4047 {
4048 arg1 = (double)(SWIG_As_double(obj0));
4049 if (SWIG_arg_fail(1)) SWIG_fail;
4050 }
4051 }
4052 if (obj1) {
4053 {
4054 arg2 = (double)(SWIG_As_double(obj1));
4055 if (SWIG_arg_fail(2)) SWIG_fail;
4056 }
4057 }
4058 {
4059 PyThreadState* __tstate = wxPyBeginAllowThreads();
4060 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4061
4062 wxPyEndAllowThreads(__tstate);
4063 if (PyErr_Occurred()) SWIG_fail;
4064 }
4065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4066 return resultobj;
4067 fail:
4068 return NULL;
4069 }
4070
4071
4072 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4073 PyObject *resultobj;
4074 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4075 PyObject * obj0 = 0 ;
4076 char *kwnames[] = {
4077 (char *) "self", NULL
4078 };
4079
4080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4082 if (SWIG_arg_fail(1)) SWIG_fail;
4083 {
4084 PyThreadState* __tstate = wxPyBeginAllowThreads();
4085 delete arg1;
4086
4087 wxPyEndAllowThreads(__tstate);
4088 if (PyErr_Occurred()) SWIG_fail;
4089 }
4090 Py_INCREF(Py_None); resultobj = Py_None;
4091 return resultobj;
4092 fail:
4093 return NULL;
4094 }
4095
4096
4097 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4098 PyObject *resultobj;
4099 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4100 wxRealPoint *arg2 = 0 ;
4101 bool result;
4102 wxRealPoint temp2 ;
4103 PyObject * obj0 = 0 ;
4104 PyObject * obj1 = 0 ;
4105 char *kwnames[] = {
4106 (char *) "self",(char *) "pt", NULL
4107 };
4108
4109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4111 if (SWIG_arg_fail(1)) SWIG_fail;
4112 {
4113 arg2 = &temp2;
4114 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4115 }
4116 {
4117 PyThreadState* __tstate = wxPyBeginAllowThreads();
4118 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4119
4120 wxPyEndAllowThreads(__tstate);
4121 if (PyErr_Occurred()) SWIG_fail;
4122 }
4123 {
4124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4125 }
4126 return resultobj;
4127 fail:
4128 return NULL;
4129 }
4130
4131
4132 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4133 PyObject *resultobj;
4134 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4135 wxRealPoint *arg2 = 0 ;
4136 bool result;
4137 wxRealPoint temp2 ;
4138 PyObject * obj0 = 0 ;
4139 PyObject * obj1 = 0 ;
4140 char *kwnames[] = {
4141 (char *) "self",(char *) "pt", NULL
4142 };
4143
4144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4146 if (SWIG_arg_fail(1)) SWIG_fail;
4147 {
4148 arg2 = &temp2;
4149 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4150 }
4151 {
4152 PyThreadState* __tstate = wxPyBeginAllowThreads();
4153 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4154
4155 wxPyEndAllowThreads(__tstate);
4156 if (PyErr_Occurred()) SWIG_fail;
4157 }
4158 {
4159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4160 }
4161 return resultobj;
4162 fail:
4163 return NULL;
4164 }
4165
4166
4167 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4168 PyObject *resultobj;
4169 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4170 wxRealPoint *arg2 = 0 ;
4171 wxRealPoint result;
4172 wxRealPoint temp2 ;
4173 PyObject * obj0 = 0 ;
4174 PyObject * obj1 = 0 ;
4175 char *kwnames[] = {
4176 (char *) "self",(char *) "pt", NULL
4177 };
4178
4179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4181 if (SWIG_arg_fail(1)) SWIG_fail;
4182 {
4183 arg2 = &temp2;
4184 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4185 }
4186 {
4187 PyThreadState* __tstate = wxPyBeginAllowThreads();
4188 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4189
4190 wxPyEndAllowThreads(__tstate);
4191 if (PyErr_Occurred()) SWIG_fail;
4192 }
4193 {
4194 wxRealPoint * resultptr;
4195 resultptr = new wxRealPoint((wxRealPoint &)(result));
4196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4197 }
4198 return resultobj;
4199 fail:
4200 return NULL;
4201 }
4202
4203
4204 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4205 PyObject *resultobj;
4206 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4207 wxRealPoint *arg2 = 0 ;
4208 wxRealPoint result;
4209 wxRealPoint temp2 ;
4210 PyObject * obj0 = 0 ;
4211 PyObject * obj1 = 0 ;
4212 char *kwnames[] = {
4213 (char *) "self",(char *) "pt", NULL
4214 };
4215
4216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4218 if (SWIG_arg_fail(1)) SWIG_fail;
4219 {
4220 arg2 = &temp2;
4221 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4222 }
4223 {
4224 PyThreadState* __tstate = wxPyBeginAllowThreads();
4225 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4226
4227 wxPyEndAllowThreads(__tstate);
4228 if (PyErr_Occurred()) SWIG_fail;
4229 }
4230 {
4231 wxRealPoint * resultptr;
4232 resultptr = new wxRealPoint((wxRealPoint &)(result));
4233 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4234 }
4235 return resultobj;
4236 fail:
4237 return NULL;
4238 }
4239
4240
4241 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4242 PyObject *resultobj;
4243 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4244 double arg2 ;
4245 double arg3 ;
4246 PyObject * obj0 = 0 ;
4247 PyObject * obj1 = 0 ;
4248 PyObject * obj2 = 0 ;
4249 char *kwnames[] = {
4250 (char *) "self",(char *) "x",(char *) "y", NULL
4251 };
4252
4253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4255 if (SWIG_arg_fail(1)) SWIG_fail;
4256 {
4257 arg2 = (double)(SWIG_As_double(obj1));
4258 if (SWIG_arg_fail(2)) SWIG_fail;
4259 }
4260 {
4261 arg3 = (double)(SWIG_As_double(obj2));
4262 if (SWIG_arg_fail(3)) SWIG_fail;
4263 }
4264 {
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 wxRealPoint_Set(arg1,arg2,arg3);
4267
4268 wxPyEndAllowThreads(__tstate);
4269 if (PyErr_Occurred()) SWIG_fail;
4270 }
4271 Py_INCREF(Py_None); resultobj = Py_None;
4272 return resultobj;
4273 fail:
4274 return NULL;
4275 }
4276
4277
4278 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4279 PyObject *resultobj;
4280 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4281 PyObject *result;
4282 PyObject * obj0 = 0 ;
4283 char *kwnames[] = {
4284 (char *) "self", NULL
4285 };
4286
4287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4289 if (SWIG_arg_fail(1)) SWIG_fail;
4290 {
4291 PyThreadState* __tstate = wxPyBeginAllowThreads();
4292 result = (PyObject *)wxRealPoint_Get(arg1);
4293
4294 wxPyEndAllowThreads(__tstate);
4295 if (PyErr_Occurred()) SWIG_fail;
4296 }
4297 resultobj = result;
4298 return resultobj;
4299 fail:
4300 return NULL;
4301 }
4302
4303
4304 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4305 PyObject *obj;
4306 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4307 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4308 Py_INCREF(obj);
4309 return Py_BuildValue((char *)"");
4310 }
4311 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4312 PyObject *resultobj;
4313 wxPoint *arg1 = (wxPoint *) 0 ;
4314 int arg2 ;
4315 PyObject * obj0 = 0 ;
4316 PyObject * obj1 = 0 ;
4317 char *kwnames[] = {
4318 (char *) "self",(char *) "x", NULL
4319 };
4320
4321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4323 if (SWIG_arg_fail(1)) SWIG_fail;
4324 {
4325 arg2 = (int)(SWIG_As_int(obj1));
4326 if (SWIG_arg_fail(2)) SWIG_fail;
4327 }
4328 if (arg1) (arg1)->x = arg2;
4329
4330 Py_INCREF(Py_None); resultobj = Py_None;
4331 return resultobj;
4332 fail:
4333 return NULL;
4334 }
4335
4336
4337 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4338 PyObject *resultobj;
4339 wxPoint *arg1 = (wxPoint *) 0 ;
4340 int result;
4341 PyObject * obj0 = 0 ;
4342 char *kwnames[] = {
4343 (char *) "self", NULL
4344 };
4345
4346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4348 if (SWIG_arg_fail(1)) SWIG_fail;
4349 result = (int) ((arg1)->x);
4350
4351 {
4352 resultobj = SWIG_From_int((int)(result));
4353 }
4354 return resultobj;
4355 fail:
4356 return NULL;
4357 }
4358
4359
4360 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4361 PyObject *resultobj;
4362 wxPoint *arg1 = (wxPoint *) 0 ;
4363 int arg2 ;
4364 PyObject * obj0 = 0 ;
4365 PyObject * obj1 = 0 ;
4366 char *kwnames[] = {
4367 (char *) "self",(char *) "y", NULL
4368 };
4369
4370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4372 if (SWIG_arg_fail(1)) SWIG_fail;
4373 {
4374 arg2 = (int)(SWIG_As_int(obj1));
4375 if (SWIG_arg_fail(2)) SWIG_fail;
4376 }
4377 if (arg1) (arg1)->y = arg2;
4378
4379 Py_INCREF(Py_None); resultobj = Py_None;
4380 return resultobj;
4381 fail:
4382 return NULL;
4383 }
4384
4385
4386 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4387 PyObject *resultobj;
4388 wxPoint *arg1 = (wxPoint *) 0 ;
4389 int result;
4390 PyObject * obj0 = 0 ;
4391 char *kwnames[] = {
4392 (char *) "self", NULL
4393 };
4394
4395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4397 if (SWIG_arg_fail(1)) SWIG_fail;
4398 result = (int) ((arg1)->y);
4399
4400 {
4401 resultobj = SWIG_From_int((int)(result));
4402 }
4403 return resultobj;
4404 fail:
4405 return NULL;
4406 }
4407
4408
4409 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4410 PyObject *resultobj;
4411 int arg1 = (int) 0 ;
4412 int arg2 = (int) 0 ;
4413 wxPoint *result;
4414 PyObject * obj0 = 0 ;
4415 PyObject * obj1 = 0 ;
4416 char *kwnames[] = {
4417 (char *) "x",(char *) "y", NULL
4418 };
4419
4420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4421 if (obj0) {
4422 {
4423 arg1 = (int)(SWIG_As_int(obj0));
4424 if (SWIG_arg_fail(1)) SWIG_fail;
4425 }
4426 }
4427 if (obj1) {
4428 {
4429 arg2 = (int)(SWIG_As_int(obj1));
4430 if (SWIG_arg_fail(2)) SWIG_fail;
4431 }
4432 }
4433 {
4434 PyThreadState* __tstate = wxPyBeginAllowThreads();
4435 result = (wxPoint *)new wxPoint(arg1,arg2);
4436
4437 wxPyEndAllowThreads(__tstate);
4438 if (PyErr_Occurred()) SWIG_fail;
4439 }
4440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4448 PyObject *resultobj;
4449 wxPoint *arg1 = (wxPoint *) 0 ;
4450 PyObject * obj0 = 0 ;
4451 char *kwnames[] = {
4452 (char *) "self", NULL
4453 };
4454
4455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4457 if (SWIG_arg_fail(1)) SWIG_fail;
4458 {
4459 PyThreadState* __tstate = wxPyBeginAllowThreads();
4460 delete arg1;
4461
4462 wxPyEndAllowThreads(__tstate);
4463 if (PyErr_Occurred()) SWIG_fail;
4464 }
4465 Py_INCREF(Py_None); resultobj = Py_None;
4466 return resultobj;
4467 fail:
4468 return NULL;
4469 }
4470
4471
4472 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4473 PyObject *resultobj;
4474 wxPoint *arg1 = (wxPoint *) 0 ;
4475 wxPoint *arg2 = 0 ;
4476 bool result;
4477 wxPoint temp2 ;
4478 PyObject * obj0 = 0 ;
4479 PyObject * obj1 = 0 ;
4480 char *kwnames[] = {
4481 (char *) "self",(char *) "pt", NULL
4482 };
4483
4484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4486 if (SWIG_arg_fail(1)) SWIG_fail;
4487 {
4488 arg2 = &temp2;
4489 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4490 }
4491 {
4492 PyThreadState* __tstate = wxPyBeginAllowThreads();
4493 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4494
4495 wxPyEndAllowThreads(__tstate);
4496 if (PyErr_Occurred()) SWIG_fail;
4497 }
4498 {
4499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4500 }
4501 return resultobj;
4502 fail:
4503 return NULL;
4504 }
4505
4506
4507 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj;
4509 wxPoint *arg1 = (wxPoint *) 0 ;
4510 wxPoint *arg2 = 0 ;
4511 bool result;
4512 wxPoint temp2 ;
4513 PyObject * obj0 = 0 ;
4514 PyObject * obj1 = 0 ;
4515 char *kwnames[] = {
4516 (char *) "self",(char *) "pt", NULL
4517 };
4518
4519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4521 if (SWIG_arg_fail(1)) SWIG_fail;
4522 {
4523 arg2 = &temp2;
4524 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4525 }
4526 {
4527 PyThreadState* __tstate = wxPyBeginAllowThreads();
4528 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4529
4530 wxPyEndAllowThreads(__tstate);
4531 if (PyErr_Occurred()) SWIG_fail;
4532 }
4533 {
4534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4535 }
4536 return resultobj;
4537 fail:
4538 return NULL;
4539 }
4540
4541
4542 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4543 PyObject *resultobj;
4544 wxPoint *arg1 = (wxPoint *) 0 ;
4545 wxPoint *arg2 = 0 ;
4546 wxPoint result;
4547 wxPoint temp2 ;
4548 PyObject * obj0 = 0 ;
4549 PyObject * obj1 = 0 ;
4550 char *kwnames[] = {
4551 (char *) "self",(char *) "pt", NULL
4552 };
4553
4554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4556 if (SWIG_arg_fail(1)) SWIG_fail;
4557 {
4558 arg2 = &temp2;
4559 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4560 }
4561 {
4562 PyThreadState* __tstate = wxPyBeginAllowThreads();
4563 result = (arg1)->operator +((wxPoint const &)*arg2);
4564
4565 wxPyEndAllowThreads(__tstate);
4566 if (PyErr_Occurred()) SWIG_fail;
4567 }
4568 {
4569 wxPoint * resultptr;
4570 resultptr = new wxPoint((wxPoint &)(result));
4571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4572 }
4573 return resultobj;
4574 fail:
4575 return NULL;
4576 }
4577
4578
4579 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4580 PyObject *resultobj;
4581 wxPoint *arg1 = (wxPoint *) 0 ;
4582 wxPoint *arg2 = 0 ;
4583 wxPoint result;
4584 wxPoint temp2 ;
4585 PyObject * obj0 = 0 ;
4586 PyObject * obj1 = 0 ;
4587 char *kwnames[] = {
4588 (char *) "self",(char *) "pt", NULL
4589 };
4590
4591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4593 if (SWIG_arg_fail(1)) SWIG_fail;
4594 {
4595 arg2 = &temp2;
4596 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4597 }
4598 {
4599 PyThreadState* __tstate = wxPyBeginAllowThreads();
4600 result = (arg1)->operator -((wxPoint const &)*arg2);
4601
4602 wxPyEndAllowThreads(__tstate);
4603 if (PyErr_Occurred()) SWIG_fail;
4604 }
4605 {
4606 wxPoint * resultptr;
4607 resultptr = new wxPoint((wxPoint &)(result));
4608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4609 }
4610 return resultobj;
4611 fail:
4612 return NULL;
4613 }
4614
4615
4616 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4617 PyObject *resultobj;
4618 wxPoint *arg1 = (wxPoint *) 0 ;
4619 wxPoint *arg2 = 0 ;
4620 wxPoint *result;
4621 wxPoint temp2 ;
4622 PyObject * obj0 = 0 ;
4623 PyObject * obj1 = 0 ;
4624 char *kwnames[] = {
4625 (char *) "self",(char *) "pt", NULL
4626 };
4627
4628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4630 if (SWIG_arg_fail(1)) SWIG_fail;
4631 {
4632 arg2 = &temp2;
4633 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4634 }
4635 {
4636 PyThreadState* __tstate = wxPyBeginAllowThreads();
4637 {
4638 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4639 result = (wxPoint *) &_result_ref;
4640 }
4641
4642 wxPyEndAllowThreads(__tstate);
4643 if (PyErr_Occurred()) SWIG_fail;
4644 }
4645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4646 return resultobj;
4647 fail:
4648 return NULL;
4649 }
4650
4651
4652 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4653 PyObject *resultobj;
4654 wxPoint *arg1 = (wxPoint *) 0 ;
4655 wxPoint *arg2 = 0 ;
4656 wxPoint *result;
4657 wxPoint temp2 ;
4658 PyObject * obj0 = 0 ;
4659 PyObject * obj1 = 0 ;
4660 char *kwnames[] = {
4661 (char *) "self",(char *) "pt", NULL
4662 };
4663
4664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4666 if (SWIG_arg_fail(1)) SWIG_fail;
4667 {
4668 arg2 = &temp2;
4669 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4670 }
4671 {
4672 PyThreadState* __tstate = wxPyBeginAllowThreads();
4673 {
4674 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4675 result = (wxPoint *) &_result_ref;
4676 }
4677
4678 wxPyEndAllowThreads(__tstate);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4682 return resultobj;
4683 fail:
4684 return NULL;
4685 }
4686
4687
4688 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4689 PyObject *resultobj;
4690 wxPoint *arg1 = (wxPoint *) 0 ;
4691 long arg2 ;
4692 long arg3 ;
4693 PyObject * obj0 = 0 ;
4694 PyObject * obj1 = 0 ;
4695 PyObject * obj2 = 0 ;
4696 char *kwnames[] = {
4697 (char *) "self",(char *) "x",(char *) "y", NULL
4698 };
4699
4700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4702 if (SWIG_arg_fail(1)) SWIG_fail;
4703 {
4704 arg2 = (long)(SWIG_As_long(obj1));
4705 if (SWIG_arg_fail(2)) SWIG_fail;
4706 }
4707 {
4708 arg3 = (long)(SWIG_As_long(obj2));
4709 if (SWIG_arg_fail(3)) SWIG_fail;
4710 }
4711 {
4712 PyThreadState* __tstate = wxPyBeginAllowThreads();
4713 wxPoint_Set(arg1,arg2,arg3);
4714
4715 wxPyEndAllowThreads(__tstate);
4716 if (PyErr_Occurred()) SWIG_fail;
4717 }
4718 Py_INCREF(Py_None); resultobj = Py_None;
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4726 PyObject *resultobj;
4727 wxPoint *arg1 = (wxPoint *) 0 ;
4728 PyObject *result;
4729 PyObject * obj0 = 0 ;
4730 char *kwnames[] = {
4731 (char *) "self", NULL
4732 };
4733
4734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4736 if (SWIG_arg_fail(1)) SWIG_fail;
4737 {
4738 PyThreadState* __tstate = wxPyBeginAllowThreads();
4739 result = (PyObject *)wxPoint_Get(arg1);
4740
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 resultobj = result;
4745 return resultobj;
4746 fail:
4747 return NULL;
4748 }
4749
4750
4751 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4752 PyObject *obj;
4753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4754 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4755 Py_INCREF(obj);
4756 return Py_BuildValue((char *)"");
4757 }
4758 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4759 PyObject *resultobj;
4760 int arg1 = (int) 0 ;
4761 int arg2 = (int) 0 ;
4762 int arg3 = (int) 0 ;
4763 int arg4 = (int) 0 ;
4764 wxRect *result;
4765 PyObject * obj0 = 0 ;
4766 PyObject * obj1 = 0 ;
4767 PyObject * obj2 = 0 ;
4768 PyObject * obj3 = 0 ;
4769 char *kwnames[] = {
4770 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4771 };
4772
4773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4774 if (obj0) {
4775 {
4776 arg1 = (int)(SWIG_As_int(obj0));
4777 if (SWIG_arg_fail(1)) SWIG_fail;
4778 }
4779 }
4780 if (obj1) {
4781 {
4782 arg2 = (int)(SWIG_As_int(obj1));
4783 if (SWIG_arg_fail(2)) SWIG_fail;
4784 }
4785 }
4786 if (obj2) {
4787 {
4788 arg3 = (int)(SWIG_As_int(obj2));
4789 if (SWIG_arg_fail(3)) SWIG_fail;
4790 }
4791 }
4792 if (obj3) {
4793 {
4794 arg4 = (int)(SWIG_As_int(obj3));
4795 if (SWIG_arg_fail(4)) SWIG_fail;
4796 }
4797 }
4798 {
4799 PyThreadState* __tstate = wxPyBeginAllowThreads();
4800 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4801
4802 wxPyEndAllowThreads(__tstate);
4803 if (PyErr_Occurred()) SWIG_fail;
4804 }
4805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4806 return resultobj;
4807 fail:
4808 return NULL;
4809 }
4810
4811
4812 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4813 PyObject *resultobj;
4814 wxPoint *arg1 = 0 ;
4815 wxPoint *arg2 = 0 ;
4816 wxRect *result;
4817 wxPoint temp1 ;
4818 wxPoint temp2 ;
4819 PyObject * obj0 = 0 ;
4820 PyObject * obj1 = 0 ;
4821 char *kwnames[] = {
4822 (char *) "topLeft",(char *) "bottomRight", NULL
4823 };
4824
4825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4826 {
4827 arg1 = &temp1;
4828 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4829 }
4830 {
4831 arg2 = &temp2;
4832 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4833 }
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4837
4838 wxPyEndAllowThreads(__tstate);
4839 if (PyErr_Occurred()) SWIG_fail;
4840 }
4841 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj;
4850 wxPoint *arg1 = 0 ;
4851 wxSize *arg2 = 0 ;
4852 wxRect *result;
4853 wxPoint temp1 ;
4854 wxSize temp2 ;
4855 PyObject * obj0 = 0 ;
4856 PyObject * obj1 = 0 ;
4857 char *kwnames[] = {
4858 (char *) "pos",(char *) "size", NULL
4859 };
4860
4861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4862 {
4863 arg1 = &temp1;
4864 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4865 }
4866 {
4867 arg2 = &temp2;
4868 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4869 }
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4873
4874 wxPyEndAllowThreads(__tstate);
4875 if (PyErr_Occurred()) SWIG_fail;
4876 }
4877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4878 return resultobj;
4879 fail:
4880 return NULL;
4881 }
4882
4883
4884 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4885 PyObject *resultobj;
4886 wxSize *arg1 = 0 ;
4887 wxRect *result;
4888 wxSize temp1 ;
4889 PyObject * obj0 = 0 ;
4890 char *kwnames[] = {
4891 (char *) "size", NULL
4892 };
4893
4894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4895 {
4896 arg1 = &temp1;
4897 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4898 }
4899 {
4900 PyThreadState* __tstate = wxPyBeginAllowThreads();
4901 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4902
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4914 PyObject *resultobj;
4915 wxRect *arg1 = (wxRect *) 0 ;
4916 PyObject * obj0 = 0 ;
4917 char *kwnames[] = {
4918 (char *) "self", NULL
4919 };
4920
4921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4923 if (SWIG_arg_fail(1)) SWIG_fail;
4924 {
4925 PyThreadState* __tstate = wxPyBeginAllowThreads();
4926 delete arg1;
4927
4928 wxPyEndAllowThreads(__tstate);
4929 if (PyErr_Occurred()) SWIG_fail;
4930 }
4931 Py_INCREF(Py_None); resultobj = Py_None;
4932 return resultobj;
4933 fail:
4934 return NULL;
4935 }
4936
4937
4938 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4939 PyObject *resultobj;
4940 wxRect *arg1 = (wxRect *) 0 ;
4941 int result;
4942 PyObject * obj0 = 0 ;
4943 char *kwnames[] = {
4944 (char *) "self", NULL
4945 };
4946
4947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4949 if (SWIG_arg_fail(1)) SWIG_fail;
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 result = (int)((wxRect const *)arg1)->GetX();
4953
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 {
4958 resultobj = SWIG_From_int((int)(result));
4959 }
4960 return resultobj;
4961 fail:
4962 return NULL;
4963 }
4964
4965
4966 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4967 PyObject *resultobj;
4968 wxRect *arg1 = (wxRect *) 0 ;
4969 int arg2 ;
4970 PyObject * obj0 = 0 ;
4971 PyObject * obj1 = 0 ;
4972 char *kwnames[] = {
4973 (char *) "self",(char *) "x", NULL
4974 };
4975
4976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4978 if (SWIG_arg_fail(1)) SWIG_fail;
4979 {
4980 arg2 = (int)(SWIG_As_int(obj1));
4981 if (SWIG_arg_fail(2)) SWIG_fail;
4982 }
4983 {
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 (arg1)->SetX(arg2);
4986
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 Py_INCREF(Py_None); resultobj = Py_None;
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4998 PyObject *resultobj;
4999 wxRect *arg1 = (wxRect *) 0 ;
5000 int result;
5001 PyObject * obj0 = 0 ;
5002 char *kwnames[] = {
5003 (char *) "self", NULL
5004 };
5005
5006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5008 if (SWIG_arg_fail(1)) SWIG_fail;
5009 {
5010 PyThreadState* __tstate = wxPyBeginAllowThreads();
5011 result = (int)(arg1)->GetY();
5012
5013 wxPyEndAllowThreads(__tstate);
5014 if (PyErr_Occurred()) SWIG_fail;
5015 }
5016 {
5017 resultobj = SWIG_From_int((int)(result));
5018 }
5019 return resultobj;
5020 fail:
5021 return NULL;
5022 }
5023
5024
5025 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5026 PyObject *resultobj;
5027 wxRect *arg1 = (wxRect *) 0 ;
5028 int arg2 ;
5029 PyObject * obj0 = 0 ;
5030 PyObject * obj1 = 0 ;
5031 char *kwnames[] = {
5032 (char *) "self",(char *) "y", NULL
5033 };
5034
5035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5037 if (SWIG_arg_fail(1)) SWIG_fail;
5038 {
5039 arg2 = (int)(SWIG_As_int(obj1));
5040 if (SWIG_arg_fail(2)) SWIG_fail;
5041 }
5042 {
5043 PyThreadState* __tstate = wxPyBeginAllowThreads();
5044 (arg1)->SetY(arg2);
5045
5046 wxPyEndAllowThreads(__tstate);
5047 if (PyErr_Occurred()) SWIG_fail;
5048 }
5049 Py_INCREF(Py_None); resultobj = Py_None;
5050 return resultobj;
5051 fail:
5052 return NULL;
5053 }
5054
5055
5056 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5057 PyObject *resultobj;
5058 wxRect *arg1 = (wxRect *) 0 ;
5059 int result;
5060 PyObject * obj0 = 0 ;
5061 char *kwnames[] = {
5062 (char *) "self", NULL
5063 };
5064
5065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5067 if (SWIG_arg_fail(1)) SWIG_fail;
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 result = (int)((wxRect const *)arg1)->GetWidth();
5071
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 {
5076 resultobj = SWIG_From_int((int)(result));
5077 }
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
5084 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5085 PyObject *resultobj;
5086 wxRect *arg1 = (wxRect *) 0 ;
5087 int arg2 ;
5088 PyObject * obj0 = 0 ;
5089 PyObject * obj1 = 0 ;
5090 char *kwnames[] = {
5091 (char *) "self",(char *) "w", NULL
5092 };
5093
5094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5096 if (SWIG_arg_fail(1)) SWIG_fail;
5097 {
5098 arg2 = (int)(SWIG_As_int(obj1));
5099 if (SWIG_arg_fail(2)) SWIG_fail;
5100 }
5101 {
5102 PyThreadState* __tstate = wxPyBeginAllowThreads();
5103 (arg1)->SetWidth(arg2);
5104
5105 wxPyEndAllowThreads(__tstate);
5106 if (PyErr_Occurred()) SWIG_fail;
5107 }
5108 Py_INCREF(Py_None); resultobj = Py_None;
5109 return resultobj;
5110 fail:
5111 return NULL;
5112 }
5113
5114
5115 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5116 PyObject *resultobj;
5117 wxRect *arg1 = (wxRect *) 0 ;
5118 int result;
5119 PyObject * obj0 = 0 ;
5120 char *kwnames[] = {
5121 (char *) "self", NULL
5122 };
5123
5124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5126 if (SWIG_arg_fail(1)) SWIG_fail;
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 result = (int)((wxRect const *)arg1)->GetHeight();
5130
5131 wxPyEndAllowThreads(__tstate);
5132 if (PyErr_Occurred()) SWIG_fail;
5133 }
5134 {
5135 resultobj = SWIG_From_int((int)(result));
5136 }
5137 return resultobj;
5138 fail:
5139 return NULL;
5140 }
5141
5142
5143 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj;
5145 wxRect *arg1 = (wxRect *) 0 ;
5146 int arg2 ;
5147 PyObject * obj0 = 0 ;
5148 PyObject * obj1 = 0 ;
5149 char *kwnames[] = {
5150 (char *) "self",(char *) "h", NULL
5151 };
5152
5153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5155 if (SWIG_arg_fail(1)) SWIG_fail;
5156 {
5157 arg2 = (int)(SWIG_As_int(obj1));
5158 if (SWIG_arg_fail(2)) SWIG_fail;
5159 }
5160 {
5161 PyThreadState* __tstate = wxPyBeginAllowThreads();
5162 (arg1)->SetHeight(arg2);
5163
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 Py_INCREF(Py_None); resultobj = Py_None;
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5175 PyObject *resultobj;
5176 wxRect *arg1 = (wxRect *) 0 ;
5177 wxPoint result;
5178 PyObject * obj0 = 0 ;
5179 char *kwnames[] = {
5180 (char *) "self", NULL
5181 };
5182
5183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5185 if (SWIG_arg_fail(1)) SWIG_fail;
5186 {
5187 PyThreadState* __tstate = wxPyBeginAllowThreads();
5188 result = ((wxRect const *)arg1)->GetPosition();
5189
5190 wxPyEndAllowThreads(__tstate);
5191 if (PyErr_Occurred()) SWIG_fail;
5192 }
5193 {
5194 wxPoint * resultptr;
5195 resultptr = new wxPoint((wxPoint &)(result));
5196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5197 }
5198 return resultobj;
5199 fail:
5200 return NULL;
5201 }
5202
5203
5204 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5205 PyObject *resultobj;
5206 wxRect *arg1 = (wxRect *) 0 ;
5207 wxPoint *arg2 = 0 ;
5208 wxPoint temp2 ;
5209 PyObject * obj0 = 0 ;
5210 PyObject * obj1 = 0 ;
5211 char *kwnames[] = {
5212 (char *) "self",(char *) "p", NULL
5213 };
5214
5215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5217 if (SWIG_arg_fail(1)) SWIG_fail;
5218 {
5219 arg2 = &temp2;
5220 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5221 }
5222 {
5223 PyThreadState* __tstate = wxPyBeginAllowThreads();
5224 (arg1)->SetPosition((wxPoint const &)*arg2);
5225
5226 wxPyEndAllowThreads(__tstate);
5227 if (PyErr_Occurred()) SWIG_fail;
5228 }
5229 Py_INCREF(Py_None); resultobj = Py_None;
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj;
5238 wxRect *arg1 = (wxRect *) 0 ;
5239 wxSize result;
5240 PyObject * obj0 = 0 ;
5241 char *kwnames[] = {
5242 (char *) "self", NULL
5243 };
5244
5245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5247 if (SWIG_arg_fail(1)) SWIG_fail;
5248 {
5249 PyThreadState* __tstate = wxPyBeginAllowThreads();
5250 result = ((wxRect const *)arg1)->GetSize();
5251
5252 wxPyEndAllowThreads(__tstate);
5253 if (PyErr_Occurred()) SWIG_fail;
5254 }
5255 {
5256 wxSize * resultptr;
5257 resultptr = new wxSize((wxSize &)(result));
5258 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5259 }
5260 return resultobj;
5261 fail:
5262 return NULL;
5263 }
5264
5265
5266 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5267 PyObject *resultobj;
5268 wxRect *arg1 = (wxRect *) 0 ;
5269 wxSize *arg2 = 0 ;
5270 wxSize temp2 ;
5271 PyObject * obj0 = 0 ;
5272 PyObject * obj1 = 0 ;
5273 char *kwnames[] = {
5274 (char *) "self",(char *) "s", NULL
5275 };
5276
5277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5279 if (SWIG_arg_fail(1)) SWIG_fail;
5280 {
5281 arg2 = &temp2;
5282 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5283 }
5284 {
5285 PyThreadState* __tstate = wxPyBeginAllowThreads();
5286 (arg1)->SetSize((wxSize const &)*arg2);
5287
5288 wxPyEndAllowThreads(__tstate);
5289 if (PyErr_Occurred()) SWIG_fail;
5290 }
5291 Py_INCREF(Py_None); resultobj = Py_None;
5292 return resultobj;
5293 fail:
5294 return NULL;
5295 }
5296
5297
5298 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5299 PyObject *resultobj;
5300 wxRect *arg1 = (wxRect *) 0 ;
5301 bool result;
5302 PyObject * obj0 = 0 ;
5303 char *kwnames[] = {
5304 (char *) "self", NULL
5305 };
5306
5307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5309 if (SWIG_arg_fail(1)) SWIG_fail;
5310 {
5311 PyThreadState* __tstate = wxPyBeginAllowThreads();
5312 result = (bool)((wxRect const *)arg1)->IsEmpty();
5313
5314 wxPyEndAllowThreads(__tstate);
5315 if (PyErr_Occurred()) SWIG_fail;
5316 }
5317 {
5318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5319 }
5320 return resultobj;
5321 fail:
5322 return NULL;
5323 }
5324
5325
5326 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5327 PyObject *resultobj;
5328 wxRect *arg1 = (wxRect *) 0 ;
5329 wxPoint result;
5330 PyObject * obj0 = 0 ;
5331 char *kwnames[] = {
5332 (char *) "self", NULL
5333 };
5334
5335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5337 if (SWIG_arg_fail(1)) SWIG_fail;
5338 {
5339 PyThreadState* __tstate = wxPyBeginAllowThreads();
5340 result = ((wxRect const *)arg1)->GetTopLeft();
5341
5342 wxPyEndAllowThreads(__tstate);
5343 if (PyErr_Occurred()) SWIG_fail;
5344 }
5345 {
5346 wxPoint * resultptr;
5347 resultptr = new wxPoint((wxPoint &)(result));
5348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5349 }
5350 return resultobj;
5351 fail:
5352 return NULL;
5353 }
5354
5355
5356 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5357 PyObject *resultobj;
5358 wxRect *arg1 = (wxRect *) 0 ;
5359 wxPoint *arg2 = 0 ;
5360 wxPoint temp2 ;
5361 PyObject * obj0 = 0 ;
5362 PyObject * obj1 = 0 ;
5363 char *kwnames[] = {
5364 (char *) "self",(char *) "p", NULL
5365 };
5366
5367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5369 if (SWIG_arg_fail(1)) SWIG_fail;
5370 {
5371 arg2 = &temp2;
5372 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5373 }
5374 {
5375 PyThreadState* __tstate = wxPyBeginAllowThreads();
5376 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5377
5378 wxPyEndAllowThreads(__tstate);
5379 if (PyErr_Occurred()) SWIG_fail;
5380 }
5381 Py_INCREF(Py_None); resultobj = Py_None;
5382 return resultobj;
5383 fail:
5384 return NULL;
5385 }
5386
5387
5388 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5389 PyObject *resultobj;
5390 wxRect *arg1 = (wxRect *) 0 ;
5391 wxPoint result;
5392 PyObject * obj0 = 0 ;
5393 char *kwnames[] = {
5394 (char *) "self", NULL
5395 };
5396
5397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5399 if (SWIG_arg_fail(1)) SWIG_fail;
5400 {
5401 PyThreadState* __tstate = wxPyBeginAllowThreads();
5402 result = ((wxRect const *)arg1)->GetBottomRight();
5403
5404 wxPyEndAllowThreads(__tstate);
5405 if (PyErr_Occurred()) SWIG_fail;
5406 }
5407 {
5408 wxPoint * resultptr;
5409 resultptr = new wxPoint((wxPoint &)(result));
5410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5411 }
5412 return resultobj;
5413 fail:
5414 return NULL;
5415 }
5416
5417
5418 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5419 PyObject *resultobj;
5420 wxRect *arg1 = (wxRect *) 0 ;
5421 wxPoint *arg2 = 0 ;
5422 wxPoint temp2 ;
5423 PyObject * obj0 = 0 ;
5424 PyObject * obj1 = 0 ;
5425 char *kwnames[] = {
5426 (char *) "self",(char *) "p", NULL
5427 };
5428
5429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5431 if (SWIG_arg_fail(1)) SWIG_fail;
5432 {
5433 arg2 = &temp2;
5434 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5435 }
5436 {
5437 PyThreadState* __tstate = wxPyBeginAllowThreads();
5438 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5439
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 Py_INCREF(Py_None); resultobj = Py_None;
5444 return resultobj;
5445 fail:
5446 return NULL;
5447 }
5448
5449
5450 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5451 PyObject *resultobj;
5452 wxRect *arg1 = (wxRect *) 0 ;
5453 int result;
5454 PyObject * obj0 = 0 ;
5455 char *kwnames[] = {
5456 (char *) "self", NULL
5457 };
5458
5459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5461 if (SWIG_arg_fail(1)) SWIG_fail;
5462 {
5463 PyThreadState* __tstate = wxPyBeginAllowThreads();
5464 result = (int)((wxRect const *)arg1)->GetLeft();
5465
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 {
5470 resultobj = SWIG_From_int((int)(result));
5471 }
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5479 PyObject *resultobj;
5480 wxRect *arg1 = (wxRect *) 0 ;
5481 int result;
5482 PyObject * obj0 = 0 ;
5483 char *kwnames[] = {
5484 (char *) "self", NULL
5485 };
5486
5487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5489 if (SWIG_arg_fail(1)) SWIG_fail;
5490 {
5491 PyThreadState* __tstate = wxPyBeginAllowThreads();
5492 result = (int)((wxRect const *)arg1)->GetTop();
5493
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 {
5498 resultobj = SWIG_From_int((int)(result));
5499 }
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj;
5508 wxRect *arg1 = (wxRect *) 0 ;
5509 int result;
5510 PyObject * obj0 = 0 ;
5511 char *kwnames[] = {
5512 (char *) "self", NULL
5513 };
5514
5515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5517 if (SWIG_arg_fail(1)) SWIG_fail;
5518 {
5519 PyThreadState* __tstate = wxPyBeginAllowThreads();
5520 result = (int)((wxRect const *)arg1)->GetBottom();
5521
5522 wxPyEndAllowThreads(__tstate);
5523 if (PyErr_Occurred()) SWIG_fail;
5524 }
5525 {
5526 resultobj = SWIG_From_int((int)(result));
5527 }
5528 return resultobj;
5529 fail:
5530 return NULL;
5531 }
5532
5533
5534 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5535 PyObject *resultobj;
5536 wxRect *arg1 = (wxRect *) 0 ;
5537 int result;
5538 PyObject * obj0 = 0 ;
5539 char *kwnames[] = {
5540 (char *) "self", NULL
5541 };
5542
5543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
5548 result = (int)((wxRect const *)arg1)->GetRight();
5549
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 {
5554 resultobj = SWIG_From_int((int)(result));
5555 }
5556 return resultobj;
5557 fail:
5558 return NULL;
5559 }
5560
5561
5562 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5563 PyObject *resultobj;
5564 wxRect *arg1 = (wxRect *) 0 ;
5565 int arg2 ;
5566 PyObject * obj0 = 0 ;
5567 PyObject * obj1 = 0 ;
5568 char *kwnames[] = {
5569 (char *) "self",(char *) "left", NULL
5570 };
5571
5572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5574 if (SWIG_arg_fail(1)) SWIG_fail;
5575 {
5576 arg2 = (int)(SWIG_As_int(obj1));
5577 if (SWIG_arg_fail(2)) SWIG_fail;
5578 }
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 (arg1)->SetLeft(arg2);
5582
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 Py_INCREF(Py_None); resultobj = Py_None;
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5594 PyObject *resultobj;
5595 wxRect *arg1 = (wxRect *) 0 ;
5596 int arg2 ;
5597 PyObject * obj0 = 0 ;
5598 PyObject * obj1 = 0 ;
5599 char *kwnames[] = {
5600 (char *) "self",(char *) "right", NULL
5601 };
5602
5603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5605 if (SWIG_arg_fail(1)) SWIG_fail;
5606 {
5607 arg2 = (int)(SWIG_As_int(obj1));
5608 if (SWIG_arg_fail(2)) SWIG_fail;
5609 }
5610 {
5611 PyThreadState* __tstate = wxPyBeginAllowThreads();
5612 (arg1)->SetRight(arg2);
5613
5614 wxPyEndAllowThreads(__tstate);
5615 if (PyErr_Occurred()) SWIG_fail;
5616 }
5617 Py_INCREF(Py_None); resultobj = Py_None;
5618 return resultobj;
5619 fail:
5620 return NULL;
5621 }
5622
5623
5624 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5625 PyObject *resultobj;
5626 wxRect *arg1 = (wxRect *) 0 ;
5627 int arg2 ;
5628 PyObject * obj0 = 0 ;
5629 PyObject * obj1 = 0 ;
5630 char *kwnames[] = {
5631 (char *) "self",(char *) "top", NULL
5632 };
5633
5634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5636 if (SWIG_arg_fail(1)) SWIG_fail;
5637 {
5638 arg2 = (int)(SWIG_As_int(obj1));
5639 if (SWIG_arg_fail(2)) SWIG_fail;
5640 }
5641 {
5642 PyThreadState* __tstate = wxPyBeginAllowThreads();
5643 (arg1)->SetTop(arg2);
5644
5645 wxPyEndAllowThreads(__tstate);
5646 if (PyErr_Occurred()) SWIG_fail;
5647 }
5648 Py_INCREF(Py_None); resultobj = Py_None;
5649 return resultobj;
5650 fail:
5651 return NULL;
5652 }
5653
5654
5655 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5656 PyObject *resultobj;
5657 wxRect *arg1 = (wxRect *) 0 ;
5658 int arg2 ;
5659 PyObject * obj0 = 0 ;
5660 PyObject * obj1 = 0 ;
5661 char *kwnames[] = {
5662 (char *) "self",(char *) "bottom", NULL
5663 };
5664
5665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5667 if (SWIG_arg_fail(1)) SWIG_fail;
5668 {
5669 arg2 = (int)(SWIG_As_int(obj1));
5670 if (SWIG_arg_fail(2)) SWIG_fail;
5671 }
5672 {
5673 PyThreadState* __tstate = wxPyBeginAllowThreads();
5674 (arg1)->SetBottom(arg2);
5675
5676 wxPyEndAllowThreads(__tstate);
5677 if (PyErr_Occurred()) SWIG_fail;
5678 }
5679 Py_INCREF(Py_None); resultobj = Py_None;
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5687 PyObject *resultobj;
5688 wxRect *arg1 = (wxRect *) 0 ;
5689 int arg2 ;
5690 int arg3 ;
5691 wxRect *result;
5692 PyObject * obj0 = 0 ;
5693 PyObject * obj1 = 0 ;
5694 PyObject * obj2 = 0 ;
5695 char *kwnames[] = {
5696 (char *) "self",(char *) "dx",(char *) "dy", NULL
5697 };
5698
5699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5701 if (SWIG_arg_fail(1)) SWIG_fail;
5702 {
5703 arg2 = (int)(SWIG_As_int(obj1));
5704 if (SWIG_arg_fail(2)) SWIG_fail;
5705 }
5706 {
5707 arg3 = (int)(SWIG_As_int(obj2));
5708 if (SWIG_arg_fail(3)) SWIG_fail;
5709 }
5710 {
5711 PyThreadState* __tstate = wxPyBeginAllowThreads();
5712 {
5713 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5714 result = (wxRect *) &_result_ref;
5715 }
5716
5717 wxPyEndAllowThreads(__tstate);
5718 if (PyErr_Occurred()) SWIG_fail;
5719 }
5720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5721 return resultobj;
5722 fail:
5723 return NULL;
5724 }
5725
5726
5727 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5728 PyObject *resultobj;
5729 wxRect *arg1 = (wxRect *) 0 ;
5730 int arg2 ;
5731 int arg3 ;
5732 wxRect *result;
5733 PyObject * obj0 = 0 ;
5734 PyObject * obj1 = 0 ;
5735 PyObject * obj2 = 0 ;
5736 char *kwnames[] = {
5737 (char *) "self",(char *) "dx",(char *) "dy", NULL
5738 };
5739
5740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5742 if (SWIG_arg_fail(1)) SWIG_fail;
5743 {
5744 arg2 = (int)(SWIG_As_int(obj1));
5745 if (SWIG_arg_fail(2)) SWIG_fail;
5746 }
5747 {
5748 arg3 = (int)(SWIG_As_int(obj2));
5749 if (SWIG_arg_fail(3)) SWIG_fail;
5750 }
5751 {
5752 PyThreadState* __tstate = wxPyBeginAllowThreads();
5753 {
5754 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5755 result = (wxRect *) &_result_ref;
5756 }
5757
5758 wxPyEndAllowThreads(__tstate);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5762 return resultobj;
5763 fail:
5764 return NULL;
5765 }
5766
5767
5768 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5769 PyObject *resultobj;
5770 wxRect *arg1 = (wxRect *) 0 ;
5771 int arg2 ;
5772 int arg3 ;
5773 PyObject * obj0 = 0 ;
5774 PyObject * obj1 = 0 ;
5775 PyObject * obj2 = 0 ;
5776 char *kwnames[] = {
5777 (char *) "self",(char *) "dx",(char *) "dy", NULL
5778 };
5779
5780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5782 if (SWIG_arg_fail(1)) SWIG_fail;
5783 {
5784 arg2 = (int)(SWIG_As_int(obj1));
5785 if (SWIG_arg_fail(2)) SWIG_fail;
5786 }
5787 {
5788 arg3 = (int)(SWIG_As_int(obj2));
5789 if (SWIG_arg_fail(3)) SWIG_fail;
5790 }
5791 {
5792 PyThreadState* __tstate = wxPyBeginAllowThreads();
5793 (arg1)->Offset(arg2,arg3);
5794
5795 wxPyEndAllowThreads(__tstate);
5796 if (PyErr_Occurred()) SWIG_fail;
5797 }
5798 Py_INCREF(Py_None); resultobj = Py_None;
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj;
5807 wxRect *arg1 = (wxRect *) 0 ;
5808 wxPoint *arg2 = 0 ;
5809 wxPoint temp2 ;
5810 PyObject * obj0 = 0 ;
5811 PyObject * obj1 = 0 ;
5812 char *kwnames[] = {
5813 (char *) "self",(char *) "pt", NULL
5814 };
5815
5816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5818 if (SWIG_arg_fail(1)) SWIG_fail;
5819 {
5820 arg2 = &temp2;
5821 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5822 }
5823 {
5824 PyThreadState* __tstate = wxPyBeginAllowThreads();
5825 (arg1)->Offset((wxPoint const &)*arg2);
5826
5827 wxPyEndAllowThreads(__tstate);
5828 if (PyErr_Occurred()) SWIG_fail;
5829 }
5830 Py_INCREF(Py_None); resultobj = Py_None;
5831 return resultobj;
5832 fail:
5833 return NULL;
5834 }
5835
5836
5837 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5838 PyObject *resultobj;
5839 wxRect *arg1 = (wxRect *) 0 ;
5840 wxRect *arg2 = 0 ;
5841 wxRect result;
5842 wxRect temp2 ;
5843 PyObject * obj0 = 0 ;
5844 PyObject * obj1 = 0 ;
5845 char *kwnames[] = {
5846 (char *) "self",(char *) "rect", NULL
5847 };
5848
5849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5851 if (SWIG_arg_fail(1)) SWIG_fail;
5852 {
5853 arg2 = &temp2;
5854 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5855 }
5856 {
5857 PyThreadState* __tstate = wxPyBeginAllowThreads();
5858 result = (arg1)->Intersect((wxRect const &)*arg2);
5859
5860 wxPyEndAllowThreads(__tstate);
5861 if (PyErr_Occurred()) SWIG_fail;
5862 }
5863 {
5864 wxRect * resultptr;
5865 resultptr = new wxRect((wxRect &)(result));
5866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5867 }
5868 return resultobj;
5869 fail:
5870 return NULL;
5871 }
5872
5873
5874 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5875 PyObject *resultobj;
5876 wxRect *arg1 = (wxRect *) 0 ;
5877 wxRect *arg2 = 0 ;
5878 wxRect result;
5879 wxRect temp2 ;
5880 PyObject * obj0 = 0 ;
5881 PyObject * obj1 = 0 ;
5882 char *kwnames[] = {
5883 (char *) "self",(char *) "rect", NULL
5884 };
5885
5886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5888 if (SWIG_arg_fail(1)) SWIG_fail;
5889 {
5890 arg2 = &temp2;
5891 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5892 }
5893 {
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 result = (arg1)->Union((wxRect const &)*arg2);
5896
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 {
5901 wxRect * resultptr;
5902 resultptr = new wxRect((wxRect &)(result));
5903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5904 }
5905 return resultobj;
5906 fail:
5907 return NULL;
5908 }
5909
5910
5911 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5912 PyObject *resultobj;
5913 wxRect *arg1 = (wxRect *) 0 ;
5914 wxRect *arg2 = 0 ;
5915 wxRect result;
5916 wxRect temp2 ;
5917 PyObject * obj0 = 0 ;
5918 PyObject * obj1 = 0 ;
5919 char *kwnames[] = {
5920 (char *) "self",(char *) "rect", NULL
5921 };
5922
5923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5925 if (SWIG_arg_fail(1)) SWIG_fail;
5926 {
5927 arg2 = &temp2;
5928 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5929 }
5930 {
5931 PyThreadState* __tstate = wxPyBeginAllowThreads();
5932 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5933
5934 wxPyEndAllowThreads(__tstate);
5935 if (PyErr_Occurred()) SWIG_fail;
5936 }
5937 {
5938 wxRect * resultptr;
5939 resultptr = new wxRect((wxRect &)(result));
5940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5941 }
5942 return resultobj;
5943 fail:
5944 return NULL;
5945 }
5946
5947
5948 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5949 PyObject *resultobj;
5950 wxRect *arg1 = (wxRect *) 0 ;
5951 wxRect *arg2 = 0 ;
5952 wxRect *result;
5953 wxRect temp2 ;
5954 PyObject * obj0 = 0 ;
5955 PyObject * obj1 = 0 ;
5956 char *kwnames[] = {
5957 (char *) "self",(char *) "rect", NULL
5958 };
5959
5960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5962 if (SWIG_arg_fail(1)) SWIG_fail;
5963 {
5964 arg2 = &temp2;
5965 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5966 }
5967 {
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 {
5970 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5971 result = (wxRect *) &_result_ref;
5972 }
5973
5974 wxPyEndAllowThreads(__tstate);
5975 if (PyErr_Occurred()) SWIG_fail;
5976 }
5977 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5978 return resultobj;
5979 fail:
5980 return NULL;
5981 }
5982
5983
5984 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5985 PyObject *resultobj;
5986 wxRect *arg1 = (wxRect *) 0 ;
5987 wxRect *arg2 = 0 ;
5988 bool result;
5989 wxRect temp2 ;
5990 PyObject * obj0 = 0 ;
5991 PyObject * obj1 = 0 ;
5992 char *kwnames[] = {
5993 (char *) "self",(char *) "rect", NULL
5994 };
5995
5996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5998 if (SWIG_arg_fail(1)) SWIG_fail;
5999 {
6000 arg2 = &temp2;
6001 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6002 }
6003 {
6004 PyThreadState* __tstate = wxPyBeginAllowThreads();
6005 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6006
6007 wxPyEndAllowThreads(__tstate);
6008 if (PyErr_Occurred()) SWIG_fail;
6009 }
6010 {
6011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6012 }
6013 return resultobj;
6014 fail:
6015 return NULL;
6016 }
6017
6018
6019 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6020 PyObject *resultobj;
6021 wxRect *arg1 = (wxRect *) 0 ;
6022 wxRect *arg2 = 0 ;
6023 bool result;
6024 wxRect temp2 ;
6025 PyObject * obj0 = 0 ;
6026 PyObject * obj1 = 0 ;
6027 char *kwnames[] = {
6028 (char *) "self",(char *) "rect", NULL
6029 };
6030
6031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6033 if (SWIG_arg_fail(1)) SWIG_fail;
6034 {
6035 arg2 = &temp2;
6036 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6037 }
6038 {
6039 PyThreadState* __tstate = wxPyBeginAllowThreads();
6040 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6041
6042 wxPyEndAllowThreads(__tstate);
6043 if (PyErr_Occurred()) SWIG_fail;
6044 }
6045 {
6046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6047 }
6048 return resultobj;
6049 fail:
6050 return NULL;
6051 }
6052
6053
6054 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6055 PyObject *resultobj;
6056 wxRect *arg1 = (wxRect *) 0 ;
6057 int arg2 ;
6058 int arg3 ;
6059 bool result;
6060 PyObject * obj0 = 0 ;
6061 PyObject * obj1 = 0 ;
6062 PyObject * obj2 = 0 ;
6063 char *kwnames[] = {
6064 (char *) "self",(char *) "x",(char *) "y", NULL
6065 };
6066
6067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6069 if (SWIG_arg_fail(1)) SWIG_fail;
6070 {
6071 arg2 = (int)(SWIG_As_int(obj1));
6072 if (SWIG_arg_fail(2)) SWIG_fail;
6073 }
6074 {
6075 arg3 = (int)(SWIG_As_int(obj2));
6076 if (SWIG_arg_fail(3)) SWIG_fail;
6077 }
6078 {
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6081
6082 wxPyEndAllowThreads(__tstate);
6083 if (PyErr_Occurred()) SWIG_fail;
6084 }
6085 {
6086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6087 }
6088 return resultobj;
6089 fail:
6090 return NULL;
6091 }
6092
6093
6094 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6095 PyObject *resultobj;
6096 wxRect *arg1 = (wxRect *) 0 ;
6097 wxPoint *arg2 = 0 ;
6098 bool result;
6099 wxPoint temp2 ;
6100 PyObject * obj0 = 0 ;
6101 PyObject * obj1 = 0 ;
6102 char *kwnames[] = {
6103 (char *) "self",(char *) "pt", NULL
6104 };
6105
6106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6108 if (SWIG_arg_fail(1)) SWIG_fail;
6109 {
6110 arg2 = &temp2;
6111 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6112 }
6113 {
6114 PyThreadState* __tstate = wxPyBeginAllowThreads();
6115 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6116
6117 wxPyEndAllowThreads(__tstate);
6118 if (PyErr_Occurred()) SWIG_fail;
6119 }
6120 {
6121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6122 }
6123 return resultobj;
6124 fail:
6125 return NULL;
6126 }
6127
6128
6129 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6130 PyObject *resultobj;
6131 wxRect *arg1 = (wxRect *) 0 ;
6132 wxRect *arg2 = 0 ;
6133 bool result;
6134 wxRect temp2 ;
6135 PyObject * obj0 = 0 ;
6136 PyObject * obj1 = 0 ;
6137 char *kwnames[] = {
6138 (char *) "self",(char *) "rect", NULL
6139 };
6140
6141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6143 if (SWIG_arg_fail(1)) SWIG_fail;
6144 {
6145 arg2 = &temp2;
6146 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6147 }
6148 {
6149 PyThreadState* __tstate = wxPyBeginAllowThreads();
6150 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6151
6152 wxPyEndAllowThreads(__tstate);
6153 if (PyErr_Occurred()) SWIG_fail;
6154 }
6155 {
6156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6157 }
6158 return resultobj;
6159 fail:
6160 return NULL;
6161 }
6162
6163
6164 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6165 PyObject *resultobj;
6166 wxRect *arg1 = (wxRect *) 0 ;
6167 int arg2 ;
6168 PyObject * obj0 = 0 ;
6169 PyObject * obj1 = 0 ;
6170 char *kwnames[] = {
6171 (char *) "self",(char *) "x", NULL
6172 };
6173
6174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6176 if (SWIG_arg_fail(1)) SWIG_fail;
6177 {
6178 arg2 = (int)(SWIG_As_int(obj1));
6179 if (SWIG_arg_fail(2)) SWIG_fail;
6180 }
6181 if (arg1) (arg1)->x = arg2;
6182
6183 Py_INCREF(Py_None); resultobj = Py_None;
6184 return resultobj;
6185 fail:
6186 return NULL;
6187 }
6188
6189
6190 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6191 PyObject *resultobj;
6192 wxRect *arg1 = (wxRect *) 0 ;
6193 int result;
6194 PyObject * obj0 = 0 ;
6195 char *kwnames[] = {
6196 (char *) "self", NULL
6197 };
6198
6199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6201 if (SWIG_arg_fail(1)) SWIG_fail;
6202 result = (int) ((arg1)->x);
6203
6204 {
6205 resultobj = SWIG_From_int((int)(result));
6206 }
6207 return resultobj;
6208 fail:
6209 return NULL;
6210 }
6211
6212
6213 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6214 PyObject *resultobj;
6215 wxRect *arg1 = (wxRect *) 0 ;
6216 int arg2 ;
6217 PyObject * obj0 = 0 ;
6218 PyObject * obj1 = 0 ;
6219 char *kwnames[] = {
6220 (char *) "self",(char *) "y", NULL
6221 };
6222
6223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6225 if (SWIG_arg_fail(1)) SWIG_fail;
6226 {
6227 arg2 = (int)(SWIG_As_int(obj1));
6228 if (SWIG_arg_fail(2)) SWIG_fail;
6229 }
6230 if (arg1) (arg1)->y = arg2;
6231
6232 Py_INCREF(Py_None); resultobj = Py_None;
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6240 PyObject *resultobj;
6241 wxRect *arg1 = (wxRect *) 0 ;
6242 int result;
6243 PyObject * obj0 = 0 ;
6244 char *kwnames[] = {
6245 (char *) "self", NULL
6246 };
6247
6248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6250 if (SWIG_arg_fail(1)) SWIG_fail;
6251 result = (int) ((arg1)->y);
6252
6253 {
6254 resultobj = SWIG_From_int((int)(result));
6255 }
6256 return resultobj;
6257 fail:
6258 return NULL;
6259 }
6260
6261
6262 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6263 PyObject *resultobj;
6264 wxRect *arg1 = (wxRect *) 0 ;
6265 int arg2 ;
6266 PyObject * obj0 = 0 ;
6267 PyObject * obj1 = 0 ;
6268 char *kwnames[] = {
6269 (char *) "self",(char *) "width", NULL
6270 };
6271
6272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6274 if (SWIG_arg_fail(1)) SWIG_fail;
6275 {
6276 arg2 = (int)(SWIG_As_int(obj1));
6277 if (SWIG_arg_fail(2)) SWIG_fail;
6278 }
6279 if (arg1) (arg1)->width = arg2;
6280
6281 Py_INCREF(Py_None); resultobj = Py_None;
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj;
6290 wxRect *arg1 = (wxRect *) 0 ;
6291 int result;
6292 PyObject * obj0 = 0 ;
6293 char *kwnames[] = {
6294 (char *) "self", NULL
6295 };
6296
6297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6299 if (SWIG_arg_fail(1)) SWIG_fail;
6300 result = (int) ((arg1)->width);
6301
6302 {
6303 resultobj = SWIG_From_int((int)(result));
6304 }
6305 return resultobj;
6306 fail:
6307 return NULL;
6308 }
6309
6310
6311 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6312 PyObject *resultobj;
6313 wxRect *arg1 = (wxRect *) 0 ;
6314 int arg2 ;
6315 PyObject * obj0 = 0 ;
6316 PyObject * obj1 = 0 ;
6317 char *kwnames[] = {
6318 (char *) "self",(char *) "height", NULL
6319 };
6320
6321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6323 if (SWIG_arg_fail(1)) SWIG_fail;
6324 {
6325 arg2 = (int)(SWIG_As_int(obj1));
6326 if (SWIG_arg_fail(2)) SWIG_fail;
6327 }
6328 if (arg1) (arg1)->height = arg2;
6329
6330 Py_INCREF(Py_None); resultobj = Py_None;
6331 return resultobj;
6332 fail:
6333 return NULL;
6334 }
6335
6336
6337 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6338 PyObject *resultobj;
6339 wxRect *arg1 = (wxRect *) 0 ;
6340 int result;
6341 PyObject * obj0 = 0 ;
6342 char *kwnames[] = {
6343 (char *) "self", NULL
6344 };
6345
6346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6348 if (SWIG_arg_fail(1)) SWIG_fail;
6349 result = (int) ((arg1)->height);
6350
6351 {
6352 resultobj = SWIG_From_int((int)(result));
6353 }
6354 return resultobj;
6355 fail:
6356 return NULL;
6357 }
6358
6359
6360 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6361 PyObject *resultobj;
6362 wxRect *arg1 = (wxRect *) 0 ;
6363 int arg2 = (int) 0 ;
6364 int arg3 = (int) 0 ;
6365 int arg4 = (int) 0 ;
6366 int arg5 = (int) 0 ;
6367 PyObject * obj0 = 0 ;
6368 PyObject * obj1 = 0 ;
6369 PyObject * obj2 = 0 ;
6370 PyObject * obj3 = 0 ;
6371 PyObject * obj4 = 0 ;
6372 char *kwnames[] = {
6373 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6374 };
6375
6376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6378 if (SWIG_arg_fail(1)) SWIG_fail;
6379 if (obj1) {
6380 {
6381 arg2 = (int)(SWIG_As_int(obj1));
6382 if (SWIG_arg_fail(2)) SWIG_fail;
6383 }
6384 }
6385 if (obj2) {
6386 {
6387 arg3 = (int)(SWIG_As_int(obj2));
6388 if (SWIG_arg_fail(3)) SWIG_fail;
6389 }
6390 }
6391 if (obj3) {
6392 {
6393 arg4 = (int)(SWIG_As_int(obj3));
6394 if (SWIG_arg_fail(4)) SWIG_fail;
6395 }
6396 }
6397 if (obj4) {
6398 {
6399 arg5 = (int)(SWIG_As_int(obj4));
6400 if (SWIG_arg_fail(5)) SWIG_fail;
6401 }
6402 }
6403 {
6404 PyThreadState* __tstate = wxPyBeginAllowThreads();
6405 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6406
6407 wxPyEndAllowThreads(__tstate);
6408 if (PyErr_Occurred()) SWIG_fail;
6409 }
6410 Py_INCREF(Py_None); resultobj = Py_None;
6411 return resultobj;
6412 fail:
6413 return NULL;
6414 }
6415
6416
6417 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6418 PyObject *resultobj;
6419 wxRect *arg1 = (wxRect *) 0 ;
6420 PyObject *result;
6421 PyObject * obj0 = 0 ;
6422 char *kwnames[] = {
6423 (char *) "self", NULL
6424 };
6425
6426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6428 if (SWIG_arg_fail(1)) SWIG_fail;
6429 {
6430 PyThreadState* __tstate = wxPyBeginAllowThreads();
6431 result = (PyObject *)wxRect_Get(arg1);
6432
6433 wxPyEndAllowThreads(__tstate);
6434 if (PyErr_Occurred()) SWIG_fail;
6435 }
6436 resultobj = result;
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6444 PyObject *obj;
6445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6446 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6447 Py_INCREF(obj);
6448 return Py_BuildValue((char *)"");
6449 }
6450 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6451 PyObject *resultobj;
6452 wxRect *arg1 = (wxRect *) 0 ;
6453 wxRect *arg2 = (wxRect *) 0 ;
6454 PyObject *result;
6455 PyObject * obj0 = 0 ;
6456 PyObject * obj1 = 0 ;
6457 char *kwnames[] = {
6458 (char *) "r1",(char *) "r2", NULL
6459 };
6460
6461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6463 if (SWIG_arg_fail(1)) SWIG_fail;
6464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6465 if (SWIG_arg_fail(2)) SWIG_fail;
6466 {
6467 if (!wxPyCheckForApp()) SWIG_fail;
6468 PyThreadState* __tstate = wxPyBeginAllowThreads();
6469 result = (PyObject *)wxIntersectRect(arg1,arg2);
6470
6471 wxPyEndAllowThreads(__tstate);
6472 if (PyErr_Occurred()) SWIG_fail;
6473 }
6474 resultobj = result;
6475 return resultobj;
6476 fail:
6477 return NULL;
6478 }
6479
6480
6481 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6482 PyObject *resultobj;
6483 double arg1 = (double) 0.0 ;
6484 double arg2 = (double) 0.0 ;
6485 wxPoint2D *result;
6486 PyObject * obj0 = 0 ;
6487 PyObject * obj1 = 0 ;
6488 char *kwnames[] = {
6489 (char *) "x",(char *) "y", NULL
6490 };
6491
6492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6493 if (obj0) {
6494 {
6495 arg1 = (double)(SWIG_As_double(obj0));
6496 if (SWIG_arg_fail(1)) SWIG_fail;
6497 }
6498 }
6499 if (obj1) {
6500 {
6501 arg2 = (double)(SWIG_As_double(obj1));
6502 if (SWIG_arg_fail(2)) SWIG_fail;
6503 }
6504 }
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
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_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6520 PyObject *resultobj;
6521 wxPoint2D *arg1 = 0 ;
6522 wxPoint2D *result;
6523 wxPoint2D temp1 ;
6524 PyObject * obj0 = 0 ;
6525 char *kwnames[] = {
6526 (char *) "pt", NULL
6527 };
6528
6529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6530 {
6531 arg1 = &temp1;
6532 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6533 }
6534 {
6535 PyThreadState* __tstate = wxPyBeginAllowThreads();
6536 result = (wxPoint2D *)new wxPoint2D((wxPoint2D 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_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6549 PyObject *resultobj;
6550 wxPoint *arg1 = 0 ;
6551 wxPoint2D *result;
6552 wxPoint temp1 ;
6553 PyObject * obj0 = 0 ;
6554 char *kwnames[] = {
6555 (char *) "pt", NULL
6556 };
6557
6558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6559 {
6560 arg1 = &temp1;
6561 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6562 }
6563 {
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6566
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6571 return resultobj;
6572 fail:
6573 return NULL;
6574 }
6575
6576
6577 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6578 PyObject *resultobj;
6579 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6580 int *arg2 = (int *) 0 ;
6581 int *arg3 = (int *) 0 ;
6582 int temp2 ;
6583 int res2 = 0 ;
6584 int temp3 ;
6585 int res3 = 0 ;
6586 PyObject * obj0 = 0 ;
6587 char *kwnames[] = {
6588 (char *) "self", NULL
6589 };
6590
6591 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6592 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6595 if (SWIG_arg_fail(1)) SWIG_fail;
6596 {
6597 PyThreadState* __tstate = wxPyBeginAllowThreads();
6598 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6599
6600 wxPyEndAllowThreads(__tstate);
6601 if (PyErr_Occurred()) SWIG_fail;
6602 }
6603 Py_INCREF(Py_None); resultobj = Py_None;
6604 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6605 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6606 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6607 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6608 return resultobj;
6609 fail:
6610 return NULL;
6611 }
6612
6613
6614 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6615 PyObject *resultobj;
6616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6617 int *arg2 = (int *) 0 ;
6618 int *arg3 = (int *) 0 ;
6619 int temp2 ;
6620 int res2 = 0 ;
6621 int temp3 ;
6622 int res3 = 0 ;
6623 PyObject * obj0 = 0 ;
6624 char *kwnames[] = {
6625 (char *) "self", NULL
6626 };
6627
6628 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6629 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6632 if (SWIG_arg_fail(1)) SWIG_fail;
6633 {
6634 PyThreadState* __tstate = wxPyBeginAllowThreads();
6635 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6636
6637 wxPyEndAllowThreads(__tstate);
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 Py_INCREF(Py_None); resultobj = Py_None;
6641 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6642 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6643 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6644 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6652 PyObject *resultobj;
6653 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6654 double result;
6655 PyObject * obj0 = 0 ;
6656 char *kwnames[] = {
6657 (char *) "self", NULL
6658 };
6659
6660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6662 if (SWIG_arg_fail(1)) SWIG_fail;
6663 {
6664 PyThreadState* __tstate = wxPyBeginAllowThreads();
6665 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6666
6667 wxPyEndAllowThreads(__tstate);
6668 if (PyErr_Occurred()) SWIG_fail;
6669 }
6670 {
6671 resultobj = SWIG_From_double((double)(result));
6672 }
6673 return resultobj;
6674 fail:
6675 return NULL;
6676 }
6677
6678
6679 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6680 PyObject *resultobj;
6681 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6682 double result;
6683 PyObject * obj0 = 0 ;
6684 char *kwnames[] = {
6685 (char *) "self", NULL
6686 };
6687
6688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
6693 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6694
6695 wxPyEndAllowThreads(__tstate);
6696 if (PyErr_Occurred()) SWIG_fail;
6697 }
6698 {
6699 resultobj = SWIG_From_double((double)(result));
6700 }
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6708 PyObject *resultobj;
6709 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6710 double arg2 ;
6711 PyObject * obj0 = 0 ;
6712 PyObject * obj1 = 0 ;
6713 char *kwnames[] = {
6714 (char *) "self",(char *) "length", NULL
6715 };
6716
6717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6719 if (SWIG_arg_fail(1)) SWIG_fail;
6720 {
6721 arg2 = (double)(SWIG_As_double(obj1));
6722 if (SWIG_arg_fail(2)) SWIG_fail;
6723 }
6724 {
6725 PyThreadState* __tstate = wxPyBeginAllowThreads();
6726 (arg1)->SetVectorLength(arg2);
6727
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 Py_INCREF(Py_None); resultobj = Py_None;
6732 return resultobj;
6733 fail:
6734 return NULL;
6735 }
6736
6737
6738 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6739 PyObject *resultobj;
6740 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6741 double arg2 ;
6742 PyObject * obj0 = 0 ;
6743 PyObject * obj1 = 0 ;
6744 char *kwnames[] = {
6745 (char *) "self",(char *) "degrees", NULL
6746 };
6747
6748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6750 if (SWIG_arg_fail(1)) SWIG_fail;
6751 {
6752 arg2 = (double)(SWIG_As_double(obj1));
6753 if (SWIG_arg_fail(2)) SWIG_fail;
6754 }
6755 {
6756 PyThreadState* __tstate = wxPyBeginAllowThreads();
6757 (arg1)->SetVectorAngle(arg2);
6758
6759 wxPyEndAllowThreads(__tstate);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 Py_INCREF(Py_None); resultobj = Py_None;
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6770 PyObject *resultobj;
6771 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6772 wxPoint2D *arg2 = 0 ;
6773 double result;
6774 wxPoint2D temp2 ;
6775 PyObject * obj0 = 0 ;
6776 PyObject * obj1 = 0 ;
6777 char *kwnames[] = {
6778 (char *) "self",(char *) "pt", NULL
6779 };
6780
6781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6783 if (SWIG_arg_fail(1)) SWIG_fail;
6784 {
6785 arg2 = &temp2;
6786 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6787 }
6788 {
6789 PyThreadState* __tstate = wxPyBeginAllowThreads();
6790 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6791
6792 wxPyEndAllowThreads(__tstate);
6793 if (PyErr_Occurred()) SWIG_fail;
6794 }
6795 {
6796 resultobj = SWIG_From_double((double)(result));
6797 }
6798 return resultobj;
6799 fail:
6800 return NULL;
6801 }
6802
6803
6804 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6805 PyObject *resultobj;
6806 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6807 wxPoint2D *arg2 = 0 ;
6808 double result;
6809 wxPoint2D temp2 ;
6810 PyObject * obj0 = 0 ;
6811 PyObject * obj1 = 0 ;
6812 char *kwnames[] = {
6813 (char *) "self",(char *) "pt", NULL
6814 };
6815
6816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6818 if (SWIG_arg_fail(1)) SWIG_fail;
6819 {
6820 arg2 = &temp2;
6821 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6822 }
6823 {
6824 PyThreadState* __tstate = wxPyBeginAllowThreads();
6825 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6826
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 {
6831 resultobj = SWIG_From_double((double)(result));
6832 }
6833 return resultobj;
6834 fail:
6835 return NULL;
6836 }
6837
6838
6839 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6840 PyObject *resultobj;
6841 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6842 wxPoint2D *arg2 = 0 ;
6843 double result;
6844 wxPoint2D temp2 ;
6845 PyObject * obj0 = 0 ;
6846 PyObject * obj1 = 0 ;
6847 char *kwnames[] = {
6848 (char *) "self",(char *) "vec", NULL
6849 };
6850
6851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6853 if (SWIG_arg_fail(1)) SWIG_fail;
6854 {
6855 arg2 = &temp2;
6856 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6857 }
6858 {
6859 PyThreadState* __tstate = wxPyBeginAllowThreads();
6860 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6861
6862 wxPyEndAllowThreads(__tstate);
6863 if (PyErr_Occurred()) SWIG_fail;
6864 }
6865 {
6866 resultobj = SWIG_From_double((double)(result));
6867 }
6868 return resultobj;
6869 fail:
6870 return NULL;
6871 }
6872
6873
6874 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6875 PyObject *resultobj;
6876 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6877 wxPoint2D *arg2 = 0 ;
6878 double result;
6879 wxPoint2D temp2 ;
6880 PyObject * obj0 = 0 ;
6881 PyObject * obj1 = 0 ;
6882 char *kwnames[] = {
6883 (char *) "self",(char *) "vec", NULL
6884 };
6885
6886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6888 if (SWIG_arg_fail(1)) SWIG_fail;
6889 {
6890 arg2 = &temp2;
6891 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6892 }
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6896
6897 wxPyEndAllowThreads(__tstate);
6898 if (PyErr_Occurred()) SWIG_fail;
6899 }
6900 {
6901 resultobj = SWIG_From_double((double)(result));
6902 }
6903 return resultobj;
6904 fail:
6905 return NULL;
6906 }
6907
6908
6909 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6910 PyObject *resultobj;
6911 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6912 wxPoint2D result;
6913 PyObject * obj0 = 0 ;
6914 char *kwnames[] = {
6915 (char *) "self", NULL
6916 };
6917
6918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6920 if (SWIG_arg_fail(1)) SWIG_fail;
6921 {
6922 PyThreadState* __tstate = wxPyBeginAllowThreads();
6923 result = (arg1)->operator -();
6924
6925 wxPyEndAllowThreads(__tstate);
6926 if (PyErr_Occurred()) SWIG_fail;
6927 }
6928 {
6929 wxPoint2D * resultptr;
6930 resultptr = new wxPoint2D((wxPoint2D &)(result));
6931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6932 }
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj;
6941 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6942 wxPoint2D *arg2 = 0 ;
6943 wxPoint2D *result;
6944 wxPoint2D temp2 ;
6945 PyObject * obj0 = 0 ;
6946 PyObject * obj1 = 0 ;
6947 char *kwnames[] = {
6948 (char *) "self",(char *) "pt", NULL
6949 };
6950
6951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6953 if (SWIG_arg_fail(1)) SWIG_fail;
6954 {
6955 arg2 = &temp2;
6956 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6957 }
6958 {
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 {
6961 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6962 result = (wxPoint2D *) &_result_ref;
6963 }
6964
6965 wxPyEndAllowThreads(__tstate);
6966 if (PyErr_Occurred()) SWIG_fail;
6967 }
6968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6969 return resultobj;
6970 fail:
6971 return NULL;
6972 }
6973
6974
6975 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6976 PyObject *resultobj;
6977 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6978 wxPoint2D *arg2 = 0 ;
6979 wxPoint2D *result;
6980 wxPoint2D temp2 ;
6981 PyObject * obj0 = 0 ;
6982 PyObject * obj1 = 0 ;
6983 char *kwnames[] = {
6984 (char *) "self",(char *) "pt", NULL
6985 };
6986
6987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6989 if (SWIG_arg_fail(1)) SWIG_fail;
6990 {
6991 arg2 = &temp2;
6992 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6993 }
6994 {
6995 PyThreadState* __tstate = wxPyBeginAllowThreads();
6996 {
6997 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6998 result = (wxPoint2D *) &_result_ref;
6999 }
7000
7001 wxPyEndAllowThreads(__tstate);
7002 if (PyErr_Occurred()) SWIG_fail;
7003 }
7004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7005 return resultobj;
7006 fail:
7007 return NULL;
7008 }
7009
7010
7011 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7012 PyObject *resultobj;
7013 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7014 wxPoint2D *arg2 = 0 ;
7015 wxPoint2D *result;
7016 wxPoint2D temp2 ;
7017 PyObject * obj0 = 0 ;
7018 PyObject * obj1 = 0 ;
7019 char *kwnames[] = {
7020 (char *) "self",(char *) "pt", NULL
7021 };
7022
7023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7025 if (SWIG_arg_fail(1)) SWIG_fail;
7026 {
7027 arg2 = &temp2;
7028 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7029 }
7030 {
7031 PyThreadState* __tstate = wxPyBeginAllowThreads();
7032 {
7033 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7034 result = (wxPoint2D *) &_result_ref;
7035 }
7036
7037 wxPyEndAllowThreads(__tstate);
7038 if (PyErr_Occurred()) SWIG_fail;
7039 }
7040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7041 return resultobj;
7042 fail:
7043 return NULL;
7044 }
7045
7046
7047 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7048 PyObject *resultobj;
7049 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7050 wxPoint2D *arg2 = 0 ;
7051 wxPoint2D *result;
7052 wxPoint2D temp2 ;
7053 PyObject * obj0 = 0 ;
7054 PyObject * obj1 = 0 ;
7055 char *kwnames[] = {
7056 (char *) "self",(char *) "pt", NULL
7057 };
7058
7059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7061 if (SWIG_arg_fail(1)) SWIG_fail;
7062 {
7063 arg2 = &temp2;
7064 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7065 }
7066 {
7067 PyThreadState* __tstate = wxPyBeginAllowThreads();
7068 {
7069 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7070 result = (wxPoint2D *) &_result_ref;
7071 }
7072
7073 wxPyEndAllowThreads(__tstate);
7074 if (PyErr_Occurred()) SWIG_fail;
7075 }
7076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7077 return resultobj;
7078 fail:
7079 return NULL;
7080 }
7081
7082
7083 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7084 PyObject *resultobj;
7085 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7086 wxPoint2D *arg2 = 0 ;
7087 bool result;
7088 wxPoint2D temp2 ;
7089 PyObject * obj0 = 0 ;
7090 PyObject * obj1 = 0 ;
7091 char *kwnames[] = {
7092 (char *) "self",(char *) "pt", NULL
7093 };
7094
7095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7097 if (SWIG_arg_fail(1)) SWIG_fail;
7098 {
7099 arg2 = &temp2;
7100 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7101 }
7102 {
7103 PyThreadState* __tstate = wxPyBeginAllowThreads();
7104 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7105
7106 wxPyEndAllowThreads(__tstate);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 {
7110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7111 }
7112 return resultobj;
7113 fail:
7114 return NULL;
7115 }
7116
7117
7118 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7119 PyObject *resultobj;
7120 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7121 wxPoint2D *arg2 = 0 ;
7122 bool result;
7123 wxPoint2D temp2 ;
7124 PyObject * obj0 = 0 ;
7125 PyObject * obj1 = 0 ;
7126 char *kwnames[] = {
7127 (char *) "self",(char *) "pt", NULL
7128 };
7129
7130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7132 if (SWIG_arg_fail(1)) SWIG_fail;
7133 {
7134 arg2 = &temp2;
7135 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7136 }
7137 {
7138 PyThreadState* __tstate = wxPyBeginAllowThreads();
7139 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7140
7141 wxPyEndAllowThreads(__tstate);
7142 if (PyErr_Occurred()) SWIG_fail;
7143 }
7144 {
7145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7146 }
7147 return resultobj;
7148 fail:
7149 return NULL;
7150 }
7151
7152
7153 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7154 PyObject *resultobj;
7155 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7156 double arg2 ;
7157 PyObject * obj0 = 0 ;
7158 PyObject * obj1 = 0 ;
7159 char *kwnames[] = {
7160 (char *) "self",(char *) "m_x", NULL
7161 };
7162
7163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7165 if (SWIG_arg_fail(1)) SWIG_fail;
7166 {
7167 arg2 = (double)(SWIG_As_double(obj1));
7168 if (SWIG_arg_fail(2)) SWIG_fail;
7169 }
7170 if (arg1) (arg1)->m_x = arg2;
7171
7172 Py_INCREF(Py_None); resultobj = Py_None;
7173 return resultobj;
7174 fail:
7175 return NULL;
7176 }
7177
7178
7179 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7180 PyObject *resultobj;
7181 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7182 double result;
7183 PyObject * obj0 = 0 ;
7184 char *kwnames[] = {
7185 (char *) "self", NULL
7186 };
7187
7188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7190 if (SWIG_arg_fail(1)) SWIG_fail;
7191 result = (double) ((arg1)->m_x);
7192
7193 {
7194 resultobj = SWIG_From_double((double)(result));
7195 }
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7203 PyObject *resultobj;
7204 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7205 double arg2 ;
7206 PyObject * obj0 = 0 ;
7207 PyObject * obj1 = 0 ;
7208 char *kwnames[] = {
7209 (char *) "self",(char *) "m_y", NULL
7210 };
7211
7212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7214 if (SWIG_arg_fail(1)) SWIG_fail;
7215 {
7216 arg2 = (double)(SWIG_As_double(obj1));
7217 if (SWIG_arg_fail(2)) SWIG_fail;
7218 }
7219 if (arg1) (arg1)->m_y = arg2;
7220
7221 Py_INCREF(Py_None); resultobj = Py_None;
7222 return resultobj;
7223 fail:
7224 return NULL;
7225 }
7226
7227
7228 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7229 PyObject *resultobj;
7230 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7231 double result;
7232 PyObject * obj0 = 0 ;
7233 char *kwnames[] = {
7234 (char *) "self", NULL
7235 };
7236
7237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7239 if (SWIG_arg_fail(1)) SWIG_fail;
7240 result = (double) ((arg1)->m_y);
7241
7242 {
7243 resultobj = SWIG_From_double((double)(result));
7244 }
7245 return resultobj;
7246 fail:
7247 return NULL;
7248 }
7249
7250
7251 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7252 PyObject *resultobj;
7253 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7254 double arg2 = (double) 0 ;
7255 double arg3 = (double) 0 ;
7256 PyObject * obj0 = 0 ;
7257 PyObject * obj1 = 0 ;
7258 PyObject * obj2 = 0 ;
7259 char *kwnames[] = {
7260 (char *) "self",(char *) "x",(char *) "y", NULL
7261 };
7262
7263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7265 if (SWIG_arg_fail(1)) SWIG_fail;
7266 if (obj1) {
7267 {
7268 arg2 = (double)(SWIG_As_double(obj1));
7269 if (SWIG_arg_fail(2)) SWIG_fail;
7270 }
7271 }
7272 if (obj2) {
7273 {
7274 arg3 = (double)(SWIG_As_double(obj2));
7275 if (SWIG_arg_fail(3)) SWIG_fail;
7276 }
7277 }
7278 {
7279 PyThreadState* __tstate = wxPyBeginAllowThreads();
7280 wxPoint2D_Set(arg1,arg2,arg3);
7281
7282 wxPyEndAllowThreads(__tstate);
7283 if (PyErr_Occurred()) SWIG_fail;
7284 }
7285 Py_INCREF(Py_None); resultobj = Py_None;
7286 return resultobj;
7287 fail:
7288 return NULL;
7289 }
7290
7291
7292 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7293 PyObject *resultobj;
7294 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7295 PyObject *result;
7296 PyObject * obj0 = 0 ;
7297 char *kwnames[] = {
7298 (char *) "self", NULL
7299 };
7300
7301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7303 if (SWIG_arg_fail(1)) SWIG_fail;
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 result = (PyObject *)wxPoint2D_Get(arg1);
7307
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 resultobj = result;
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7319 PyObject *obj;
7320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7321 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7322 Py_INCREF(obj);
7323 return Py_BuildValue((char *)"");
7324 }
7325 static int _wrap_DefaultPosition_set(PyObject *) {
7326 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7327 return 1;
7328 }
7329
7330
7331 static PyObject *_wrap_DefaultPosition_get(void) {
7332 PyObject *pyobj;
7333
7334 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7335 return pyobj;
7336 }
7337
7338
7339 static int _wrap_DefaultSize_set(PyObject *) {
7340 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7341 return 1;
7342 }
7343
7344
7345 static PyObject *_wrap_DefaultSize_get(void) {
7346 PyObject *pyobj;
7347
7348 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7349 return pyobj;
7350 }
7351
7352
7353 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7354 PyObject *resultobj;
7355 PyObject *arg1 = (PyObject *) 0 ;
7356 wxPyInputStream *result;
7357 PyObject * obj0 = 0 ;
7358 char *kwnames[] = {
7359 (char *) "p", NULL
7360 };
7361
7362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7363 arg1 = obj0;
7364 {
7365 PyThreadState* __tstate = wxPyBeginAllowThreads();
7366 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7367
7368 wxPyEndAllowThreads(__tstate);
7369 if (PyErr_Occurred()) SWIG_fail;
7370 }
7371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7379 PyObject *resultobj;
7380 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7381 PyObject * obj0 = 0 ;
7382 char *kwnames[] = {
7383 (char *) "self", NULL
7384 };
7385
7386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7388 if (SWIG_arg_fail(1)) SWIG_fail;
7389 {
7390 PyThreadState* __tstate = wxPyBeginAllowThreads();
7391 delete arg1;
7392
7393 wxPyEndAllowThreads(__tstate);
7394 if (PyErr_Occurred()) SWIG_fail;
7395 }
7396 Py_INCREF(Py_None); resultobj = Py_None;
7397 return resultobj;
7398 fail:
7399 return NULL;
7400 }
7401
7402
7403 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7404 PyObject *resultobj;
7405 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7406 PyObject * obj0 = 0 ;
7407 char *kwnames[] = {
7408 (char *) "self", NULL
7409 };
7410
7411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7413 if (SWIG_arg_fail(1)) SWIG_fail;
7414 {
7415 PyThreadState* __tstate = wxPyBeginAllowThreads();
7416 (arg1)->close();
7417
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 Py_INCREF(Py_None); resultobj = Py_None;
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj;
7430 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7431 PyObject * obj0 = 0 ;
7432 char *kwnames[] = {
7433 (char *) "self", NULL
7434 };
7435
7436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7438 if (SWIG_arg_fail(1)) SWIG_fail;
7439 {
7440 PyThreadState* __tstate = wxPyBeginAllowThreads();
7441 (arg1)->flush();
7442
7443 wxPyEndAllowThreads(__tstate);
7444 if (PyErr_Occurred()) SWIG_fail;
7445 }
7446 Py_INCREF(Py_None); resultobj = Py_None;
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj;
7455 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7456 bool result;
7457 PyObject * obj0 = 0 ;
7458 char *kwnames[] = {
7459 (char *) "self", NULL
7460 };
7461
7462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7464 if (SWIG_arg_fail(1)) SWIG_fail;
7465 {
7466 PyThreadState* __tstate = wxPyBeginAllowThreads();
7467 result = (bool)(arg1)->eof();
7468
7469 wxPyEndAllowThreads(__tstate);
7470 if (PyErr_Occurred()) SWIG_fail;
7471 }
7472 {
7473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7474 }
7475 return resultobj;
7476 fail:
7477 return NULL;
7478 }
7479
7480
7481 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7482 PyObject *resultobj;
7483 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7484 int arg2 = (int) -1 ;
7485 PyObject *result;
7486 PyObject * obj0 = 0 ;
7487 PyObject * obj1 = 0 ;
7488 char *kwnames[] = {
7489 (char *) "self",(char *) "size", NULL
7490 };
7491
7492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7494 if (SWIG_arg_fail(1)) SWIG_fail;
7495 if (obj1) {
7496 {
7497 arg2 = (int)(SWIG_As_int(obj1));
7498 if (SWIG_arg_fail(2)) SWIG_fail;
7499 }
7500 }
7501 {
7502 PyThreadState* __tstate = wxPyBeginAllowThreads();
7503 result = (PyObject *)(arg1)->read(arg2);
7504
7505 wxPyEndAllowThreads(__tstate);
7506 if (PyErr_Occurred()) SWIG_fail;
7507 }
7508 resultobj = result;
7509 return resultobj;
7510 fail:
7511 return NULL;
7512 }
7513
7514
7515 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7516 PyObject *resultobj;
7517 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7518 int arg2 = (int) -1 ;
7519 PyObject *result;
7520 PyObject * obj0 = 0 ;
7521 PyObject * obj1 = 0 ;
7522 char *kwnames[] = {
7523 (char *) "self",(char *) "size", NULL
7524 };
7525
7526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7528 if (SWIG_arg_fail(1)) SWIG_fail;
7529 if (obj1) {
7530 {
7531 arg2 = (int)(SWIG_As_int(obj1));
7532 if (SWIG_arg_fail(2)) SWIG_fail;
7533 }
7534 }
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 result = (PyObject *)(arg1)->readline(arg2);
7538
7539 wxPyEndAllowThreads(__tstate);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 resultobj = result;
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj;
7551 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7552 int arg2 = (int) -1 ;
7553 PyObject *result;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 char *kwnames[] = {
7557 (char *) "self",(char *) "sizehint", NULL
7558 };
7559
7560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7562 if (SWIG_arg_fail(1)) SWIG_fail;
7563 if (obj1) {
7564 {
7565 arg2 = (int)(SWIG_As_int(obj1));
7566 if (SWIG_arg_fail(2)) SWIG_fail;
7567 }
7568 }
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = (PyObject *)(arg1)->readlines(arg2);
7572
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 resultobj = result;
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj;
7585 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7586 int arg2 ;
7587 int arg3 = (int) 0 ;
7588 PyObject * obj0 = 0 ;
7589 PyObject * obj1 = 0 ;
7590 PyObject * obj2 = 0 ;
7591 char *kwnames[] = {
7592 (char *) "self",(char *) "offset",(char *) "whence", NULL
7593 };
7594
7595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7597 if (SWIG_arg_fail(1)) SWIG_fail;
7598 {
7599 arg2 = (int)(SWIG_As_int(obj1));
7600 if (SWIG_arg_fail(2)) SWIG_fail;
7601 }
7602 if (obj2) {
7603 {
7604 arg3 = (int)(SWIG_As_int(obj2));
7605 if (SWIG_arg_fail(3)) SWIG_fail;
7606 }
7607 }
7608 {
7609 PyThreadState* __tstate = wxPyBeginAllowThreads();
7610 (arg1)->seek(arg2,arg3);
7611
7612 wxPyEndAllowThreads(__tstate);
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 Py_INCREF(Py_None); resultobj = Py_None;
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj;
7624 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7625 int result;
7626 PyObject * obj0 = 0 ;
7627 char *kwnames[] = {
7628 (char *) "self", NULL
7629 };
7630
7631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7633 if (SWIG_arg_fail(1)) SWIG_fail;
7634 {
7635 PyThreadState* __tstate = wxPyBeginAllowThreads();
7636 result = (int)(arg1)->tell();
7637
7638 wxPyEndAllowThreads(__tstate);
7639 if (PyErr_Occurred()) SWIG_fail;
7640 }
7641 {
7642 resultobj = SWIG_From_int((int)(result));
7643 }
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7651 PyObject *resultobj;
7652 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7653 char result;
7654 PyObject * obj0 = 0 ;
7655 char *kwnames[] = {
7656 (char *) "self", NULL
7657 };
7658
7659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7661 if (SWIG_arg_fail(1)) SWIG_fail;
7662 {
7663 PyThreadState* __tstate = wxPyBeginAllowThreads();
7664 result = (char)(arg1)->Peek();
7665
7666 wxPyEndAllowThreads(__tstate);
7667 if (PyErr_Occurred()) SWIG_fail;
7668 }
7669 {
7670 resultobj = SWIG_From_char((char)(result));
7671 }
7672 return resultobj;
7673 fail:
7674 return NULL;
7675 }
7676
7677
7678 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7679 PyObject *resultobj;
7680 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7681 char result;
7682 PyObject * obj0 = 0 ;
7683 char *kwnames[] = {
7684 (char *) "self", NULL
7685 };
7686
7687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7689 if (SWIG_arg_fail(1)) SWIG_fail;
7690 {
7691 PyThreadState* __tstate = wxPyBeginAllowThreads();
7692 result = (char)(arg1)->GetC();
7693
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 {
7698 resultobj = SWIG_From_char((char)(result));
7699 }
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj;
7708 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7709 size_t result;
7710 PyObject * obj0 = 0 ;
7711 char *kwnames[] = {
7712 (char *) "self", NULL
7713 };
7714
7715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7717 if (SWIG_arg_fail(1)) SWIG_fail;
7718 {
7719 PyThreadState* __tstate = wxPyBeginAllowThreads();
7720 result = (size_t)(arg1)->LastRead();
7721
7722 wxPyEndAllowThreads(__tstate);
7723 if (PyErr_Occurred()) SWIG_fail;
7724 }
7725 {
7726 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7727 }
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7735 PyObject *resultobj;
7736 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7737 bool result;
7738 PyObject * obj0 = 0 ;
7739 char *kwnames[] = {
7740 (char *) "self", NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(1)) SWIG_fail;
7746 {
7747 PyThreadState* __tstate = wxPyBeginAllowThreads();
7748 result = (bool)(arg1)->CanRead();
7749
7750 wxPyEndAllowThreads(__tstate);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 {
7754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7755 }
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7763 PyObject *resultobj;
7764 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7765 bool result;
7766 PyObject * obj0 = 0 ;
7767 char *kwnames[] = {
7768 (char *) "self", NULL
7769 };
7770
7771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7773 if (SWIG_arg_fail(1)) SWIG_fail;
7774 {
7775 PyThreadState* __tstate = wxPyBeginAllowThreads();
7776 result = (bool)(arg1)->Eof();
7777
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 {
7782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7783 }
7784 return resultobj;
7785 fail:
7786 return NULL;
7787 }
7788
7789
7790 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7791 PyObject *resultobj;
7792 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7793 char arg2 ;
7794 bool result;
7795 PyObject * obj0 = 0 ;
7796 PyObject * obj1 = 0 ;
7797 char *kwnames[] = {
7798 (char *) "self",(char *) "c", NULL
7799 };
7800
7801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7803 if (SWIG_arg_fail(1)) SWIG_fail;
7804 {
7805 arg2 = (char)(SWIG_As_char(obj1));
7806 if (SWIG_arg_fail(2)) SWIG_fail;
7807 }
7808 {
7809 PyThreadState* __tstate = wxPyBeginAllowThreads();
7810 result = (bool)(arg1)->Ungetch(arg2);
7811
7812 wxPyEndAllowThreads(__tstate);
7813 if (PyErr_Occurred()) SWIG_fail;
7814 }
7815 {
7816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7817 }
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7825 PyObject *resultobj;
7826 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7827 long arg2 ;
7828 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7829 long result;
7830 PyObject * obj0 = 0 ;
7831 PyObject * obj1 = 0 ;
7832 PyObject * obj2 = 0 ;
7833 char *kwnames[] = {
7834 (char *) "self",(char *) "pos",(char *) "mode", NULL
7835 };
7836
7837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7839 if (SWIG_arg_fail(1)) SWIG_fail;
7840 {
7841 arg2 = (long)(SWIG_As_long(obj1));
7842 if (SWIG_arg_fail(2)) SWIG_fail;
7843 }
7844 if (obj2) {
7845 {
7846 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7847 if (SWIG_arg_fail(3)) SWIG_fail;
7848 }
7849 }
7850 {
7851 PyThreadState* __tstate = wxPyBeginAllowThreads();
7852 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7853
7854 wxPyEndAllowThreads(__tstate);
7855 if (PyErr_Occurred()) SWIG_fail;
7856 }
7857 {
7858 resultobj = SWIG_From_long((long)(result));
7859 }
7860 return resultobj;
7861 fail:
7862 return NULL;
7863 }
7864
7865
7866 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7867 PyObject *resultobj;
7868 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7869 long result;
7870 PyObject * obj0 = 0 ;
7871 char *kwnames[] = {
7872 (char *) "self", NULL
7873 };
7874
7875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7877 if (SWIG_arg_fail(1)) SWIG_fail;
7878 {
7879 PyThreadState* __tstate = wxPyBeginAllowThreads();
7880 result = (long)(arg1)->TellI();
7881
7882 wxPyEndAllowThreads(__tstate);
7883 if (PyErr_Occurred()) SWIG_fail;
7884 }
7885 {
7886 resultobj = SWIG_From_long((long)(result));
7887 }
7888 return resultobj;
7889 fail:
7890 return NULL;
7891 }
7892
7893
7894 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7895 PyObject *obj;
7896 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7897 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7898 Py_INCREF(obj);
7899 return Py_BuildValue((char *)"");
7900 }
7901 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7902 PyObject *resultobj;
7903 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7904 PyObject *arg2 = (PyObject *) 0 ;
7905 PyObject * obj0 = 0 ;
7906 PyObject * obj1 = 0 ;
7907 char *kwnames[] = {
7908 (char *) "self",(char *) "obj", NULL
7909 };
7910
7911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7913 if (SWIG_arg_fail(1)) SWIG_fail;
7914 arg2 = obj1;
7915 {
7916 PyThreadState* __tstate = wxPyBeginAllowThreads();
7917 wxOutputStream_write(arg1,arg2);
7918
7919 wxPyEndAllowThreads(__tstate);
7920 if (PyErr_Occurred()) SWIG_fail;
7921 }
7922 Py_INCREF(Py_None); resultobj = Py_None;
7923 return resultobj;
7924 fail:
7925 return NULL;
7926 }
7927
7928
7929 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7930 PyObject *obj;
7931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7932 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7933 Py_INCREF(obj);
7934 return Py_BuildValue((char *)"");
7935 }
7936 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7937 PyObject *resultobj;
7938 wxInputStream *arg1 = (wxInputStream *) 0 ;
7939 wxString *arg2 = 0 ;
7940 wxString *arg3 = 0 ;
7941 wxString *arg4 = 0 ;
7942 wxDateTime arg5 ;
7943 wxFSFile *result;
7944 wxPyInputStream *temp1 ;
7945 bool temp2 = false ;
7946 bool temp3 = false ;
7947 bool temp4 = false ;
7948 PyObject * obj0 = 0 ;
7949 PyObject * obj1 = 0 ;
7950 PyObject * obj2 = 0 ;
7951 PyObject * obj3 = 0 ;
7952 PyObject * obj4 = 0 ;
7953 char *kwnames[] = {
7954 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7955 };
7956
7957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7958 {
7959 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7960 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7961 } else {
7962 PyErr_Clear(); // clear the failure of the wxPyConvert above
7963 arg1 = wxPyCBInputStream_create(obj0, true);
7964 if (arg1 == NULL) {
7965 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7966 SWIG_fail;
7967 }
7968 }
7969 }
7970 {
7971 arg2 = wxString_in_helper(obj1);
7972 if (arg2 == NULL) SWIG_fail;
7973 temp2 = true;
7974 }
7975 {
7976 arg3 = wxString_in_helper(obj2);
7977 if (arg3 == NULL) SWIG_fail;
7978 temp3 = true;
7979 }
7980 {
7981 arg4 = wxString_in_helper(obj3);
7982 if (arg4 == NULL) SWIG_fail;
7983 temp4 = true;
7984 }
7985 {
7986 wxDateTime * argp;
7987 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7988 if (SWIG_arg_fail(5)) SWIG_fail;
7989 if (argp == NULL) {
7990 SWIG_null_ref("wxDateTime");
7991 }
7992 if (SWIG_arg_fail(5)) SWIG_fail;
7993 arg5 = *argp;
7994 }
7995 {
7996 PyThreadState* __tstate = wxPyBeginAllowThreads();
7997 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7998
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 {
8003 resultobj = wxPyMake_wxObject(result, 1);
8004 }
8005 {
8006 if (temp2)
8007 delete arg2;
8008 }
8009 {
8010 if (temp3)
8011 delete arg3;
8012 }
8013 {
8014 if (temp4)
8015 delete arg4;
8016 }
8017 return resultobj;
8018 fail:
8019 {
8020 if (temp2)
8021 delete arg2;
8022 }
8023 {
8024 if (temp3)
8025 delete arg3;
8026 }
8027 {
8028 if (temp4)
8029 delete arg4;
8030 }
8031 return NULL;
8032 }
8033
8034
8035 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8036 PyObject *resultobj;
8037 wxFSFile *arg1 = (wxFSFile *) 0 ;
8038 PyObject * obj0 = 0 ;
8039 char *kwnames[] = {
8040 (char *) "self", NULL
8041 };
8042
8043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8045 if (SWIG_arg_fail(1)) SWIG_fail;
8046 {
8047 PyThreadState* __tstate = wxPyBeginAllowThreads();
8048 delete arg1;
8049
8050 wxPyEndAllowThreads(__tstate);
8051 if (PyErr_Occurred()) SWIG_fail;
8052 }
8053 Py_INCREF(Py_None); resultobj = Py_None;
8054 return resultobj;
8055 fail:
8056 return NULL;
8057 }
8058
8059
8060 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8061 PyObject *resultobj;
8062 wxFSFile *arg1 = (wxFSFile *) 0 ;
8063 wxInputStream *result;
8064 PyObject * obj0 = 0 ;
8065 char *kwnames[] = {
8066 (char *) "self", NULL
8067 };
8068
8069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8071 if (SWIG_arg_fail(1)) SWIG_fail;
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 result = (wxInputStream *)(arg1)->GetStream();
8075
8076 wxPyEndAllowThreads(__tstate);
8077 if (PyErr_Occurred()) SWIG_fail;
8078 }
8079 {
8080 wxPyInputStream * _ptr = NULL;
8081
8082 if (result) {
8083 _ptr = new wxPyInputStream(result);
8084 }
8085 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8086 }
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8094 PyObject *resultobj;
8095 wxFSFile *arg1 = (wxFSFile *) 0 ;
8096 wxString *result;
8097 PyObject * obj0 = 0 ;
8098 char *kwnames[] = {
8099 (char *) "self", NULL
8100 };
8101
8102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8104 if (SWIG_arg_fail(1)) SWIG_fail;
8105 {
8106 PyThreadState* __tstate = wxPyBeginAllowThreads();
8107 {
8108 wxString const &_result_ref = (arg1)->GetMimeType();
8109 result = (wxString *) &_result_ref;
8110 }
8111
8112 wxPyEndAllowThreads(__tstate);
8113 if (PyErr_Occurred()) SWIG_fail;
8114 }
8115 {
8116 #if wxUSE_UNICODE
8117 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8118 #else
8119 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8120 #endif
8121 }
8122 return resultobj;
8123 fail:
8124 return NULL;
8125 }
8126
8127
8128 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8129 PyObject *resultobj;
8130 wxFSFile *arg1 = (wxFSFile *) 0 ;
8131 wxString *result;
8132 PyObject * obj0 = 0 ;
8133 char *kwnames[] = {
8134 (char *) "self", NULL
8135 };
8136
8137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8139 if (SWIG_arg_fail(1)) SWIG_fail;
8140 {
8141 PyThreadState* __tstate = wxPyBeginAllowThreads();
8142 {
8143 wxString const &_result_ref = (arg1)->GetLocation();
8144 result = (wxString *) &_result_ref;
8145 }
8146
8147 wxPyEndAllowThreads(__tstate);
8148 if (PyErr_Occurred()) SWIG_fail;
8149 }
8150 {
8151 #if wxUSE_UNICODE
8152 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8153 #else
8154 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8155 #endif
8156 }
8157 return resultobj;
8158 fail:
8159 return NULL;
8160 }
8161
8162
8163 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8164 PyObject *resultobj;
8165 wxFSFile *arg1 = (wxFSFile *) 0 ;
8166 wxString *result;
8167 PyObject * obj0 = 0 ;
8168 char *kwnames[] = {
8169 (char *) "self", NULL
8170 };
8171
8172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8174 if (SWIG_arg_fail(1)) SWIG_fail;
8175 {
8176 PyThreadState* __tstate = wxPyBeginAllowThreads();
8177 {
8178 wxString const &_result_ref = (arg1)->GetAnchor();
8179 result = (wxString *) &_result_ref;
8180 }
8181
8182 wxPyEndAllowThreads(__tstate);
8183 if (PyErr_Occurred()) SWIG_fail;
8184 }
8185 {
8186 #if wxUSE_UNICODE
8187 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8188 #else
8189 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8190 #endif
8191 }
8192 return resultobj;
8193 fail:
8194 return NULL;
8195 }
8196
8197
8198 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8199 PyObject *resultobj;
8200 wxFSFile *arg1 = (wxFSFile *) 0 ;
8201 wxDateTime result;
8202 PyObject * obj0 = 0 ;
8203 char *kwnames[] = {
8204 (char *) "self", NULL
8205 };
8206
8207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8209 if (SWIG_arg_fail(1)) SWIG_fail;
8210 {
8211 PyThreadState* __tstate = wxPyBeginAllowThreads();
8212 result = (arg1)->GetModificationTime();
8213
8214 wxPyEndAllowThreads(__tstate);
8215 if (PyErr_Occurred()) SWIG_fail;
8216 }
8217 {
8218 wxDateTime * resultptr;
8219 resultptr = new wxDateTime((wxDateTime &)(result));
8220 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8221 }
8222 return resultobj;
8223 fail:
8224 return NULL;
8225 }
8226
8227
8228 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8229 PyObject *obj;
8230 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8231 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8232 Py_INCREF(obj);
8233 return Py_BuildValue((char *)"");
8234 }
8235 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8236 PyObject *obj;
8237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8238 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8239 Py_INCREF(obj);
8240 return Py_BuildValue((char *)"");
8241 }
8242 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8243 PyObject *resultobj;
8244 wxPyFileSystemHandler *result;
8245 char *kwnames[] = {
8246 NULL
8247 };
8248
8249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8250 {
8251 PyThreadState* __tstate = wxPyBeginAllowThreads();
8252 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8253
8254 wxPyEndAllowThreads(__tstate);
8255 if (PyErr_Occurred()) SWIG_fail;
8256 }
8257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj;
8266 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8267 PyObject *arg2 = (PyObject *) 0 ;
8268 PyObject *arg3 = (PyObject *) 0 ;
8269 PyObject * obj0 = 0 ;
8270 PyObject * obj1 = 0 ;
8271 PyObject * obj2 = 0 ;
8272 char *kwnames[] = {
8273 (char *) "self",(char *) "self",(char *) "_class", NULL
8274 };
8275
8276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8278 if (SWIG_arg_fail(1)) SWIG_fail;
8279 arg2 = obj1;
8280 arg3 = obj2;
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 (arg1)->_setCallbackInfo(arg2,arg3);
8284
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 Py_INCREF(Py_None); resultobj = Py_None;
8289 return resultobj;
8290 fail:
8291 return NULL;
8292 }
8293
8294
8295 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8296 PyObject *resultobj;
8297 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8298 wxString *arg2 = 0 ;
8299 bool result;
8300 bool temp2 = false ;
8301 PyObject * obj0 = 0 ;
8302 PyObject * obj1 = 0 ;
8303 char *kwnames[] = {
8304 (char *) "self",(char *) "location", NULL
8305 };
8306
8307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8309 if (SWIG_arg_fail(1)) SWIG_fail;
8310 {
8311 arg2 = wxString_in_helper(obj1);
8312 if (arg2 == NULL) SWIG_fail;
8313 temp2 = true;
8314 }
8315 {
8316 PyThreadState* __tstate = wxPyBeginAllowThreads();
8317 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8318
8319 wxPyEndAllowThreads(__tstate);
8320 if (PyErr_Occurred()) SWIG_fail;
8321 }
8322 {
8323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8324 }
8325 {
8326 if (temp2)
8327 delete arg2;
8328 }
8329 return resultobj;
8330 fail:
8331 {
8332 if (temp2)
8333 delete arg2;
8334 }
8335 return NULL;
8336 }
8337
8338
8339 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj;
8341 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8342 wxFileSystem *arg2 = 0 ;
8343 wxString *arg3 = 0 ;
8344 wxFSFile *result;
8345 bool temp3 = false ;
8346 PyObject * obj0 = 0 ;
8347 PyObject * obj1 = 0 ;
8348 PyObject * obj2 = 0 ;
8349 char *kwnames[] = {
8350 (char *) "self",(char *) "fs",(char *) "location", NULL
8351 };
8352
8353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8355 if (SWIG_arg_fail(1)) SWIG_fail;
8356 {
8357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8358 if (SWIG_arg_fail(2)) SWIG_fail;
8359 if (arg2 == NULL) {
8360 SWIG_null_ref("wxFileSystem");
8361 }
8362 if (SWIG_arg_fail(2)) SWIG_fail;
8363 }
8364 {
8365 arg3 = wxString_in_helper(obj2);
8366 if (arg3 == NULL) SWIG_fail;
8367 temp3 = true;
8368 }
8369 {
8370 PyThreadState* __tstate = wxPyBeginAllowThreads();
8371 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8372
8373 wxPyEndAllowThreads(__tstate);
8374 if (PyErr_Occurred()) SWIG_fail;
8375 }
8376 {
8377 resultobj = wxPyMake_wxObject(result, 1);
8378 }
8379 {
8380 if (temp3)
8381 delete arg3;
8382 }
8383 return resultobj;
8384 fail:
8385 {
8386 if (temp3)
8387 delete arg3;
8388 }
8389 return NULL;
8390 }
8391
8392
8393 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8394 PyObject *resultobj;
8395 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8396 wxString *arg2 = 0 ;
8397 int arg3 = (int) 0 ;
8398 wxString result;
8399 bool temp2 = false ;
8400 PyObject * obj0 = 0 ;
8401 PyObject * obj1 = 0 ;
8402 PyObject * obj2 = 0 ;
8403 char *kwnames[] = {
8404 (char *) "self",(char *) "spec",(char *) "flags", NULL
8405 };
8406
8407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8409 if (SWIG_arg_fail(1)) SWIG_fail;
8410 {
8411 arg2 = wxString_in_helper(obj1);
8412 if (arg2 == NULL) SWIG_fail;
8413 temp2 = true;
8414 }
8415 if (obj2) {
8416 {
8417 arg3 = (int)(SWIG_As_int(obj2));
8418 if (SWIG_arg_fail(3)) SWIG_fail;
8419 }
8420 }
8421 {
8422 PyThreadState* __tstate = wxPyBeginAllowThreads();
8423 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8424
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 {
8429 #if wxUSE_UNICODE
8430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8431 #else
8432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8433 #endif
8434 }
8435 {
8436 if (temp2)
8437 delete arg2;
8438 }
8439 return resultobj;
8440 fail:
8441 {
8442 if (temp2)
8443 delete arg2;
8444 }
8445 return NULL;
8446 }
8447
8448
8449 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8450 PyObject *resultobj;
8451 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8452 wxString result;
8453 PyObject * obj0 = 0 ;
8454 char *kwnames[] = {
8455 (char *) "self", NULL
8456 };
8457
8458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8460 if (SWIG_arg_fail(1)) SWIG_fail;
8461 {
8462 PyThreadState* __tstate = wxPyBeginAllowThreads();
8463 result = (arg1)->FindNext();
8464
8465 wxPyEndAllowThreads(__tstate);
8466 if (PyErr_Occurred()) SWIG_fail;
8467 }
8468 {
8469 #if wxUSE_UNICODE
8470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8471 #else
8472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8473 #endif
8474 }
8475 return resultobj;
8476 fail:
8477 return NULL;
8478 }
8479
8480
8481 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8482 PyObject *resultobj;
8483 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8484 wxString *arg2 = 0 ;
8485 wxString result;
8486 bool temp2 = false ;
8487 PyObject * obj0 = 0 ;
8488 PyObject * obj1 = 0 ;
8489 char *kwnames[] = {
8490 (char *) "self",(char *) "location", NULL
8491 };
8492
8493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8495 if (SWIG_arg_fail(1)) SWIG_fail;
8496 {
8497 arg2 = wxString_in_helper(obj1);
8498 if (arg2 == NULL) SWIG_fail;
8499 temp2 = true;
8500 }
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 result = (arg1)->GetProtocol((wxString const &)*arg2);
8504
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 {
8509 #if wxUSE_UNICODE
8510 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8511 #else
8512 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8513 #endif
8514 }
8515 {
8516 if (temp2)
8517 delete arg2;
8518 }
8519 return resultobj;
8520 fail:
8521 {
8522 if (temp2)
8523 delete arg2;
8524 }
8525 return NULL;
8526 }
8527
8528
8529 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8530 PyObject *resultobj;
8531 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8532 wxString *arg2 = 0 ;
8533 wxString result;
8534 bool temp2 = false ;
8535 PyObject * obj0 = 0 ;
8536 PyObject * obj1 = 0 ;
8537 char *kwnames[] = {
8538 (char *) "self",(char *) "location", NULL
8539 };
8540
8541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8543 if (SWIG_arg_fail(1)) SWIG_fail;
8544 {
8545 arg2 = wxString_in_helper(obj1);
8546 if (arg2 == NULL) SWIG_fail;
8547 temp2 = true;
8548 }
8549 {
8550 PyThreadState* __tstate = wxPyBeginAllowThreads();
8551 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8552
8553 wxPyEndAllowThreads(__tstate);
8554 if (PyErr_Occurred()) SWIG_fail;
8555 }
8556 {
8557 #if wxUSE_UNICODE
8558 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8559 #else
8560 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8561 #endif
8562 }
8563 {
8564 if (temp2)
8565 delete arg2;
8566 }
8567 return resultobj;
8568 fail:
8569 {
8570 if (temp2)
8571 delete arg2;
8572 }
8573 return NULL;
8574 }
8575
8576
8577 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8578 PyObject *resultobj;
8579 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8580 wxString *arg2 = 0 ;
8581 wxString result;
8582 bool temp2 = false ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char *kwnames[] = {
8586 (char *) "self",(char *) "location", NULL
8587 };
8588
8589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8591 if (SWIG_arg_fail(1)) SWIG_fail;
8592 {
8593 arg2 = wxString_in_helper(obj1);
8594 if (arg2 == NULL) SWIG_fail;
8595 temp2 = true;
8596 }
8597 {
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 result = (arg1)->GetAnchor((wxString const &)*arg2);
8600
8601 wxPyEndAllowThreads(__tstate);
8602 if (PyErr_Occurred()) SWIG_fail;
8603 }
8604 {
8605 #if wxUSE_UNICODE
8606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8607 #else
8608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8609 #endif
8610 }
8611 {
8612 if (temp2)
8613 delete arg2;
8614 }
8615 return resultobj;
8616 fail:
8617 {
8618 if (temp2)
8619 delete arg2;
8620 }
8621 return NULL;
8622 }
8623
8624
8625 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8626 PyObject *resultobj;
8627 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8628 wxString *arg2 = 0 ;
8629 wxString result;
8630 bool temp2 = false ;
8631 PyObject * obj0 = 0 ;
8632 PyObject * obj1 = 0 ;
8633 char *kwnames[] = {
8634 (char *) "self",(char *) "location", NULL
8635 };
8636
8637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8639 if (SWIG_arg_fail(1)) SWIG_fail;
8640 {
8641 arg2 = wxString_in_helper(obj1);
8642 if (arg2 == NULL) SWIG_fail;
8643 temp2 = true;
8644 }
8645 {
8646 PyThreadState* __tstate = wxPyBeginAllowThreads();
8647 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8648
8649 wxPyEndAllowThreads(__tstate);
8650 if (PyErr_Occurred()) SWIG_fail;
8651 }
8652 {
8653 #if wxUSE_UNICODE
8654 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8655 #else
8656 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8657 #endif
8658 }
8659 {
8660 if (temp2)
8661 delete arg2;
8662 }
8663 return resultobj;
8664 fail:
8665 {
8666 if (temp2)
8667 delete arg2;
8668 }
8669 return NULL;
8670 }
8671
8672
8673 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8674 PyObject *resultobj;
8675 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8676 wxString *arg2 = 0 ;
8677 wxString result;
8678 bool temp2 = false ;
8679 PyObject * obj0 = 0 ;
8680 PyObject * obj1 = 0 ;
8681 char *kwnames[] = {
8682 (char *) "self",(char *) "location", NULL
8683 };
8684
8685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8687 if (SWIG_arg_fail(1)) SWIG_fail;
8688 {
8689 arg2 = wxString_in_helper(obj1);
8690 if (arg2 == NULL) SWIG_fail;
8691 temp2 = true;
8692 }
8693 {
8694 PyThreadState* __tstate = wxPyBeginAllowThreads();
8695 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8696
8697 wxPyEndAllowThreads(__tstate);
8698 if (PyErr_Occurred()) SWIG_fail;
8699 }
8700 {
8701 #if wxUSE_UNICODE
8702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8703 #else
8704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8705 #endif
8706 }
8707 {
8708 if (temp2)
8709 delete arg2;
8710 }
8711 return resultobj;
8712 fail:
8713 {
8714 if (temp2)
8715 delete arg2;
8716 }
8717 return NULL;
8718 }
8719
8720
8721 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8722 PyObject *obj;
8723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8724 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8725 Py_INCREF(obj);
8726 return Py_BuildValue((char *)"");
8727 }
8728 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8729 PyObject *resultobj;
8730 wxFileSystem *result;
8731 char *kwnames[] = {
8732 NULL
8733 };
8734
8735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8736 {
8737 PyThreadState* __tstate = wxPyBeginAllowThreads();
8738 result = (wxFileSystem *)new wxFileSystem();
8739
8740 wxPyEndAllowThreads(__tstate);
8741 if (PyErr_Occurred()) SWIG_fail;
8742 }
8743 {
8744 resultobj = wxPyMake_wxObject(result, 1);
8745 }
8746 return resultobj;
8747 fail:
8748 return NULL;
8749 }
8750
8751
8752 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8753 PyObject *resultobj;
8754 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8755 PyObject * obj0 = 0 ;
8756 char *kwnames[] = {
8757 (char *) "self", NULL
8758 };
8759
8760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8762 if (SWIG_arg_fail(1)) SWIG_fail;
8763 {
8764 PyThreadState* __tstate = wxPyBeginAllowThreads();
8765 delete arg1;
8766
8767 wxPyEndAllowThreads(__tstate);
8768 if (PyErr_Occurred()) SWIG_fail;
8769 }
8770 Py_INCREF(Py_None); resultobj = Py_None;
8771 return resultobj;
8772 fail:
8773 return NULL;
8774 }
8775
8776
8777 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8778 PyObject *resultobj;
8779 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8780 wxString *arg2 = 0 ;
8781 bool arg3 = (bool) false ;
8782 bool temp2 = false ;
8783 PyObject * obj0 = 0 ;
8784 PyObject * obj1 = 0 ;
8785 PyObject * obj2 = 0 ;
8786 char *kwnames[] = {
8787 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8788 };
8789
8790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8792 if (SWIG_arg_fail(1)) SWIG_fail;
8793 {
8794 arg2 = wxString_in_helper(obj1);
8795 if (arg2 == NULL) SWIG_fail;
8796 temp2 = true;
8797 }
8798 if (obj2) {
8799 {
8800 arg3 = (bool)(SWIG_As_bool(obj2));
8801 if (SWIG_arg_fail(3)) SWIG_fail;
8802 }
8803 }
8804 {
8805 PyThreadState* __tstate = wxPyBeginAllowThreads();
8806 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8807
8808 wxPyEndAllowThreads(__tstate);
8809 if (PyErr_Occurred()) SWIG_fail;
8810 }
8811 Py_INCREF(Py_None); resultobj = Py_None;
8812 {
8813 if (temp2)
8814 delete arg2;
8815 }
8816 return resultobj;
8817 fail:
8818 {
8819 if (temp2)
8820 delete arg2;
8821 }
8822 return NULL;
8823 }
8824
8825
8826 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8827 PyObject *resultobj;
8828 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8829 wxString result;
8830 PyObject * obj0 = 0 ;
8831 char *kwnames[] = {
8832 (char *) "self", NULL
8833 };
8834
8835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8837 if (SWIG_arg_fail(1)) SWIG_fail;
8838 {
8839 PyThreadState* __tstate = wxPyBeginAllowThreads();
8840 result = (arg1)->GetPath();
8841
8842 wxPyEndAllowThreads(__tstate);
8843 if (PyErr_Occurred()) SWIG_fail;
8844 }
8845 {
8846 #if wxUSE_UNICODE
8847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8848 #else
8849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8850 #endif
8851 }
8852 return resultobj;
8853 fail:
8854 return NULL;
8855 }
8856
8857
8858 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8859 PyObject *resultobj;
8860 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8861 wxString *arg2 = 0 ;
8862 wxFSFile *result;
8863 bool temp2 = false ;
8864 PyObject * obj0 = 0 ;
8865 PyObject * obj1 = 0 ;
8866 char *kwnames[] = {
8867 (char *) "self",(char *) "location", NULL
8868 };
8869
8870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8872 if (SWIG_arg_fail(1)) SWIG_fail;
8873 {
8874 arg2 = wxString_in_helper(obj1);
8875 if (arg2 == NULL) SWIG_fail;
8876 temp2 = true;
8877 }
8878 {
8879 PyThreadState* __tstate = wxPyBeginAllowThreads();
8880 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8881
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 {
8886 resultobj = wxPyMake_wxObject(result, 1);
8887 }
8888 {
8889 if (temp2)
8890 delete arg2;
8891 }
8892 return resultobj;
8893 fail:
8894 {
8895 if (temp2)
8896 delete arg2;
8897 }
8898 return NULL;
8899 }
8900
8901
8902 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8903 PyObject *resultobj;
8904 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8905 wxString *arg2 = 0 ;
8906 int arg3 = (int) 0 ;
8907 wxString result;
8908 bool temp2 = false ;
8909 PyObject * obj0 = 0 ;
8910 PyObject * obj1 = 0 ;
8911 PyObject * obj2 = 0 ;
8912 char *kwnames[] = {
8913 (char *) "self",(char *) "spec",(char *) "flags", NULL
8914 };
8915
8916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8918 if (SWIG_arg_fail(1)) SWIG_fail;
8919 {
8920 arg2 = wxString_in_helper(obj1);
8921 if (arg2 == NULL) SWIG_fail;
8922 temp2 = true;
8923 }
8924 if (obj2) {
8925 {
8926 arg3 = (int)(SWIG_As_int(obj2));
8927 if (SWIG_arg_fail(3)) SWIG_fail;
8928 }
8929 }
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8933
8934 wxPyEndAllowThreads(__tstate);
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 {
8938 #if wxUSE_UNICODE
8939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8940 #else
8941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8942 #endif
8943 }
8944 {
8945 if (temp2)
8946 delete arg2;
8947 }
8948 return resultobj;
8949 fail:
8950 {
8951 if (temp2)
8952 delete arg2;
8953 }
8954 return NULL;
8955 }
8956
8957
8958 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8959 PyObject *resultobj;
8960 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8961 wxString result;
8962 PyObject * obj0 = 0 ;
8963 char *kwnames[] = {
8964 (char *) "self", NULL
8965 };
8966
8967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8969 if (SWIG_arg_fail(1)) SWIG_fail;
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 result = (arg1)->FindNext();
8973
8974 wxPyEndAllowThreads(__tstate);
8975 if (PyErr_Occurred()) SWIG_fail;
8976 }
8977 {
8978 #if wxUSE_UNICODE
8979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8980 #else
8981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8982 #endif
8983 }
8984 return resultobj;
8985 fail:
8986 return NULL;
8987 }
8988
8989
8990 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8991 PyObject *resultobj;
8992 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8993 PyObject * obj0 = 0 ;
8994 char *kwnames[] = {
8995 (char *) "handler", NULL
8996 };
8997
8998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9000 if (SWIG_arg_fail(1)) SWIG_fail;
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 wxFileSystem::AddHandler(arg1);
9004
9005 wxPyEndAllowThreads(__tstate);
9006 if (PyErr_Occurred()) SWIG_fail;
9007 }
9008 Py_INCREF(Py_None); resultobj = Py_None;
9009 return resultobj;
9010 fail:
9011 return NULL;
9012 }
9013
9014
9015 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9016 PyObject *resultobj;
9017 char *kwnames[] = {
9018 NULL
9019 };
9020
9021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9022 {
9023 PyThreadState* __tstate = wxPyBeginAllowThreads();
9024 wxFileSystem::CleanUpHandlers();
9025
9026 wxPyEndAllowThreads(__tstate);
9027 if (PyErr_Occurred()) SWIG_fail;
9028 }
9029 Py_INCREF(Py_None); resultobj = Py_None;
9030 return resultobj;
9031 fail:
9032 return NULL;
9033 }
9034
9035
9036 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9037 PyObject *resultobj;
9038 wxString *arg1 = 0 ;
9039 wxString result;
9040 bool temp1 = false ;
9041 PyObject * obj0 = 0 ;
9042 char *kwnames[] = {
9043 (char *) "filename", NULL
9044 };
9045
9046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9047 {
9048 arg1 = wxString_in_helper(obj0);
9049 if (arg1 == NULL) SWIG_fail;
9050 temp1 = true;
9051 }
9052 {
9053 PyThreadState* __tstate = wxPyBeginAllowThreads();
9054 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9055
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 {
9060 #if wxUSE_UNICODE
9061 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9062 #else
9063 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9064 #endif
9065 }
9066 {
9067 if (temp1)
9068 delete arg1;
9069 }
9070 return resultobj;
9071 fail:
9072 {
9073 if (temp1)
9074 delete arg1;
9075 }
9076 return NULL;
9077 }
9078
9079
9080 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9081 PyObject *resultobj;
9082 wxString *arg1 = 0 ;
9083 wxString result;
9084 bool temp1 = false ;
9085 PyObject * obj0 = 0 ;
9086 char *kwnames[] = {
9087 (char *) "url", NULL
9088 };
9089
9090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9091 {
9092 arg1 = wxString_in_helper(obj0);
9093 if (arg1 == NULL) SWIG_fail;
9094 temp1 = true;
9095 }
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 result = FileSystem_URLToFileName((wxString const &)*arg1);
9099
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 {
9104 #if wxUSE_UNICODE
9105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9106 #else
9107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9108 #endif
9109 }
9110 {
9111 if (temp1)
9112 delete arg1;
9113 }
9114 return resultobj;
9115 fail:
9116 {
9117 if (temp1)
9118 delete arg1;
9119 }
9120 return NULL;
9121 }
9122
9123
9124 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9125 PyObject *obj;
9126 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9127 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9128 Py_INCREF(obj);
9129 return Py_BuildValue((char *)"");
9130 }
9131 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9132 PyObject *resultobj;
9133 wxInternetFSHandler *result;
9134 char *kwnames[] = {
9135 NULL
9136 };
9137
9138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9139 {
9140 PyThreadState* __tstate = wxPyBeginAllowThreads();
9141 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9142
9143 wxPyEndAllowThreads(__tstate);
9144 if (PyErr_Occurred()) SWIG_fail;
9145 }
9146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9147 return resultobj;
9148 fail:
9149 return NULL;
9150 }
9151
9152
9153 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9154 PyObject *resultobj;
9155 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9156 wxString *arg2 = 0 ;
9157 bool result;
9158 bool temp2 = false ;
9159 PyObject * obj0 = 0 ;
9160 PyObject * obj1 = 0 ;
9161 char *kwnames[] = {
9162 (char *) "self",(char *) "location", NULL
9163 };
9164
9165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9167 if (SWIG_arg_fail(1)) SWIG_fail;
9168 {
9169 arg2 = wxString_in_helper(obj1);
9170 if (arg2 == NULL) SWIG_fail;
9171 temp2 = true;
9172 }
9173 {
9174 PyThreadState* __tstate = wxPyBeginAllowThreads();
9175 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9176
9177 wxPyEndAllowThreads(__tstate);
9178 if (PyErr_Occurred()) SWIG_fail;
9179 }
9180 {
9181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9182 }
9183 {
9184 if (temp2)
9185 delete arg2;
9186 }
9187 return resultobj;
9188 fail:
9189 {
9190 if (temp2)
9191 delete arg2;
9192 }
9193 return NULL;
9194 }
9195
9196
9197 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9198 PyObject *resultobj;
9199 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9200 wxFileSystem *arg2 = 0 ;
9201 wxString *arg3 = 0 ;
9202 wxFSFile *result;
9203 bool temp3 = false ;
9204 PyObject * obj0 = 0 ;
9205 PyObject * obj1 = 0 ;
9206 PyObject * obj2 = 0 ;
9207 char *kwnames[] = {
9208 (char *) "self",(char *) "fs",(char *) "location", NULL
9209 };
9210
9211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9213 if (SWIG_arg_fail(1)) SWIG_fail;
9214 {
9215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9216 if (SWIG_arg_fail(2)) SWIG_fail;
9217 if (arg2 == NULL) {
9218 SWIG_null_ref("wxFileSystem");
9219 }
9220 if (SWIG_arg_fail(2)) SWIG_fail;
9221 }
9222 {
9223 arg3 = wxString_in_helper(obj2);
9224 if (arg3 == NULL) SWIG_fail;
9225 temp3 = true;
9226 }
9227 {
9228 PyThreadState* __tstate = wxPyBeginAllowThreads();
9229 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9230
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 {
9235 resultobj = wxPyMake_wxObject(result, 1);
9236 }
9237 {
9238 if (temp3)
9239 delete arg3;
9240 }
9241 return resultobj;
9242 fail:
9243 {
9244 if (temp3)
9245 delete arg3;
9246 }
9247 return NULL;
9248 }
9249
9250
9251 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9252 PyObject *obj;
9253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9254 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9255 Py_INCREF(obj);
9256 return Py_BuildValue((char *)"");
9257 }
9258 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9259 PyObject *resultobj;
9260 wxZipFSHandler *result;
9261 char *kwnames[] = {
9262 NULL
9263 };
9264
9265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9266 {
9267 PyThreadState* __tstate = wxPyBeginAllowThreads();
9268 result = (wxZipFSHandler *)new wxZipFSHandler();
9269
9270 wxPyEndAllowThreads(__tstate);
9271 if (PyErr_Occurred()) SWIG_fail;
9272 }
9273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9274 return resultobj;
9275 fail:
9276 return NULL;
9277 }
9278
9279
9280 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9281 PyObject *resultobj;
9282 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9283 wxString *arg2 = 0 ;
9284 bool result;
9285 bool temp2 = false ;
9286 PyObject * obj0 = 0 ;
9287 PyObject * obj1 = 0 ;
9288 char *kwnames[] = {
9289 (char *) "self",(char *) "location", NULL
9290 };
9291
9292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9294 if (SWIG_arg_fail(1)) SWIG_fail;
9295 {
9296 arg2 = wxString_in_helper(obj1);
9297 if (arg2 == NULL) SWIG_fail;
9298 temp2 = true;
9299 }
9300 {
9301 PyThreadState* __tstate = wxPyBeginAllowThreads();
9302 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9303
9304 wxPyEndAllowThreads(__tstate);
9305 if (PyErr_Occurred()) SWIG_fail;
9306 }
9307 {
9308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9309 }
9310 {
9311 if (temp2)
9312 delete arg2;
9313 }
9314 return resultobj;
9315 fail:
9316 {
9317 if (temp2)
9318 delete arg2;
9319 }
9320 return NULL;
9321 }
9322
9323
9324 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9325 PyObject *resultobj;
9326 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9327 wxFileSystem *arg2 = 0 ;
9328 wxString *arg3 = 0 ;
9329 wxFSFile *result;
9330 bool temp3 = false ;
9331 PyObject * obj0 = 0 ;
9332 PyObject * obj1 = 0 ;
9333 PyObject * obj2 = 0 ;
9334 char *kwnames[] = {
9335 (char *) "self",(char *) "fs",(char *) "location", NULL
9336 };
9337
9338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9340 if (SWIG_arg_fail(1)) SWIG_fail;
9341 {
9342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9343 if (SWIG_arg_fail(2)) SWIG_fail;
9344 if (arg2 == NULL) {
9345 SWIG_null_ref("wxFileSystem");
9346 }
9347 if (SWIG_arg_fail(2)) SWIG_fail;
9348 }
9349 {
9350 arg3 = wxString_in_helper(obj2);
9351 if (arg3 == NULL) SWIG_fail;
9352 temp3 = true;
9353 }
9354 {
9355 PyThreadState* __tstate = wxPyBeginAllowThreads();
9356 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9357
9358 wxPyEndAllowThreads(__tstate);
9359 if (PyErr_Occurred()) SWIG_fail;
9360 }
9361 {
9362 resultobj = wxPyMake_wxObject(result, 1);
9363 }
9364 {
9365 if (temp3)
9366 delete arg3;
9367 }
9368 return resultobj;
9369 fail:
9370 {
9371 if (temp3)
9372 delete arg3;
9373 }
9374 return NULL;
9375 }
9376
9377
9378 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9379 PyObject *resultobj;
9380 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9381 wxString *arg2 = 0 ;
9382 int arg3 = (int) 0 ;
9383 wxString result;
9384 bool temp2 = false ;
9385 PyObject * obj0 = 0 ;
9386 PyObject * obj1 = 0 ;
9387 PyObject * obj2 = 0 ;
9388 char *kwnames[] = {
9389 (char *) "self",(char *) "spec",(char *) "flags", NULL
9390 };
9391
9392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9394 if (SWIG_arg_fail(1)) SWIG_fail;
9395 {
9396 arg2 = wxString_in_helper(obj1);
9397 if (arg2 == NULL) SWIG_fail;
9398 temp2 = true;
9399 }
9400 if (obj2) {
9401 {
9402 arg3 = (int)(SWIG_As_int(obj2));
9403 if (SWIG_arg_fail(3)) SWIG_fail;
9404 }
9405 }
9406 {
9407 PyThreadState* __tstate = wxPyBeginAllowThreads();
9408 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9409
9410 wxPyEndAllowThreads(__tstate);
9411 if (PyErr_Occurred()) SWIG_fail;
9412 }
9413 {
9414 #if wxUSE_UNICODE
9415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9416 #else
9417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9418 #endif
9419 }
9420 {
9421 if (temp2)
9422 delete arg2;
9423 }
9424 return resultobj;
9425 fail:
9426 {
9427 if (temp2)
9428 delete arg2;
9429 }
9430 return NULL;
9431 }
9432
9433
9434 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj;
9436 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9437 wxString result;
9438 PyObject * obj0 = 0 ;
9439 char *kwnames[] = {
9440 (char *) "self", NULL
9441 };
9442
9443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9445 if (SWIG_arg_fail(1)) SWIG_fail;
9446 {
9447 PyThreadState* __tstate = wxPyBeginAllowThreads();
9448 result = (arg1)->FindNext();
9449
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 {
9454 #if wxUSE_UNICODE
9455 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9456 #else
9457 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9458 #endif
9459 }
9460 return resultobj;
9461 fail:
9462 return NULL;
9463 }
9464
9465
9466 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9467 PyObject *obj;
9468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9469 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9470 Py_INCREF(obj);
9471 return Py_BuildValue((char *)"");
9472 }
9473 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9474 PyObject *resultobj;
9475 wxString *arg1 = 0 ;
9476 wxImage *arg2 = 0 ;
9477 long arg3 ;
9478 bool temp1 = false ;
9479 PyObject * obj0 = 0 ;
9480 PyObject * obj1 = 0 ;
9481 PyObject * obj2 = 0 ;
9482 char *kwnames[] = {
9483 (char *) "filename",(char *) "image",(char *) "type", NULL
9484 };
9485
9486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9487 {
9488 arg1 = wxString_in_helper(obj0);
9489 if (arg1 == NULL) SWIG_fail;
9490 temp1 = true;
9491 }
9492 {
9493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9494 if (SWIG_arg_fail(2)) SWIG_fail;
9495 if (arg2 == NULL) {
9496 SWIG_null_ref("wxImage");
9497 }
9498 if (SWIG_arg_fail(2)) SWIG_fail;
9499 }
9500 {
9501 arg3 = (long)(SWIG_As_long(obj2));
9502 if (SWIG_arg_fail(3)) SWIG_fail;
9503 }
9504 {
9505 PyThreadState* __tstate = wxPyBeginAllowThreads();
9506 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9507
9508 wxPyEndAllowThreads(__tstate);
9509 if (PyErr_Occurred()) SWIG_fail;
9510 }
9511 Py_INCREF(Py_None); resultobj = Py_None;
9512 {
9513 if (temp1)
9514 delete arg1;
9515 }
9516 return resultobj;
9517 fail:
9518 {
9519 if (temp1)
9520 delete arg1;
9521 }
9522 return NULL;
9523 }
9524
9525
9526 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9527 PyObject *resultobj;
9528 wxString *arg1 = 0 ;
9529 wxBitmap *arg2 = 0 ;
9530 long arg3 ;
9531 bool temp1 = false ;
9532 PyObject * obj0 = 0 ;
9533 PyObject * obj1 = 0 ;
9534 PyObject * obj2 = 0 ;
9535 char *kwnames[] = {
9536 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9537 };
9538
9539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9540 {
9541 arg1 = wxString_in_helper(obj0);
9542 if (arg1 == NULL) SWIG_fail;
9543 temp1 = true;
9544 }
9545 {
9546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9547 if (SWIG_arg_fail(2)) SWIG_fail;
9548 if (arg2 == NULL) {
9549 SWIG_null_ref("wxBitmap");
9550 }
9551 if (SWIG_arg_fail(2)) SWIG_fail;
9552 }
9553 {
9554 arg3 = (long)(SWIG_As_long(obj2));
9555 if (SWIG_arg_fail(3)) SWIG_fail;
9556 }
9557 {
9558 PyThreadState* __tstate = wxPyBeginAllowThreads();
9559 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9560
9561 wxPyEndAllowThreads(__tstate);
9562 if (PyErr_Occurred()) SWIG_fail;
9563 }
9564 Py_INCREF(Py_None); resultobj = Py_None;
9565 {
9566 if (temp1)
9567 delete arg1;
9568 }
9569 return resultobj;
9570 fail:
9571 {
9572 if (temp1)
9573 delete arg1;
9574 }
9575 return NULL;
9576 }
9577
9578
9579 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9580 PyObject *resultobj;
9581 wxString *arg1 = 0 ;
9582 PyObject *arg2 = (PyObject *) 0 ;
9583 bool temp1 = false ;
9584 PyObject * obj0 = 0 ;
9585 PyObject * obj1 = 0 ;
9586 char *kwnames[] = {
9587 (char *) "filename",(char *) "data", NULL
9588 };
9589
9590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9591 {
9592 arg1 = wxString_in_helper(obj0);
9593 if (arg1 == NULL) SWIG_fail;
9594 temp1 = true;
9595 }
9596 arg2 = obj1;
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9600
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 Py_INCREF(Py_None); resultobj = Py_None;
9605 {
9606 if (temp1)
9607 delete arg1;
9608 }
9609 return resultobj;
9610 fail:
9611 {
9612 if (temp1)
9613 delete arg1;
9614 }
9615 return NULL;
9616 }
9617
9618
9619 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9620 PyObject *resultobj;
9621 wxMemoryFSHandler *result;
9622 char *kwnames[] = {
9623 NULL
9624 };
9625
9626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9627 {
9628 PyThreadState* __tstate = wxPyBeginAllowThreads();
9629 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9630
9631 wxPyEndAllowThreads(__tstate);
9632 if (PyErr_Occurred()) SWIG_fail;
9633 }
9634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9635 return resultobj;
9636 fail:
9637 return NULL;
9638 }
9639
9640
9641 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9642 PyObject *resultobj;
9643 wxString *arg1 = 0 ;
9644 bool temp1 = false ;
9645 PyObject * obj0 = 0 ;
9646 char *kwnames[] = {
9647 (char *) "filename", NULL
9648 };
9649
9650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9651 {
9652 arg1 = wxString_in_helper(obj0);
9653 if (arg1 == NULL) SWIG_fail;
9654 temp1 = true;
9655 }
9656 {
9657 PyThreadState* __tstate = wxPyBeginAllowThreads();
9658 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9659
9660 wxPyEndAllowThreads(__tstate);
9661 if (PyErr_Occurred()) SWIG_fail;
9662 }
9663 Py_INCREF(Py_None); resultobj = Py_None;
9664 {
9665 if (temp1)
9666 delete arg1;
9667 }
9668 return resultobj;
9669 fail:
9670 {
9671 if (temp1)
9672 delete arg1;
9673 }
9674 return NULL;
9675 }
9676
9677
9678 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9679 PyObject *resultobj;
9680 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9681 wxString *arg2 = 0 ;
9682 bool result;
9683 bool temp2 = false ;
9684 PyObject * obj0 = 0 ;
9685 PyObject * obj1 = 0 ;
9686 char *kwnames[] = {
9687 (char *) "self",(char *) "location", NULL
9688 };
9689
9690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9692 if (SWIG_arg_fail(1)) SWIG_fail;
9693 {
9694 arg2 = wxString_in_helper(obj1);
9695 if (arg2 == NULL) SWIG_fail;
9696 temp2 = true;
9697 }
9698 {
9699 PyThreadState* __tstate = wxPyBeginAllowThreads();
9700 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9701
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 {
9706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9707 }
9708 {
9709 if (temp2)
9710 delete arg2;
9711 }
9712 return resultobj;
9713 fail:
9714 {
9715 if (temp2)
9716 delete arg2;
9717 }
9718 return NULL;
9719 }
9720
9721
9722 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9723 PyObject *resultobj;
9724 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9725 wxFileSystem *arg2 = 0 ;
9726 wxString *arg3 = 0 ;
9727 wxFSFile *result;
9728 bool temp3 = false ;
9729 PyObject * obj0 = 0 ;
9730 PyObject * obj1 = 0 ;
9731 PyObject * obj2 = 0 ;
9732 char *kwnames[] = {
9733 (char *) "self",(char *) "fs",(char *) "location", NULL
9734 };
9735
9736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9738 if (SWIG_arg_fail(1)) SWIG_fail;
9739 {
9740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9741 if (SWIG_arg_fail(2)) SWIG_fail;
9742 if (arg2 == NULL) {
9743 SWIG_null_ref("wxFileSystem");
9744 }
9745 if (SWIG_arg_fail(2)) SWIG_fail;
9746 }
9747 {
9748 arg3 = wxString_in_helper(obj2);
9749 if (arg3 == NULL) SWIG_fail;
9750 temp3 = true;
9751 }
9752 {
9753 PyThreadState* __tstate = wxPyBeginAllowThreads();
9754 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9755
9756 wxPyEndAllowThreads(__tstate);
9757 if (PyErr_Occurred()) SWIG_fail;
9758 }
9759 {
9760 resultobj = wxPyMake_wxObject(result, 1);
9761 }
9762 {
9763 if (temp3)
9764 delete arg3;
9765 }
9766 return resultobj;
9767 fail:
9768 {
9769 if (temp3)
9770 delete arg3;
9771 }
9772 return NULL;
9773 }
9774
9775
9776 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9777 PyObject *resultobj;
9778 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9779 wxString *arg2 = 0 ;
9780 int arg3 = (int) 0 ;
9781 wxString result;
9782 bool temp2 = false ;
9783 PyObject * obj0 = 0 ;
9784 PyObject * obj1 = 0 ;
9785 PyObject * obj2 = 0 ;
9786 char *kwnames[] = {
9787 (char *) "self",(char *) "spec",(char *) "flags", NULL
9788 };
9789
9790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9792 if (SWIG_arg_fail(1)) SWIG_fail;
9793 {
9794 arg2 = wxString_in_helper(obj1);
9795 if (arg2 == NULL) SWIG_fail;
9796 temp2 = true;
9797 }
9798 if (obj2) {
9799 {
9800 arg3 = (int)(SWIG_As_int(obj2));
9801 if (SWIG_arg_fail(3)) SWIG_fail;
9802 }
9803 }
9804 {
9805 PyThreadState* __tstate = wxPyBeginAllowThreads();
9806 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9807
9808 wxPyEndAllowThreads(__tstate);
9809 if (PyErr_Occurred()) SWIG_fail;
9810 }
9811 {
9812 #if wxUSE_UNICODE
9813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9814 #else
9815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9816 #endif
9817 }
9818 {
9819 if (temp2)
9820 delete arg2;
9821 }
9822 return resultobj;
9823 fail:
9824 {
9825 if (temp2)
9826 delete arg2;
9827 }
9828 return NULL;
9829 }
9830
9831
9832 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9833 PyObject *resultobj;
9834 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9835 wxString result;
9836 PyObject * obj0 = 0 ;
9837 char *kwnames[] = {
9838 (char *) "self", NULL
9839 };
9840
9841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9843 if (SWIG_arg_fail(1)) SWIG_fail;
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 result = (arg1)->FindNext();
9847
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 {
9852 #if wxUSE_UNICODE
9853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9854 #else
9855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9856 #endif
9857 }
9858 return resultobj;
9859 fail:
9860 return NULL;
9861 }
9862
9863
9864 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9865 PyObject *obj;
9866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9867 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9868 Py_INCREF(obj);
9869 return Py_BuildValue((char *)"");
9870 }
9871 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9872 PyObject *resultobj;
9873 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9874 wxString result;
9875 PyObject * obj0 = 0 ;
9876 char *kwnames[] = {
9877 (char *) "self", NULL
9878 };
9879
9880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9882 if (SWIG_arg_fail(1)) SWIG_fail;
9883 {
9884 PyThreadState* __tstate = wxPyBeginAllowThreads();
9885 result = (arg1)->GetName();
9886
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 {
9891 #if wxUSE_UNICODE
9892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9893 #else
9894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9895 #endif
9896 }
9897 return resultobj;
9898 fail:
9899 return NULL;
9900 }
9901
9902
9903 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9904 PyObject *resultobj;
9905 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9906 wxString result;
9907 PyObject * obj0 = 0 ;
9908 char *kwnames[] = {
9909 (char *) "self", NULL
9910 };
9911
9912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9914 if (SWIG_arg_fail(1)) SWIG_fail;
9915 {
9916 PyThreadState* __tstate = wxPyBeginAllowThreads();
9917 result = (arg1)->GetExtension();
9918
9919 wxPyEndAllowThreads(__tstate);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 {
9923 #if wxUSE_UNICODE
9924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9925 #else
9926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9927 #endif
9928 }
9929 return resultobj;
9930 fail:
9931 return NULL;
9932 }
9933
9934
9935 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9936 PyObject *resultobj;
9937 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9938 long result;
9939 PyObject * obj0 = 0 ;
9940 char *kwnames[] = {
9941 (char *) "self", NULL
9942 };
9943
9944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9946 if (SWIG_arg_fail(1)) SWIG_fail;
9947 {
9948 PyThreadState* __tstate = wxPyBeginAllowThreads();
9949 result = (long)(arg1)->GetType();
9950
9951 wxPyEndAllowThreads(__tstate);
9952 if (PyErr_Occurred()) SWIG_fail;
9953 }
9954 {
9955 resultobj = SWIG_From_long((long)(result));
9956 }
9957 return resultobj;
9958 fail:
9959 return NULL;
9960 }
9961
9962
9963 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9964 PyObject *resultobj;
9965 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9966 wxString result;
9967 PyObject * obj0 = 0 ;
9968 char *kwnames[] = {
9969 (char *) "self", NULL
9970 };
9971
9972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9974 if (SWIG_arg_fail(1)) SWIG_fail;
9975 {
9976 PyThreadState* __tstate = wxPyBeginAllowThreads();
9977 result = (arg1)->GetMimeType();
9978
9979 wxPyEndAllowThreads(__tstate);
9980 if (PyErr_Occurred()) SWIG_fail;
9981 }
9982 {
9983 #if wxUSE_UNICODE
9984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9985 #else
9986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9987 #endif
9988 }
9989 return resultobj;
9990 fail:
9991 return NULL;
9992 }
9993
9994
9995 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9996 PyObject *resultobj;
9997 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9998 wxString *arg2 = 0 ;
9999 bool result;
10000 bool temp2 = false ;
10001 PyObject * obj0 = 0 ;
10002 PyObject * obj1 = 0 ;
10003 char *kwnames[] = {
10004 (char *) "self",(char *) "name", NULL
10005 };
10006
10007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10009 if (SWIG_arg_fail(1)) SWIG_fail;
10010 {
10011 arg2 = wxString_in_helper(obj1);
10012 if (arg2 == NULL) SWIG_fail;
10013 temp2 = true;
10014 }
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10018
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 {
10023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10024 }
10025 {
10026 if (temp2)
10027 delete arg2;
10028 }
10029 return resultobj;
10030 fail:
10031 {
10032 if (temp2)
10033 delete arg2;
10034 }
10035 return NULL;
10036 }
10037
10038
10039 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10040 PyObject *resultobj;
10041 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10042 wxString *arg2 = 0 ;
10043 bool temp2 = false ;
10044 PyObject * obj0 = 0 ;
10045 PyObject * obj1 = 0 ;
10046 char *kwnames[] = {
10047 (char *) "self",(char *) "name", NULL
10048 };
10049
10050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10052 if (SWIG_arg_fail(1)) SWIG_fail;
10053 {
10054 arg2 = wxString_in_helper(obj1);
10055 if (arg2 == NULL) SWIG_fail;
10056 temp2 = true;
10057 }
10058 {
10059 PyThreadState* __tstate = wxPyBeginAllowThreads();
10060 (arg1)->SetName((wxString const &)*arg2);
10061
10062 wxPyEndAllowThreads(__tstate);
10063 if (PyErr_Occurred()) SWIG_fail;
10064 }
10065 Py_INCREF(Py_None); resultobj = Py_None;
10066 {
10067 if (temp2)
10068 delete arg2;
10069 }
10070 return resultobj;
10071 fail:
10072 {
10073 if (temp2)
10074 delete arg2;
10075 }
10076 return NULL;
10077 }
10078
10079
10080 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10081 PyObject *resultobj;
10082 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10083 wxString *arg2 = 0 ;
10084 bool temp2 = false ;
10085 PyObject * obj0 = 0 ;
10086 PyObject * obj1 = 0 ;
10087 char *kwnames[] = {
10088 (char *) "self",(char *) "extension", NULL
10089 };
10090
10091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10093 if (SWIG_arg_fail(1)) SWIG_fail;
10094 {
10095 arg2 = wxString_in_helper(obj1);
10096 if (arg2 == NULL) SWIG_fail;
10097 temp2 = true;
10098 }
10099 {
10100 PyThreadState* __tstate = wxPyBeginAllowThreads();
10101 (arg1)->SetExtension((wxString const &)*arg2);
10102
10103 wxPyEndAllowThreads(__tstate);
10104 if (PyErr_Occurred()) SWIG_fail;
10105 }
10106 Py_INCREF(Py_None); resultobj = Py_None;
10107 {
10108 if (temp2)
10109 delete arg2;
10110 }
10111 return resultobj;
10112 fail:
10113 {
10114 if (temp2)
10115 delete arg2;
10116 }
10117 return NULL;
10118 }
10119
10120
10121 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10122 PyObject *resultobj;
10123 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10124 long arg2 ;
10125 PyObject * obj0 = 0 ;
10126 PyObject * obj1 = 0 ;
10127 char *kwnames[] = {
10128 (char *) "self",(char *) "type", NULL
10129 };
10130
10131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10133 if (SWIG_arg_fail(1)) SWIG_fail;
10134 {
10135 arg2 = (long)(SWIG_As_long(obj1));
10136 if (SWIG_arg_fail(2)) SWIG_fail;
10137 }
10138 {
10139 PyThreadState* __tstate = wxPyBeginAllowThreads();
10140 (arg1)->SetType(arg2);
10141
10142 wxPyEndAllowThreads(__tstate);
10143 if (PyErr_Occurred()) SWIG_fail;
10144 }
10145 Py_INCREF(Py_None); resultobj = Py_None;
10146 return resultobj;
10147 fail:
10148 return NULL;
10149 }
10150
10151
10152 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10153 PyObject *resultobj;
10154 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10155 wxString *arg2 = 0 ;
10156 bool temp2 = false ;
10157 PyObject * obj0 = 0 ;
10158 PyObject * obj1 = 0 ;
10159 char *kwnames[] = {
10160 (char *) "self",(char *) "mimetype", NULL
10161 };
10162
10163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10165 if (SWIG_arg_fail(1)) SWIG_fail;
10166 {
10167 arg2 = wxString_in_helper(obj1);
10168 if (arg2 == NULL) SWIG_fail;
10169 temp2 = true;
10170 }
10171 {
10172 PyThreadState* __tstate = wxPyBeginAllowThreads();
10173 (arg1)->SetMimeType((wxString const &)*arg2);
10174
10175 wxPyEndAllowThreads(__tstate);
10176 if (PyErr_Occurred()) SWIG_fail;
10177 }
10178 Py_INCREF(Py_None); resultobj = Py_None;
10179 {
10180 if (temp2)
10181 delete arg2;
10182 }
10183 return resultobj;
10184 fail:
10185 {
10186 if (temp2)
10187 delete arg2;
10188 }
10189 return NULL;
10190 }
10191
10192
10193 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10194 PyObject *obj;
10195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10196 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10197 Py_INCREF(obj);
10198 return Py_BuildValue((char *)"");
10199 }
10200 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10201 PyObject *resultobj;
10202 wxImageHistogram *result;
10203 char *kwnames[] = {
10204 NULL
10205 };
10206
10207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10208 {
10209 PyThreadState* __tstate = wxPyBeginAllowThreads();
10210 result = (wxImageHistogram *)new wxImageHistogram();
10211
10212 wxPyEndAllowThreads(__tstate);
10213 if (PyErr_Occurred()) SWIG_fail;
10214 }
10215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10216 return resultobj;
10217 fail:
10218 return NULL;
10219 }
10220
10221
10222 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10223 PyObject *resultobj;
10224 unsigned char arg1 ;
10225 unsigned char arg2 ;
10226 unsigned char arg3 ;
10227 unsigned long result;
10228 PyObject * obj0 = 0 ;
10229 PyObject * obj1 = 0 ;
10230 PyObject * obj2 = 0 ;
10231 char *kwnames[] = {
10232 (char *) "r",(char *) "g",(char *) "b", NULL
10233 };
10234
10235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10236 {
10237 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10238 if (SWIG_arg_fail(1)) SWIG_fail;
10239 }
10240 {
10241 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10242 if (SWIG_arg_fail(2)) SWIG_fail;
10243 }
10244 {
10245 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10246 if (SWIG_arg_fail(3)) SWIG_fail;
10247 }
10248 {
10249 PyThreadState* __tstate = wxPyBeginAllowThreads();
10250 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10251
10252 wxPyEndAllowThreads(__tstate);
10253 if (PyErr_Occurred()) SWIG_fail;
10254 }
10255 {
10256 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10257 }
10258 return resultobj;
10259 fail:
10260 return NULL;
10261 }
10262
10263
10264 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10265 PyObject *resultobj;
10266 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10267 unsigned char *arg2 = (unsigned char *) 0 ;
10268 unsigned char *arg3 = (unsigned char *) 0 ;
10269 unsigned char *arg4 = (unsigned char *) 0 ;
10270 unsigned char arg5 = (unsigned char) 1 ;
10271 unsigned char arg6 = (unsigned char) 0 ;
10272 unsigned char arg7 = (unsigned char) 0 ;
10273 bool result;
10274 unsigned char temp2 ;
10275 int res2 = 0 ;
10276 unsigned char temp3 ;
10277 int res3 = 0 ;
10278 unsigned char temp4 ;
10279 int res4 = 0 ;
10280 PyObject * obj0 = 0 ;
10281 PyObject * obj1 = 0 ;
10282 PyObject * obj2 = 0 ;
10283 PyObject * obj3 = 0 ;
10284 char *kwnames[] = {
10285 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10286 };
10287
10288 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10289 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10290 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10293 if (SWIG_arg_fail(1)) SWIG_fail;
10294 if (obj1) {
10295 {
10296 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10297 if (SWIG_arg_fail(5)) SWIG_fail;
10298 }
10299 }
10300 if (obj2) {
10301 {
10302 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10303 if (SWIG_arg_fail(6)) SWIG_fail;
10304 }
10305 }
10306 if (obj3) {
10307 {
10308 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10309 if (SWIG_arg_fail(7)) SWIG_fail;
10310 }
10311 }
10312 {
10313 PyThreadState* __tstate = wxPyBeginAllowThreads();
10314 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10315
10316 wxPyEndAllowThreads(__tstate);
10317 if (PyErr_Occurred()) SWIG_fail;
10318 }
10319 {
10320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10321 }
10322 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10323 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10324 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10325 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10326 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10327 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10328 return resultobj;
10329 fail:
10330 return NULL;
10331 }
10332
10333
10334 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10335 PyObject *obj;
10336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10337 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10338 Py_INCREF(obj);
10339 return Py_BuildValue((char *)"");
10340 }
10341 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10342 PyObject *resultobj;
10343 wxString *arg1 = 0 ;
10344 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10345 int arg3 = (int) -1 ;
10346 wxImage *result;
10347 bool temp1 = false ;
10348 PyObject * obj0 = 0 ;
10349 PyObject * obj1 = 0 ;
10350 PyObject * obj2 = 0 ;
10351 char *kwnames[] = {
10352 (char *) "name",(char *) "type",(char *) "index", NULL
10353 };
10354
10355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10356 {
10357 arg1 = wxString_in_helper(obj0);
10358 if (arg1 == NULL) SWIG_fail;
10359 temp1 = true;
10360 }
10361 if (obj1) {
10362 {
10363 arg2 = (long)(SWIG_As_long(obj1));
10364 if (SWIG_arg_fail(2)) SWIG_fail;
10365 }
10366 }
10367 if (obj2) {
10368 {
10369 arg3 = (int)(SWIG_As_int(obj2));
10370 if (SWIG_arg_fail(3)) SWIG_fail;
10371 }
10372 }
10373 {
10374 PyThreadState* __tstate = wxPyBeginAllowThreads();
10375 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10376
10377 wxPyEndAllowThreads(__tstate);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10381 {
10382 if (temp1)
10383 delete arg1;
10384 }
10385 return resultobj;
10386 fail:
10387 {
10388 if (temp1)
10389 delete arg1;
10390 }
10391 return NULL;
10392 }
10393
10394
10395 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10396 PyObject *resultobj;
10397 wxImage *arg1 = (wxImage *) 0 ;
10398 PyObject * obj0 = 0 ;
10399 char *kwnames[] = {
10400 (char *) "self", NULL
10401 };
10402
10403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10405 if (SWIG_arg_fail(1)) SWIG_fail;
10406 {
10407 PyThreadState* __tstate = wxPyBeginAllowThreads();
10408 delete arg1;
10409
10410 wxPyEndAllowThreads(__tstate);
10411 if (PyErr_Occurred()) SWIG_fail;
10412 }
10413 Py_INCREF(Py_None); resultobj = Py_None;
10414 return resultobj;
10415 fail:
10416 return NULL;
10417 }
10418
10419
10420 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10421 PyObject *resultobj;
10422 wxString *arg1 = 0 ;
10423 wxString *arg2 = 0 ;
10424 int arg3 = (int) -1 ;
10425 wxImage *result;
10426 bool temp1 = false ;
10427 bool temp2 = false ;
10428 PyObject * obj0 = 0 ;
10429 PyObject * obj1 = 0 ;
10430 PyObject * obj2 = 0 ;
10431 char *kwnames[] = {
10432 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10433 };
10434
10435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10436 {
10437 arg1 = wxString_in_helper(obj0);
10438 if (arg1 == NULL) SWIG_fail;
10439 temp1 = true;
10440 }
10441 {
10442 arg2 = wxString_in_helper(obj1);
10443 if (arg2 == NULL) SWIG_fail;
10444 temp2 = true;
10445 }
10446 if (obj2) {
10447 {
10448 arg3 = (int)(SWIG_As_int(obj2));
10449 if (SWIG_arg_fail(3)) SWIG_fail;
10450 }
10451 }
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10455
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10460 {
10461 if (temp1)
10462 delete arg1;
10463 }
10464 {
10465 if (temp2)
10466 delete arg2;
10467 }
10468 return resultobj;
10469 fail:
10470 {
10471 if (temp1)
10472 delete arg1;
10473 }
10474 {
10475 if (temp2)
10476 delete arg2;
10477 }
10478 return NULL;
10479 }
10480
10481
10482 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10483 PyObject *resultobj;
10484 wxInputStream *arg1 = 0 ;
10485 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10486 int arg3 = (int) -1 ;
10487 wxImage *result;
10488 wxPyInputStream *temp1 ;
10489 bool created1 ;
10490 PyObject * obj0 = 0 ;
10491 PyObject * obj1 = 0 ;
10492 PyObject * obj2 = 0 ;
10493 char *kwnames[] = {
10494 (char *) "stream",(char *) "type",(char *) "index", NULL
10495 };
10496
10497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10498 {
10499 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10500 arg1 = temp1->m_wxis;
10501 created1 = false;
10502 } else {
10503 PyErr_Clear(); // clear the failure of the wxPyConvert above
10504 arg1 = wxPyCBInputStream_create(obj0, false);
10505 if (arg1 == NULL) {
10506 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10507 SWIG_fail;
10508 }
10509 created1 = true;
10510 }
10511 }
10512 if (obj1) {
10513 {
10514 arg2 = (long)(SWIG_As_long(obj1));
10515 if (SWIG_arg_fail(2)) SWIG_fail;
10516 }
10517 }
10518 if (obj2) {
10519 {
10520 arg3 = (int)(SWIG_As_int(obj2));
10521 if (SWIG_arg_fail(3)) SWIG_fail;
10522 }
10523 }
10524 {
10525 PyThreadState* __tstate = wxPyBeginAllowThreads();
10526 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10527
10528 wxPyEndAllowThreads(__tstate);
10529 if (PyErr_Occurred()) SWIG_fail;
10530 }
10531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10532 {
10533 if (created1) delete arg1;
10534 }
10535 return resultobj;
10536 fail:
10537 {
10538 if (created1) delete arg1;
10539 }
10540 return NULL;
10541 }
10542
10543
10544 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10545 PyObject *resultobj;
10546 wxInputStream *arg1 = 0 ;
10547 wxString *arg2 = 0 ;
10548 int arg3 = (int) -1 ;
10549 wxImage *result;
10550 wxPyInputStream *temp1 ;
10551 bool created1 ;
10552 bool temp2 = false ;
10553 PyObject * obj0 = 0 ;
10554 PyObject * obj1 = 0 ;
10555 PyObject * obj2 = 0 ;
10556 char *kwnames[] = {
10557 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10558 };
10559
10560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10561 {
10562 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10563 arg1 = temp1->m_wxis;
10564 created1 = false;
10565 } else {
10566 PyErr_Clear(); // clear the failure of the wxPyConvert above
10567 arg1 = wxPyCBInputStream_create(obj0, false);
10568 if (arg1 == NULL) {
10569 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10570 SWIG_fail;
10571 }
10572 created1 = true;
10573 }
10574 }
10575 {
10576 arg2 = wxString_in_helper(obj1);
10577 if (arg2 == NULL) SWIG_fail;
10578 temp2 = true;
10579 }
10580 if (obj2) {
10581 {
10582 arg3 = (int)(SWIG_As_int(obj2));
10583 if (SWIG_arg_fail(3)) SWIG_fail;
10584 }
10585 }
10586 {
10587 PyThreadState* __tstate = wxPyBeginAllowThreads();
10588 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10589
10590 wxPyEndAllowThreads(__tstate);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10594 {
10595 if (created1) delete arg1;
10596 }
10597 {
10598 if (temp2)
10599 delete arg2;
10600 }
10601 return resultobj;
10602 fail:
10603 {
10604 if (created1) delete arg1;
10605 }
10606 {
10607 if (temp2)
10608 delete arg2;
10609 }
10610 return NULL;
10611 }
10612
10613
10614 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10615 PyObject *resultobj;
10616 int arg1 = (int) 0 ;
10617 int arg2 = (int) 0 ;
10618 bool arg3 = (bool) true ;
10619 wxImage *result;
10620 PyObject * obj0 = 0 ;
10621 PyObject * obj1 = 0 ;
10622 PyObject * obj2 = 0 ;
10623 char *kwnames[] = {
10624 (char *) "width",(char *) "height",(char *) "clear", NULL
10625 };
10626
10627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10628 if (obj0) {
10629 {
10630 arg1 = (int)(SWIG_As_int(obj0));
10631 if (SWIG_arg_fail(1)) SWIG_fail;
10632 }
10633 }
10634 if (obj1) {
10635 {
10636 arg2 = (int)(SWIG_As_int(obj1));
10637 if (SWIG_arg_fail(2)) SWIG_fail;
10638 }
10639 }
10640 if (obj2) {
10641 {
10642 arg3 = (bool)(SWIG_As_bool(obj2));
10643 if (SWIG_arg_fail(3)) SWIG_fail;
10644 }
10645 }
10646 {
10647 PyThreadState* __tstate = wxPyBeginAllowThreads();
10648 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10649
10650 wxPyEndAllowThreads(__tstate);
10651 if (PyErr_Occurred()) SWIG_fail;
10652 }
10653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10654 return resultobj;
10655 fail:
10656 return NULL;
10657 }
10658
10659
10660 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10661 PyObject *resultobj;
10662 wxBitmap *arg1 = 0 ;
10663 wxImage *result;
10664 PyObject * obj0 = 0 ;
10665 char *kwnames[] = {
10666 (char *) "bitmap", NULL
10667 };
10668
10669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10670 {
10671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10672 if (SWIG_arg_fail(1)) SWIG_fail;
10673 if (arg1 == NULL) {
10674 SWIG_null_ref("wxBitmap");
10675 }
10676 if (SWIG_arg_fail(1)) SWIG_fail;
10677 }
10678 {
10679 if (!wxPyCheckForApp()) SWIG_fail;
10680 PyThreadState* __tstate = wxPyBeginAllowThreads();
10681 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10682
10683 wxPyEndAllowThreads(__tstate);
10684 if (PyErr_Occurred()) SWIG_fail;
10685 }
10686 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10687 return resultobj;
10688 fail:
10689 return NULL;
10690 }
10691
10692
10693 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10694 PyObject *resultobj;
10695 int arg1 ;
10696 int arg2 ;
10697 unsigned char *arg3 = (unsigned char *) 0 ;
10698 wxImage *result;
10699 PyObject * obj0 = 0 ;
10700 PyObject * obj1 = 0 ;
10701 PyObject * obj2 = 0 ;
10702 char *kwnames[] = {
10703 (char *) "width",(char *) "height",(char *) "data", NULL
10704 };
10705
10706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10707 {
10708 arg1 = (int)(SWIG_As_int(obj0));
10709 if (SWIG_arg_fail(1)) SWIG_fail;
10710 }
10711 {
10712 arg2 = (int)(SWIG_As_int(obj1));
10713 if (SWIG_arg_fail(2)) SWIG_fail;
10714 }
10715 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10716 if (SWIG_arg_fail(3)) SWIG_fail;
10717 {
10718 PyThreadState* __tstate = wxPyBeginAllowThreads();
10719 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10720
10721 wxPyEndAllowThreads(__tstate);
10722 if (PyErr_Occurred()) SWIG_fail;
10723 }
10724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10725 return resultobj;
10726 fail:
10727 return NULL;
10728 }
10729
10730
10731 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10732 PyObject *resultobj;
10733 int arg1 ;
10734 int arg2 ;
10735 unsigned char *arg3 = (unsigned char *) 0 ;
10736 unsigned char *arg4 = (unsigned char *) 0 ;
10737 wxImage *result;
10738 PyObject * obj0 = 0 ;
10739 PyObject * obj1 = 0 ;
10740 PyObject * obj2 = 0 ;
10741 PyObject * obj3 = 0 ;
10742 char *kwnames[] = {
10743 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10744 };
10745
10746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10747 {
10748 arg1 = (int)(SWIG_As_int(obj0));
10749 if (SWIG_arg_fail(1)) SWIG_fail;
10750 }
10751 {
10752 arg2 = (int)(SWIG_As_int(obj1));
10753 if (SWIG_arg_fail(2)) SWIG_fail;
10754 }
10755 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10756 if (SWIG_arg_fail(3)) SWIG_fail;
10757 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10758 if (SWIG_arg_fail(4)) SWIG_fail;
10759 {
10760 PyThreadState* __tstate = wxPyBeginAllowThreads();
10761 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10762
10763 wxPyEndAllowThreads(__tstate);
10764 if (PyErr_Occurred()) SWIG_fail;
10765 }
10766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10774 PyObject *resultobj;
10775 wxImage *arg1 = (wxImage *) 0 ;
10776 int arg2 ;
10777 int arg3 ;
10778 PyObject * obj0 = 0 ;
10779 PyObject * obj1 = 0 ;
10780 PyObject * obj2 = 0 ;
10781 char *kwnames[] = {
10782 (char *) "self",(char *) "width",(char *) "height", NULL
10783 };
10784
10785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10787 if (SWIG_arg_fail(1)) SWIG_fail;
10788 {
10789 arg2 = (int)(SWIG_As_int(obj1));
10790 if (SWIG_arg_fail(2)) SWIG_fail;
10791 }
10792 {
10793 arg3 = (int)(SWIG_As_int(obj2));
10794 if (SWIG_arg_fail(3)) SWIG_fail;
10795 }
10796 {
10797 PyThreadState* __tstate = wxPyBeginAllowThreads();
10798 (arg1)->Create(arg2,arg3);
10799
10800 wxPyEndAllowThreads(__tstate);
10801 if (PyErr_Occurred()) SWIG_fail;
10802 }
10803 Py_INCREF(Py_None); resultobj = Py_None;
10804 return resultobj;
10805 fail:
10806 return NULL;
10807 }
10808
10809
10810 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10811 PyObject *resultobj;
10812 wxImage *arg1 = (wxImage *) 0 ;
10813 PyObject * obj0 = 0 ;
10814 char *kwnames[] = {
10815 (char *) "self", NULL
10816 };
10817
10818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10820 if (SWIG_arg_fail(1)) SWIG_fail;
10821 {
10822 PyThreadState* __tstate = wxPyBeginAllowThreads();
10823 (arg1)->Destroy();
10824
10825 wxPyEndAllowThreads(__tstate);
10826 if (PyErr_Occurred()) SWIG_fail;
10827 }
10828 Py_INCREF(Py_None); resultobj = Py_None;
10829 return resultobj;
10830 fail:
10831 return NULL;
10832 }
10833
10834
10835 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10836 PyObject *resultobj;
10837 wxImage *arg1 = (wxImage *) 0 ;
10838 int arg2 ;
10839 int arg3 ;
10840 SwigValueWrapper<wxImage > result;
10841 PyObject * obj0 = 0 ;
10842 PyObject * obj1 = 0 ;
10843 PyObject * obj2 = 0 ;
10844 char *kwnames[] = {
10845 (char *) "self",(char *) "width",(char *) "height", NULL
10846 };
10847
10848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10850 if (SWIG_arg_fail(1)) SWIG_fail;
10851 {
10852 arg2 = (int)(SWIG_As_int(obj1));
10853 if (SWIG_arg_fail(2)) SWIG_fail;
10854 }
10855 {
10856 arg3 = (int)(SWIG_As_int(obj2));
10857 if (SWIG_arg_fail(3)) SWIG_fail;
10858 }
10859 {
10860 PyThreadState* __tstate = wxPyBeginAllowThreads();
10861 result = (arg1)->Scale(arg2,arg3);
10862
10863 wxPyEndAllowThreads(__tstate);
10864 if (PyErr_Occurred()) SWIG_fail;
10865 }
10866 {
10867 wxImage * resultptr;
10868 resultptr = new wxImage((wxImage &)(result));
10869 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10870 }
10871 return resultobj;
10872 fail:
10873 return NULL;
10874 }
10875
10876
10877 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10878 PyObject *resultobj;
10879 wxImage *arg1 = (wxImage *) 0 ;
10880 int arg2 ;
10881 int arg3 ;
10882 SwigValueWrapper<wxImage > result;
10883 PyObject * obj0 = 0 ;
10884 PyObject * obj1 = 0 ;
10885 PyObject * obj2 = 0 ;
10886 char *kwnames[] = {
10887 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10888 };
10889
10890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10892 if (SWIG_arg_fail(1)) SWIG_fail;
10893 {
10894 arg2 = (int)(SWIG_As_int(obj1));
10895 if (SWIG_arg_fail(2)) SWIG_fail;
10896 }
10897 {
10898 arg3 = (int)(SWIG_As_int(obj2));
10899 if (SWIG_arg_fail(3)) SWIG_fail;
10900 }
10901 {
10902 PyThreadState* __tstate = wxPyBeginAllowThreads();
10903 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10904
10905 wxPyEndAllowThreads(__tstate);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 {
10909 wxImage * resultptr;
10910 resultptr = new wxImage((wxImage &)(result));
10911 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10912 }
10913 return resultobj;
10914 fail:
10915 return NULL;
10916 }
10917
10918
10919 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10920 PyObject *resultobj;
10921 wxImage *arg1 = (wxImage *) 0 ;
10922 int arg2 ;
10923 int arg3 ;
10924 wxImage *result;
10925 PyObject * obj0 = 0 ;
10926 PyObject * obj1 = 0 ;
10927 PyObject * obj2 = 0 ;
10928 char *kwnames[] = {
10929 (char *) "self",(char *) "width",(char *) "height", NULL
10930 };
10931
10932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10934 if (SWIG_arg_fail(1)) SWIG_fail;
10935 {
10936 arg2 = (int)(SWIG_As_int(obj1));
10937 if (SWIG_arg_fail(2)) SWIG_fail;
10938 }
10939 {
10940 arg3 = (int)(SWIG_As_int(obj2));
10941 if (SWIG_arg_fail(3)) SWIG_fail;
10942 }
10943 {
10944 PyThreadState* __tstate = wxPyBeginAllowThreads();
10945 {
10946 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10947 result = (wxImage *) &_result_ref;
10948 }
10949
10950 wxPyEndAllowThreads(__tstate);
10951 if (PyErr_Occurred()) SWIG_fail;
10952 }
10953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10954 return resultobj;
10955 fail:
10956 return NULL;
10957 }
10958
10959
10960 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
10961 PyObject *resultobj;
10962 wxImage *arg1 = (wxImage *) 0 ;
10963 wxSize *arg2 = 0 ;
10964 wxPoint *arg3 = 0 ;
10965 int arg4 = (int) -1 ;
10966 int arg5 = (int) -1 ;
10967 int arg6 = (int) -1 ;
10968 wxImage *result;
10969 wxSize temp2 ;
10970 wxPoint temp3 ;
10971 PyObject * obj0 = 0 ;
10972 PyObject * obj1 = 0 ;
10973 PyObject * obj2 = 0 ;
10974 PyObject * obj3 = 0 ;
10975 PyObject * obj4 = 0 ;
10976 PyObject * obj5 = 0 ;
10977 char *kwnames[] = {
10978 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
10979 };
10980
10981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10983 if (SWIG_arg_fail(1)) SWIG_fail;
10984 {
10985 arg2 = &temp2;
10986 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10987 }
10988 {
10989 arg3 = &temp3;
10990 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10991 }
10992 if (obj3) {
10993 {
10994 arg4 = (int)(SWIG_As_int(obj3));
10995 if (SWIG_arg_fail(4)) SWIG_fail;
10996 }
10997 }
10998 if (obj4) {
10999 {
11000 arg5 = (int)(SWIG_As_int(obj4));
11001 if (SWIG_arg_fail(5)) SWIG_fail;
11002 }
11003 }
11004 if (obj5) {
11005 {
11006 arg6 = (int)(SWIG_As_int(obj5));
11007 if (SWIG_arg_fail(6)) SWIG_fail;
11008 }
11009 }
11010 {
11011 PyThreadState* __tstate = wxPyBeginAllowThreads();
11012 {
11013 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11014 result = (wxImage *) &_result_ref;
11015 }
11016
11017 wxPyEndAllowThreads(__tstate);
11018 if (PyErr_Occurred()) SWIG_fail;
11019 }
11020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11021 return resultobj;
11022 fail:
11023 return NULL;
11024 }
11025
11026
11027 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11028 PyObject *resultobj;
11029 wxImage *arg1 = (wxImage *) 0 ;
11030 int arg2 ;
11031 int arg3 ;
11032 unsigned char arg4 ;
11033 unsigned char arg5 ;
11034 unsigned char arg6 ;
11035 PyObject * obj0 = 0 ;
11036 PyObject * obj1 = 0 ;
11037 PyObject * obj2 = 0 ;
11038 PyObject * obj3 = 0 ;
11039 PyObject * obj4 = 0 ;
11040 PyObject * obj5 = 0 ;
11041 char *kwnames[] = {
11042 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11043 };
11044
11045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11047 if (SWIG_arg_fail(1)) SWIG_fail;
11048 {
11049 arg2 = (int)(SWIG_As_int(obj1));
11050 if (SWIG_arg_fail(2)) SWIG_fail;
11051 }
11052 {
11053 arg3 = (int)(SWIG_As_int(obj2));
11054 if (SWIG_arg_fail(3)) SWIG_fail;
11055 }
11056 {
11057 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11058 if (SWIG_arg_fail(4)) SWIG_fail;
11059 }
11060 {
11061 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11062 if (SWIG_arg_fail(5)) SWIG_fail;
11063 }
11064 {
11065 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11066 if (SWIG_arg_fail(6)) SWIG_fail;
11067 }
11068 {
11069 PyThreadState* __tstate = wxPyBeginAllowThreads();
11070 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11071
11072 wxPyEndAllowThreads(__tstate);
11073 if (PyErr_Occurred()) SWIG_fail;
11074 }
11075 Py_INCREF(Py_None); resultobj = Py_None;
11076 return resultobj;
11077 fail:
11078 return NULL;
11079 }
11080
11081
11082 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11083 PyObject *resultobj;
11084 wxImage *arg1 = (wxImage *) 0 ;
11085 wxRect *arg2 = 0 ;
11086 unsigned char arg3 ;
11087 unsigned char arg4 ;
11088 unsigned char arg5 ;
11089 wxRect temp2 ;
11090 PyObject * obj0 = 0 ;
11091 PyObject * obj1 = 0 ;
11092 PyObject * obj2 = 0 ;
11093 PyObject * obj3 = 0 ;
11094 PyObject * obj4 = 0 ;
11095 char *kwnames[] = {
11096 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11097 };
11098
11099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11101 if (SWIG_arg_fail(1)) SWIG_fail;
11102 {
11103 arg2 = &temp2;
11104 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11105 }
11106 {
11107 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11108 if (SWIG_arg_fail(3)) SWIG_fail;
11109 }
11110 {
11111 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11112 if (SWIG_arg_fail(4)) SWIG_fail;
11113 }
11114 {
11115 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11116 if (SWIG_arg_fail(5)) SWIG_fail;
11117 }
11118 {
11119 PyThreadState* __tstate = wxPyBeginAllowThreads();
11120 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11121
11122 wxPyEndAllowThreads(__tstate);
11123 if (PyErr_Occurred()) SWIG_fail;
11124 }
11125 Py_INCREF(Py_None); resultobj = Py_None;
11126 return resultobj;
11127 fail:
11128 return NULL;
11129 }
11130
11131
11132 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11133 PyObject *resultobj;
11134 wxImage *arg1 = (wxImage *) 0 ;
11135 int arg2 ;
11136 int arg3 ;
11137 unsigned char result;
11138 PyObject * obj0 = 0 ;
11139 PyObject * obj1 = 0 ;
11140 PyObject * obj2 = 0 ;
11141 char *kwnames[] = {
11142 (char *) "self",(char *) "x",(char *) "y", NULL
11143 };
11144
11145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11147 if (SWIG_arg_fail(1)) SWIG_fail;
11148 {
11149 arg2 = (int)(SWIG_As_int(obj1));
11150 if (SWIG_arg_fail(2)) SWIG_fail;
11151 }
11152 {
11153 arg3 = (int)(SWIG_As_int(obj2));
11154 if (SWIG_arg_fail(3)) SWIG_fail;
11155 }
11156 {
11157 PyThreadState* __tstate = wxPyBeginAllowThreads();
11158 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11159
11160 wxPyEndAllowThreads(__tstate);
11161 if (PyErr_Occurred()) SWIG_fail;
11162 }
11163 {
11164 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11165 }
11166 return resultobj;
11167 fail:
11168 return NULL;
11169 }
11170
11171
11172 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11173 PyObject *resultobj;
11174 wxImage *arg1 = (wxImage *) 0 ;
11175 int arg2 ;
11176 int arg3 ;
11177 unsigned char result;
11178 PyObject * obj0 = 0 ;
11179 PyObject * obj1 = 0 ;
11180 PyObject * obj2 = 0 ;
11181 char *kwnames[] = {
11182 (char *) "self",(char *) "x",(char *) "y", NULL
11183 };
11184
11185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11187 if (SWIG_arg_fail(1)) SWIG_fail;
11188 {
11189 arg2 = (int)(SWIG_As_int(obj1));
11190 if (SWIG_arg_fail(2)) SWIG_fail;
11191 }
11192 {
11193 arg3 = (int)(SWIG_As_int(obj2));
11194 if (SWIG_arg_fail(3)) SWIG_fail;
11195 }
11196 {
11197 PyThreadState* __tstate = wxPyBeginAllowThreads();
11198 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11199
11200 wxPyEndAllowThreads(__tstate);
11201 if (PyErr_Occurred()) SWIG_fail;
11202 }
11203 {
11204 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11205 }
11206 return resultobj;
11207 fail:
11208 return NULL;
11209 }
11210
11211
11212 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11213 PyObject *resultobj;
11214 wxImage *arg1 = (wxImage *) 0 ;
11215 int arg2 ;
11216 int arg3 ;
11217 unsigned char result;
11218 PyObject * obj0 = 0 ;
11219 PyObject * obj1 = 0 ;
11220 PyObject * obj2 = 0 ;
11221 char *kwnames[] = {
11222 (char *) "self",(char *) "x",(char *) "y", NULL
11223 };
11224
11225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11227 if (SWIG_arg_fail(1)) SWIG_fail;
11228 {
11229 arg2 = (int)(SWIG_As_int(obj1));
11230 if (SWIG_arg_fail(2)) SWIG_fail;
11231 }
11232 {
11233 arg3 = (int)(SWIG_As_int(obj2));
11234 if (SWIG_arg_fail(3)) SWIG_fail;
11235 }
11236 {
11237 PyThreadState* __tstate = wxPyBeginAllowThreads();
11238 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11239
11240 wxPyEndAllowThreads(__tstate);
11241 if (PyErr_Occurred()) SWIG_fail;
11242 }
11243 {
11244 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11245 }
11246 return resultobj;
11247 fail:
11248 return NULL;
11249 }
11250
11251
11252 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11253 PyObject *resultobj;
11254 wxImage *arg1 = (wxImage *) 0 ;
11255 int arg2 ;
11256 int arg3 ;
11257 unsigned char arg4 ;
11258 PyObject * obj0 = 0 ;
11259 PyObject * obj1 = 0 ;
11260 PyObject * obj2 = 0 ;
11261 PyObject * obj3 = 0 ;
11262 char *kwnames[] = {
11263 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11264 };
11265
11266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11268 if (SWIG_arg_fail(1)) SWIG_fail;
11269 {
11270 arg2 = (int)(SWIG_As_int(obj1));
11271 if (SWIG_arg_fail(2)) SWIG_fail;
11272 }
11273 {
11274 arg3 = (int)(SWIG_As_int(obj2));
11275 if (SWIG_arg_fail(3)) SWIG_fail;
11276 }
11277 {
11278 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11279 if (SWIG_arg_fail(4)) SWIG_fail;
11280 }
11281 {
11282 PyThreadState* __tstate = wxPyBeginAllowThreads();
11283 (arg1)->SetAlpha(arg2,arg3,arg4);
11284
11285 wxPyEndAllowThreads(__tstate);
11286 if (PyErr_Occurred()) SWIG_fail;
11287 }
11288 Py_INCREF(Py_None); resultobj = Py_None;
11289 return resultobj;
11290 fail:
11291 return NULL;
11292 }
11293
11294
11295 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11296 PyObject *resultobj;
11297 wxImage *arg1 = (wxImage *) 0 ;
11298 int arg2 ;
11299 int arg3 ;
11300 unsigned char result;
11301 PyObject * obj0 = 0 ;
11302 PyObject * obj1 = 0 ;
11303 PyObject * obj2 = 0 ;
11304 char *kwnames[] = {
11305 (char *) "self",(char *) "x",(char *) "y", NULL
11306 };
11307
11308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11310 if (SWIG_arg_fail(1)) SWIG_fail;
11311 {
11312 arg2 = (int)(SWIG_As_int(obj1));
11313 if (SWIG_arg_fail(2)) SWIG_fail;
11314 }
11315 {
11316 arg3 = (int)(SWIG_As_int(obj2));
11317 if (SWIG_arg_fail(3)) SWIG_fail;
11318 }
11319 {
11320 PyThreadState* __tstate = wxPyBeginAllowThreads();
11321 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11322
11323 wxPyEndAllowThreads(__tstate);
11324 if (PyErr_Occurred()) SWIG_fail;
11325 }
11326 {
11327 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11328 }
11329 return resultobj;
11330 fail:
11331 return NULL;
11332 }
11333
11334
11335 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11336 PyObject *resultobj;
11337 wxImage *arg1 = (wxImage *) 0 ;
11338 bool result;
11339 PyObject * obj0 = 0 ;
11340 char *kwnames[] = {
11341 (char *) "self", NULL
11342 };
11343
11344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11346 if (SWIG_arg_fail(1)) SWIG_fail;
11347 {
11348 PyThreadState* __tstate = wxPyBeginAllowThreads();
11349 result = (bool)(arg1)->HasAlpha();
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_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11364 PyObject *resultobj;
11365 wxImage *arg1 = (wxImage *) 0 ;
11366 PyObject * obj0 = 0 ;
11367 char *kwnames[] = {
11368 (char *) "self", NULL
11369 };
11370
11371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11373 if (SWIG_arg_fail(1)) SWIG_fail;
11374 {
11375 PyThreadState* __tstate = wxPyBeginAllowThreads();
11376 (arg1)->InitAlpha();
11377
11378 wxPyEndAllowThreads(__tstate);
11379 if (PyErr_Occurred()) SWIG_fail;
11380 }
11381 Py_INCREF(Py_None); resultobj = Py_None;
11382 return resultobj;
11383 fail:
11384 return NULL;
11385 }
11386
11387
11388 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11389 PyObject *resultobj;
11390 wxImage *arg1 = (wxImage *) 0 ;
11391 byte *arg2 = (byte *) 0 ;
11392 byte *arg3 = (byte *) 0 ;
11393 byte *arg4 = (byte *) 0 ;
11394 byte arg5 = (byte) 0 ;
11395 byte arg6 = (byte) 0 ;
11396 byte arg7 = (byte) 0 ;
11397 bool result;
11398 byte temp2 ;
11399 int res2 = 0 ;
11400 byte temp3 ;
11401 int res3 = 0 ;
11402 byte temp4 ;
11403 int res4 = 0 ;
11404 PyObject * obj0 = 0 ;
11405 PyObject * obj1 = 0 ;
11406 PyObject * obj2 = 0 ;
11407 PyObject * obj3 = 0 ;
11408 char *kwnames[] = {
11409 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11410 };
11411
11412 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11413 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11414 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11417 if (SWIG_arg_fail(1)) SWIG_fail;
11418 if (obj1) {
11419 {
11420 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11421 if (SWIG_arg_fail(5)) SWIG_fail;
11422 }
11423 }
11424 if (obj2) {
11425 {
11426 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11427 if (SWIG_arg_fail(6)) SWIG_fail;
11428 }
11429 }
11430 if (obj3) {
11431 {
11432 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11433 if (SWIG_arg_fail(7)) SWIG_fail;
11434 }
11435 }
11436 {
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11439
11440 wxPyEndAllowThreads(__tstate);
11441 if (PyErr_Occurred()) SWIG_fail;
11442 }
11443 {
11444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11445 }
11446 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11447 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11448 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11449 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11450 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11451 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11452 return resultobj;
11453 fail:
11454 return NULL;
11455 }
11456
11457
11458 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11459 PyObject *resultobj;
11460 wxImage *arg1 = (wxImage *) 0 ;
11461 byte arg2 = (byte) 128 ;
11462 bool result;
11463 PyObject * obj0 = 0 ;
11464 PyObject * obj1 = 0 ;
11465 char *kwnames[] = {
11466 (char *) "self",(char *) "threshold", NULL
11467 };
11468
11469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11471 if (SWIG_arg_fail(1)) SWIG_fail;
11472 if (obj1) {
11473 {
11474 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11475 if (SWIG_arg_fail(2)) SWIG_fail;
11476 }
11477 }
11478 {
11479 PyThreadState* __tstate = wxPyBeginAllowThreads();
11480 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11481
11482 wxPyEndAllowThreads(__tstate);
11483 if (PyErr_Occurred()) SWIG_fail;
11484 }
11485 {
11486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11487 }
11488 return resultobj;
11489 fail:
11490 return NULL;
11491 }
11492
11493
11494 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11495 PyObject *resultobj;
11496 wxImage *arg1 = (wxImage *) 0 ;
11497 unsigned char arg2 ;
11498 unsigned char arg3 ;
11499 unsigned char arg4 ;
11500 bool result;
11501 PyObject * obj0 = 0 ;
11502 PyObject * obj1 = 0 ;
11503 PyObject * obj2 = 0 ;
11504 PyObject * obj3 = 0 ;
11505 char *kwnames[] = {
11506 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11507 };
11508
11509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11511 if (SWIG_arg_fail(1)) SWIG_fail;
11512 {
11513 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11514 if (SWIG_arg_fail(2)) SWIG_fail;
11515 }
11516 {
11517 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11518 if (SWIG_arg_fail(3)) SWIG_fail;
11519 }
11520 {
11521 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11522 if (SWIG_arg_fail(4)) SWIG_fail;
11523 }
11524 {
11525 PyThreadState* __tstate = wxPyBeginAllowThreads();
11526 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11527
11528 wxPyEndAllowThreads(__tstate);
11529 if (PyErr_Occurred()) SWIG_fail;
11530 }
11531 {
11532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11533 }
11534 return resultobj;
11535 fail:
11536 return NULL;
11537 }
11538
11539
11540 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11541 PyObject *resultobj;
11542 wxImage *arg1 = (wxImage *) 0 ;
11543 wxImage *arg2 = 0 ;
11544 byte arg3 ;
11545 byte arg4 ;
11546 byte arg5 ;
11547 bool result;
11548 PyObject * obj0 = 0 ;
11549 PyObject * obj1 = 0 ;
11550 PyObject * obj2 = 0 ;
11551 PyObject * obj3 = 0 ;
11552 PyObject * obj4 = 0 ;
11553 char *kwnames[] = {
11554 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11555 };
11556
11557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11559 if (SWIG_arg_fail(1)) SWIG_fail;
11560 {
11561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11562 if (SWIG_arg_fail(2)) SWIG_fail;
11563 if (arg2 == NULL) {
11564 SWIG_null_ref("wxImage");
11565 }
11566 if (SWIG_arg_fail(2)) SWIG_fail;
11567 }
11568 {
11569 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11570 if (SWIG_arg_fail(3)) SWIG_fail;
11571 }
11572 {
11573 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11574 if (SWIG_arg_fail(4)) SWIG_fail;
11575 }
11576 {
11577 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11578 if (SWIG_arg_fail(5)) SWIG_fail;
11579 }
11580 {
11581 PyThreadState* __tstate = wxPyBeginAllowThreads();
11582 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11583
11584 wxPyEndAllowThreads(__tstate);
11585 if (PyErr_Occurred()) SWIG_fail;
11586 }
11587 {
11588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11589 }
11590 return resultobj;
11591 fail:
11592 return NULL;
11593 }
11594
11595
11596 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11597 PyObject *resultobj;
11598 wxString *arg1 = 0 ;
11599 bool result;
11600 bool temp1 = false ;
11601 PyObject * obj0 = 0 ;
11602 char *kwnames[] = {
11603 (char *) "name", NULL
11604 };
11605
11606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11607 {
11608 arg1 = wxString_in_helper(obj0);
11609 if (arg1 == NULL) SWIG_fail;
11610 temp1 = true;
11611 }
11612 {
11613 PyThreadState* __tstate = wxPyBeginAllowThreads();
11614 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11615
11616 wxPyEndAllowThreads(__tstate);
11617 if (PyErr_Occurred()) SWIG_fail;
11618 }
11619 {
11620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11621 }
11622 {
11623 if (temp1)
11624 delete arg1;
11625 }
11626 return resultobj;
11627 fail:
11628 {
11629 if (temp1)
11630 delete arg1;
11631 }
11632 return NULL;
11633 }
11634
11635
11636 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11637 PyObject *resultobj;
11638 wxString *arg1 = 0 ;
11639 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11640 int result;
11641 bool temp1 = false ;
11642 PyObject * obj0 = 0 ;
11643 PyObject * obj1 = 0 ;
11644 char *kwnames[] = {
11645 (char *) "name",(char *) "type", NULL
11646 };
11647
11648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11649 {
11650 arg1 = wxString_in_helper(obj0);
11651 if (arg1 == NULL) SWIG_fail;
11652 temp1 = true;
11653 }
11654 if (obj1) {
11655 {
11656 arg2 = (long)(SWIG_As_long(obj1));
11657 if (SWIG_arg_fail(2)) SWIG_fail;
11658 }
11659 }
11660 {
11661 PyThreadState* __tstate = wxPyBeginAllowThreads();
11662 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11663
11664 wxPyEndAllowThreads(__tstate);
11665 if (PyErr_Occurred()) SWIG_fail;
11666 }
11667 {
11668 resultobj = SWIG_From_int((int)(result));
11669 }
11670 {
11671 if (temp1)
11672 delete arg1;
11673 }
11674 return resultobj;
11675 fail:
11676 {
11677 if (temp1)
11678 delete arg1;
11679 }
11680 return NULL;
11681 }
11682
11683
11684 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11685 PyObject *resultobj;
11686 wxImage *arg1 = (wxImage *) 0 ;
11687 wxString *arg2 = 0 ;
11688 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11689 int arg4 = (int) -1 ;
11690 bool result;
11691 bool temp2 = false ;
11692 PyObject * obj0 = 0 ;
11693 PyObject * obj1 = 0 ;
11694 PyObject * obj2 = 0 ;
11695 PyObject * obj3 = 0 ;
11696 char *kwnames[] = {
11697 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11698 };
11699
11700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11702 if (SWIG_arg_fail(1)) SWIG_fail;
11703 {
11704 arg2 = wxString_in_helper(obj1);
11705 if (arg2 == NULL) SWIG_fail;
11706 temp2 = true;
11707 }
11708 if (obj2) {
11709 {
11710 arg3 = (long)(SWIG_As_long(obj2));
11711 if (SWIG_arg_fail(3)) SWIG_fail;
11712 }
11713 }
11714 if (obj3) {
11715 {
11716 arg4 = (int)(SWIG_As_int(obj3));
11717 if (SWIG_arg_fail(4)) SWIG_fail;
11718 }
11719 }
11720 {
11721 PyThreadState* __tstate = wxPyBeginAllowThreads();
11722 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11723
11724 wxPyEndAllowThreads(__tstate);
11725 if (PyErr_Occurred()) SWIG_fail;
11726 }
11727 {
11728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11729 }
11730 {
11731 if (temp2)
11732 delete arg2;
11733 }
11734 return resultobj;
11735 fail:
11736 {
11737 if (temp2)
11738 delete arg2;
11739 }
11740 return NULL;
11741 }
11742
11743
11744 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11745 PyObject *resultobj;
11746 wxImage *arg1 = (wxImage *) 0 ;
11747 wxString *arg2 = 0 ;
11748 wxString *arg3 = 0 ;
11749 int arg4 = (int) -1 ;
11750 bool result;
11751 bool temp2 = false ;
11752 bool temp3 = false ;
11753 PyObject * obj0 = 0 ;
11754 PyObject * obj1 = 0 ;
11755 PyObject * obj2 = 0 ;
11756 PyObject * obj3 = 0 ;
11757 char *kwnames[] = {
11758 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11759 };
11760
11761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11763 if (SWIG_arg_fail(1)) SWIG_fail;
11764 {
11765 arg2 = wxString_in_helper(obj1);
11766 if (arg2 == NULL) SWIG_fail;
11767 temp2 = true;
11768 }
11769 {
11770 arg3 = wxString_in_helper(obj2);
11771 if (arg3 == NULL) SWIG_fail;
11772 temp3 = true;
11773 }
11774 if (obj3) {
11775 {
11776 arg4 = (int)(SWIG_As_int(obj3));
11777 if (SWIG_arg_fail(4)) SWIG_fail;
11778 }
11779 }
11780 {
11781 PyThreadState* __tstate = wxPyBeginAllowThreads();
11782 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11783
11784 wxPyEndAllowThreads(__tstate);
11785 if (PyErr_Occurred()) SWIG_fail;
11786 }
11787 {
11788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11789 }
11790 {
11791 if (temp2)
11792 delete arg2;
11793 }
11794 {
11795 if (temp3)
11796 delete arg3;
11797 }
11798 return resultobj;
11799 fail:
11800 {
11801 if (temp2)
11802 delete arg2;
11803 }
11804 {
11805 if (temp3)
11806 delete arg3;
11807 }
11808 return NULL;
11809 }
11810
11811
11812 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11813 PyObject *resultobj;
11814 wxImage *arg1 = (wxImage *) 0 ;
11815 wxString *arg2 = 0 ;
11816 int arg3 ;
11817 bool result;
11818 bool temp2 = false ;
11819 PyObject * obj0 = 0 ;
11820 PyObject * obj1 = 0 ;
11821 PyObject * obj2 = 0 ;
11822 char *kwnames[] = {
11823 (char *) "self",(char *) "name",(char *) "type", NULL
11824 };
11825
11826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11828 if (SWIG_arg_fail(1)) SWIG_fail;
11829 {
11830 arg2 = wxString_in_helper(obj1);
11831 if (arg2 == NULL) SWIG_fail;
11832 temp2 = true;
11833 }
11834 {
11835 arg3 = (int)(SWIG_As_int(obj2));
11836 if (SWIG_arg_fail(3)) SWIG_fail;
11837 }
11838 {
11839 PyThreadState* __tstate = wxPyBeginAllowThreads();
11840 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11841
11842 wxPyEndAllowThreads(__tstate);
11843 if (PyErr_Occurred()) SWIG_fail;
11844 }
11845 {
11846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11847 }
11848 {
11849 if (temp2)
11850 delete arg2;
11851 }
11852 return resultobj;
11853 fail:
11854 {
11855 if (temp2)
11856 delete arg2;
11857 }
11858 return NULL;
11859 }
11860
11861
11862 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11863 PyObject *resultobj;
11864 wxImage *arg1 = (wxImage *) 0 ;
11865 wxString *arg2 = 0 ;
11866 wxString *arg3 = 0 ;
11867 bool result;
11868 bool temp2 = false ;
11869 bool temp3 = false ;
11870 PyObject * obj0 = 0 ;
11871 PyObject * obj1 = 0 ;
11872 PyObject * obj2 = 0 ;
11873 char *kwnames[] = {
11874 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11875 };
11876
11877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11879 if (SWIG_arg_fail(1)) SWIG_fail;
11880 {
11881 arg2 = wxString_in_helper(obj1);
11882 if (arg2 == NULL) SWIG_fail;
11883 temp2 = true;
11884 }
11885 {
11886 arg3 = wxString_in_helper(obj2);
11887 if (arg3 == NULL) SWIG_fail;
11888 temp3 = true;
11889 }
11890 {
11891 PyThreadState* __tstate = wxPyBeginAllowThreads();
11892 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11893
11894 wxPyEndAllowThreads(__tstate);
11895 if (PyErr_Occurred()) SWIG_fail;
11896 }
11897 {
11898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11899 }
11900 {
11901 if (temp2)
11902 delete arg2;
11903 }
11904 {
11905 if (temp3)
11906 delete arg3;
11907 }
11908 return resultobj;
11909 fail:
11910 {
11911 if (temp2)
11912 delete arg2;
11913 }
11914 {
11915 if (temp3)
11916 delete arg3;
11917 }
11918 return NULL;
11919 }
11920
11921
11922 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11923 PyObject *resultobj;
11924 wxInputStream *arg1 = 0 ;
11925 bool result;
11926 wxPyInputStream *temp1 ;
11927 bool created1 ;
11928 PyObject * obj0 = 0 ;
11929 char *kwnames[] = {
11930 (char *) "stream", NULL
11931 };
11932
11933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11934 {
11935 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11936 arg1 = temp1->m_wxis;
11937 created1 = false;
11938 } else {
11939 PyErr_Clear(); // clear the failure of the wxPyConvert above
11940 arg1 = wxPyCBInputStream_create(obj0, false);
11941 if (arg1 == NULL) {
11942 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11943 SWIG_fail;
11944 }
11945 created1 = true;
11946 }
11947 }
11948 {
11949 PyThreadState* __tstate = wxPyBeginAllowThreads();
11950 result = (bool)wxImage::CanRead(*arg1);
11951
11952 wxPyEndAllowThreads(__tstate);
11953 if (PyErr_Occurred()) SWIG_fail;
11954 }
11955 {
11956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11957 }
11958 {
11959 if (created1) delete arg1;
11960 }
11961 return resultobj;
11962 fail:
11963 {
11964 if (created1) delete arg1;
11965 }
11966 return NULL;
11967 }
11968
11969
11970 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11971 PyObject *resultobj;
11972 wxImage *arg1 = (wxImage *) 0 ;
11973 wxInputStream *arg2 = 0 ;
11974 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11975 int arg4 = (int) -1 ;
11976 bool result;
11977 wxPyInputStream *temp2 ;
11978 bool created2 ;
11979 PyObject * obj0 = 0 ;
11980 PyObject * obj1 = 0 ;
11981 PyObject * obj2 = 0 ;
11982 PyObject * obj3 = 0 ;
11983 char *kwnames[] = {
11984 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11985 };
11986
11987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11989 if (SWIG_arg_fail(1)) SWIG_fail;
11990 {
11991 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11992 arg2 = temp2->m_wxis;
11993 created2 = false;
11994 } else {
11995 PyErr_Clear(); // clear the failure of the wxPyConvert above
11996 arg2 = wxPyCBInputStream_create(obj1, false);
11997 if (arg2 == NULL) {
11998 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11999 SWIG_fail;
12000 }
12001 created2 = true;
12002 }
12003 }
12004 if (obj2) {
12005 {
12006 arg3 = (long)(SWIG_As_long(obj2));
12007 if (SWIG_arg_fail(3)) SWIG_fail;
12008 }
12009 }
12010 if (obj3) {
12011 {
12012 arg4 = (int)(SWIG_As_int(obj3));
12013 if (SWIG_arg_fail(4)) SWIG_fail;
12014 }
12015 }
12016 {
12017 PyThreadState* __tstate = wxPyBeginAllowThreads();
12018 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12019
12020 wxPyEndAllowThreads(__tstate);
12021 if (PyErr_Occurred()) SWIG_fail;
12022 }
12023 {
12024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12025 }
12026 {
12027 if (created2) delete arg2;
12028 }
12029 return resultobj;
12030 fail:
12031 {
12032 if (created2) delete arg2;
12033 }
12034 return NULL;
12035 }
12036
12037
12038 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12039 PyObject *resultobj;
12040 wxImage *arg1 = (wxImage *) 0 ;
12041 wxInputStream *arg2 = 0 ;
12042 wxString *arg3 = 0 ;
12043 int arg4 = (int) -1 ;
12044 bool result;
12045 wxPyInputStream *temp2 ;
12046 bool created2 ;
12047 bool temp3 = false ;
12048 PyObject * obj0 = 0 ;
12049 PyObject * obj1 = 0 ;
12050 PyObject * obj2 = 0 ;
12051 PyObject * obj3 = 0 ;
12052 char *kwnames[] = {
12053 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12054 };
12055
12056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12058 if (SWIG_arg_fail(1)) SWIG_fail;
12059 {
12060 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12061 arg2 = temp2->m_wxis;
12062 created2 = false;
12063 } else {
12064 PyErr_Clear(); // clear the failure of the wxPyConvert above
12065 arg2 = wxPyCBInputStream_create(obj1, false);
12066 if (arg2 == NULL) {
12067 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12068 SWIG_fail;
12069 }
12070 created2 = true;
12071 }
12072 }
12073 {
12074 arg3 = wxString_in_helper(obj2);
12075 if (arg3 == NULL) SWIG_fail;
12076 temp3 = true;
12077 }
12078 if (obj3) {
12079 {
12080 arg4 = (int)(SWIG_As_int(obj3));
12081 if (SWIG_arg_fail(4)) SWIG_fail;
12082 }
12083 }
12084 {
12085 PyThreadState* __tstate = wxPyBeginAllowThreads();
12086 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12087
12088 wxPyEndAllowThreads(__tstate);
12089 if (PyErr_Occurred()) SWIG_fail;
12090 }
12091 {
12092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12093 }
12094 {
12095 if (created2) delete arg2;
12096 }
12097 {
12098 if (temp3)
12099 delete arg3;
12100 }
12101 return resultobj;
12102 fail:
12103 {
12104 if (created2) delete arg2;
12105 }
12106 {
12107 if (temp3)
12108 delete arg3;
12109 }
12110 return NULL;
12111 }
12112
12113
12114 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12115 PyObject *resultobj;
12116 wxImage *arg1 = (wxImage *) 0 ;
12117 bool result;
12118 PyObject * obj0 = 0 ;
12119 char *kwnames[] = {
12120 (char *) "self", NULL
12121 };
12122
12123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12125 if (SWIG_arg_fail(1)) SWIG_fail;
12126 {
12127 PyThreadState* __tstate = wxPyBeginAllowThreads();
12128 result = (bool)(arg1)->Ok();
12129
12130 wxPyEndAllowThreads(__tstate);
12131 if (PyErr_Occurred()) SWIG_fail;
12132 }
12133 {
12134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12135 }
12136 return resultobj;
12137 fail:
12138 return NULL;
12139 }
12140
12141
12142 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12143 PyObject *resultobj;
12144 wxImage *arg1 = (wxImage *) 0 ;
12145 int result;
12146 PyObject * obj0 = 0 ;
12147 char *kwnames[] = {
12148 (char *) "self", NULL
12149 };
12150
12151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12153 if (SWIG_arg_fail(1)) SWIG_fail;
12154 {
12155 PyThreadState* __tstate = wxPyBeginAllowThreads();
12156 result = (int)(arg1)->GetWidth();
12157
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 {
12162 resultobj = SWIG_From_int((int)(result));
12163 }
12164 return resultobj;
12165 fail:
12166 return NULL;
12167 }
12168
12169
12170 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12171 PyObject *resultobj;
12172 wxImage *arg1 = (wxImage *) 0 ;
12173 int result;
12174 PyObject * obj0 = 0 ;
12175 char *kwnames[] = {
12176 (char *) "self", NULL
12177 };
12178
12179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12181 if (SWIG_arg_fail(1)) SWIG_fail;
12182 {
12183 PyThreadState* __tstate = wxPyBeginAllowThreads();
12184 result = (int)(arg1)->GetHeight();
12185
12186 wxPyEndAllowThreads(__tstate);
12187 if (PyErr_Occurred()) SWIG_fail;
12188 }
12189 {
12190 resultobj = SWIG_From_int((int)(result));
12191 }
12192 return resultobj;
12193 fail:
12194 return NULL;
12195 }
12196
12197
12198 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12199 PyObject *resultobj;
12200 wxImage *arg1 = (wxImage *) 0 ;
12201 wxSize result;
12202 PyObject * obj0 = 0 ;
12203 char *kwnames[] = {
12204 (char *) "self", NULL
12205 };
12206
12207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12209 if (SWIG_arg_fail(1)) SWIG_fail;
12210 {
12211 PyThreadState* __tstate = wxPyBeginAllowThreads();
12212 result = wxImage_GetSize(arg1);
12213
12214 wxPyEndAllowThreads(__tstate);
12215 if (PyErr_Occurred()) SWIG_fail;
12216 }
12217 {
12218 wxSize * resultptr;
12219 resultptr = new wxSize((wxSize &)(result));
12220 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12221 }
12222 return resultobj;
12223 fail:
12224 return NULL;
12225 }
12226
12227
12228 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12229 PyObject *resultobj;
12230 wxImage *arg1 = (wxImage *) 0 ;
12231 wxRect *arg2 = 0 ;
12232 SwigValueWrapper<wxImage > result;
12233 wxRect temp2 ;
12234 PyObject * obj0 = 0 ;
12235 PyObject * obj1 = 0 ;
12236 char *kwnames[] = {
12237 (char *) "self",(char *) "rect", NULL
12238 };
12239
12240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12242 if (SWIG_arg_fail(1)) SWIG_fail;
12243 {
12244 arg2 = &temp2;
12245 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12246 }
12247 {
12248 PyThreadState* __tstate = wxPyBeginAllowThreads();
12249 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12250
12251 wxPyEndAllowThreads(__tstate);
12252 if (PyErr_Occurred()) SWIG_fail;
12253 }
12254 {
12255 wxImage * resultptr;
12256 resultptr = new wxImage((wxImage &)(result));
12257 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12258 }
12259 return resultobj;
12260 fail:
12261 return NULL;
12262 }
12263
12264
12265 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12266 PyObject *resultobj;
12267 wxImage *arg1 = (wxImage *) 0 ;
12268 wxSize *arg2 = 0 ;
12269 wxPoint *arg3 = 0 ;
12270 int arg4 = (int) -1 ;
12271 int arg5 = (int) -1 ;
12272 int arg6 = (int) -1 ;
12273 SwigValueWrapper<wxImage > result;
12274 wxSize temp2 ;
12275 wxPoint temp3 ;
12276 PyObject * obj0 = 0 ;
12277 PyObject * obj1 = 0 ;
12278 PyObject * obj2 = 0 ;
12279 PyObject * obj3 = 0 ;
12280 PyObject * obj4 = 0 ;
12281 PyObject * obj5 = 0 ;
12282 char *kwnames[] = {
12283 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12284 };
12285
12286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12288 if (SWIG_arg_fail(1)) SWIG_fail;
12289 {
12290 arg2 = &temp2;
12291 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12292 }
12293 {
12294 arg3 = &temp3;
12295 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12296 }
12297 if (obj3) {
12298 {
12299 arg4 = (int)(SWIG_As_int(obj3));
12300 if (SWIG_arg_fail(4)) SWIG_fail;
12301 }
12302 }
12303 if (obj4) {
12304 {
12305 arg5 = (int)(SWIG_As_int(obj4));
12306 if (SWIG_arg_fail(5)) SWIG_fail;
12307 }
12308 }
12309 if (obj5) {
12310 {
12311 arg6 = (int)(SWIG_As_int(obj5));
12312 if (SWIG_arg_fail(6)) SWIG_fail;
12313 }
12314 }
12315 {
12316 PyThreadState* __tstate = wxPyBeginAllowThreads();
12317 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12318
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 {
12323 wxImage * resultptr;
12324 resultptr = new wxImage((wxImage &)(result));
12325 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12326 }
12327 return resultobj;
12328 fail:
12329 return NULL;
12330 }
12331
12332
12333 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12334 PyObject *resultobj;
12335 wxImage *arg1 = (wxImage *) 0 ;
12336 SwigValueWrapper<wxImage > result;
12337 PyObject * obj0 = 0 ;
12338 char *kwnames[] = {
12339 (char *) "self", NULL
12340 };
12341
12342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12344 if (SWIG_arg_fail(1)) SWIG_fail;
12345 {
12346 PyThreadState* __tstate = wxPyBeginAllowThreads();
12347 result = (arg1)->Copy();
12348
12349 wxPyEndAllowThreads(__tstate);
12350 if (PyErr_Occurred()) SWIG_fail;
12351 }
12352 {
12353 wxImage * resultptr;
12354 resultptr = new wxImage((wxImage &)(result));
12355 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12356 }
12357 return resultobj;
12358 fail:
12359 return NULL;
12360 }
12361
12362
12363 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12364 PyObject *resultobj;
12365 wxImage *arg1 = (wxImage *) 0 ;
12366 wxImage *arg2 = 0 ;
12367 int arg3 ;
12368 int arg4 ;
12369 PyObject * obj0 = 0 ;
12370 PyObject * obj1 = 0 ;
12371 PyObject * obj2 = 0 ;
12372 PyObject * obj3 = 0 ;
12373 char *kwnames[] = {
12374 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12375 };
12376
12377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12379 if (SWIG_arg_fail(1)) SWIG_fail;
12380 {
12381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12382 if (SWIG_arg_fail(2)) SWIG_fail;
12383 if (arg2 == NULL) {
12384 SWIG_null_ref("wxImage");
12385 }
12386 if (SWIG_arg_fail(2)) SWIG_fail;
12387 }
12388 {
12389 arg3 = (int)(SWIG_As_int(obj2));
12390 if (SWIG_arg_fail(3)) SWIG_fail;
12391 }
12392 {
12393 arg4 = (int)(SWIG_As_int(obj3));
12394 if (SWIG_arg_fail(4)) SWIG_fail;
12395 }
12396 {
12397 PyThreadState* __tstate = wxPyBeginAllowThreads();
12398 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12399
12400 wxPyEndAllowThreads(__tstate);
12401 if (PyErr_Occurred()) SWIG_fail;
12402 }
12403 Py_INCREF(Py_None); resultobj = Py_None;
12404 return resultobj;
12405 fail:
12406 return NULL;
12407 }
12408
12409
12410 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12411 PyObject *resultobj;
12412 wxImage *arg1 = (wxImage *) 0 ;
12413 PyObject *result;
12414 PyObject * obj0 = 0 ;
12415 char *kwnames[] = {
12416 (char *) "self", NULL
12417 };
12418
12419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12421 if (SWIG_arg_fail(1)) SWIG_fail;
12422 {
12423 PyThreadState* __tstate = wxPyBeginAllowThreads();
12424 result = (PyObject *)wxImage_GetData(arg1);
12425
12426 wxPyEndAllowThreads(__tstate);
12427 if (PyErr_Occurred()) SWIG_fail;
12428 }
12429 resultobj = result;
12430 return resultobj;
12431 fail:
12432 return NULL;
12433 }
12434
12435
12436 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12437 PyObject *resultobj;
12438 wxImage *arg1 = (wxImage *) 0 ;
12439 PyObject *arg2 = (PyObject *) 0 ;
12440 PyObject * obj0 = 0 ;
12441 PyObject * obj1 = 0 ;
12442 char *kwnames[] = {
12443 (char *) "self",(char *) "data", NULL
12444 };
12445
12446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12448 if (SWIG_arg_fail(1)) SWIG_fail;
12449 arg2 = obj1;
12450 {
12451 PyThreadState* __tstate = wxPyBeginAllowThreads();
12452 wxImage_SetData(arg1,arg2);
12453
12454 wxPyEndAllowThreads(__tstate);
12455 if (PyErr_Occurred()) SWIG_fail;
12456 }
12457 Py_INCREF(Py_None); resultobj = Py_None;
12458 return resultobj;
12459 fail:
12460 return NULL;
12461 }
12462
12463
12464 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12465 PyObject *resultobj;
12466 wxImage *arg1 = (wxImage *) 0 ;
12467 PyObject *result;
12468 PyObject * obj0 = 0 ;
12469 char *kwnames[] = {
12470 (char *) "self", NULL
12471 };
12472
12473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12475 if (SWIG_arg_fail(1)) SWIG_fail;
12476 {
12477 PyThreadState* __tstate = wxPyBeginAllowThreads();
12478 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12479
12480 wxPyEndAllowThreads(__tstate);
12481 if (PyErr_Occurred()) SWIG_fail;
12482 }
12483 resultobj = result;
12484 return resultobj;
12485 fail:
12486 return NULL;
12487 }
12488
12489
12490 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12491 PyObject *resultobj;
12492 wxImage *arg1 = (wxImage *) 0 ;
12493 PyObject *arg2 = (PyObject *) 0 ;
12494 PyObject * obj0 = 0 ;
12495 PyObject * obj1 = 0 ;
12496 char *kwnames[] = {
12497 (char *) "self",(char *) "data", NULL
12498 };
12499
12500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12502 if (SWIG_arg_fail(1)) SWIG_fail;
12503 arg2 = obj1;
12504 {
12505 PyThreadState* __tstate = wxPyBeginAllowThreads();
12506 wxImage_SetDataBuffer(arg1,arg2);
12507
12508 wxPyEndAllowThreads(__tstate);
12509 if (PyErr_Occurred()) SWIG_fail;
12510 }
12511 Py_INCREF(Py_None); resultobj = Py_None;
12512 return resultobj;
12513 fail:
12514 return NULL;
12515 }
12516
12517
12518 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12519 PyObject *resultobj;
12520 wxImage *arg1 = (wxImage *) 0 ;
12521 PyObject *result;
12522 PyObject * obj0 = 0 ;
12523 char *kwnames[] = {
12524 (char *) "self", NULL
12525 };
12526
12527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12529 if (SWIG_arg_fail(1)) SWIG_fail;
12530 {
12531 PyThreadState* __tstate = wxPyBeginAllowThreads();
12532 result = (PyObject *)wxImage_GetAlphaData(arg1);
12533
12534 wxPyEndAllowThreads(__tstate);
12535 if (PyErr_Occurred()) SWIG_fail;
12536 }
12537 resultobj = result;
12538 return resultobj;
12539 fail:
12540 return NULL;
12541 }
12542
12543
12544 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12545 PyObject *resultobj;
12546 wxImage *arg1 = (wxImage *) 0 ;
12547 PyObject *arg2 = (PyObject *) 0 ;
12548 PyObject * obj0 = 0 ;
12549 PyObject * obj1 = 0 ;
12550 char *kwnames[] = {
12551 (char *) "self",(char *) "data", NULL
12552 };
12553
12554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12556 if (SWIG_arg_fail(1)) SWIG_fail;
12557 arg2 = obj1;
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 wxImage_SetAlphaData(arg1,arg2);
12561
12562 wxPyEndAllowThreads(__tstate);
12563 if (PyErr_Occurred()) SWIG_fail;
12564 }
12565 Py_INCREF(Py_None); resultobj = Py_None;
12566 return resultobj;
12567 fail:
12568 return NULL;
12569 }
12570
12571
12572 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12573 PyObject *resultobj;
12574 wxImage *arg1 = (wxImage *) 0 ;
12575 PyObject *result;
12576 PyObject * obj0 = 0 ;
12577 char *kwnames[] = {
12578 (char *) "self", NULL
12579 };
12580
12581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12583 if (SWIG_arg_fail(1)) SWIG_fail;
12584 {
12585 PyThreadState* __tstate = wxPyBeginAllowThreads();
12586 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12587
12588 wxPyEndAllowThreads(__tstate);
12589 if (PyErr_Occurred()) SWIG_fail;
12590 }
12591 resultobj = result;
12592 return resultobj;
12593 fail:
12594 return NULL;
12595 }
12596
12597
12598 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12599 PyObject *resultobj;
12600 wxImage *arg1 = (wxImage *) 0 ;
12601 PyObject *arg2 = (PyObject *) 0 ;
12602 PyObject * obj0 = 0 ;
12603 PyObject * obj1 = 0 ;
12604 char *kwnames[] = {
12605 (char *) "self",(char *) "data", NULL
12606 };
12607
12608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12610 if (SWIG_arg_fail(1)) SWIG_fail;
12611 arg2 = obj1;
12612 {
12613 PyThreadState* __tstate = wxPyBeginAllowThreads();
12614 wxImage_SetAlphaBuffer(arg1,arg2);
12615
12616 wxPyEndAllowThreads(__tstate);
12617 if (PyErr_Occurred()) SWIG_fail;
12618 }
12619 Py_INCREF(Py_None); resultobj = Py_None;
12620 return resultobj;
12621 fail:
12622 return NULL;
12623 }
12624
12625
12626 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12627 PyObject *resultobj;
12628 wxImage *arg1 = (wxImage *) 0 ;
12629 unsigned char arg2 ;
12630 unsigned char arg3 ;
12631 unsigned char arg4 ;
12632 PyObject * obj0 = 0 ;
12633 PyObject * obj1 = 0 ;
12634 PyObject * obj2 = 0 ;
12635 PyObject * obj3 = 0 ;
12636 char *kwnames[] = {
12637 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12638 };
12639
12640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12642 if (SWIG_arg_fail(1)) SWIG_fail;
12643 {
12644 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12645 if (SWIG_arg_fail(2)) SWIG_fail;
12646 }
12647 {
12648 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12649 if (SWIG_arg_fail(3)) SWIG_fail;
12650 }
12651 {
12652 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12653 if (SWIG_arg_fail(4)) SWIG_fail;
12654 }
12655 {
12656 PyThreadState* __tstate = wxPyBeginAllowThreads();
12657 (arg1)->SetMaskColour(arg2,arg3,arg4);
12658
12659 wxPyEndAllowThreads(__tstate);
12660 if (PyErr_Occurred()) SWIG_fail;
12661 }
12662 Py_INCREF(Py_None); resultobj = Py_None;
12663 return resultobj;
12664 fail:
12665 return NULL;
12666 }
12667
12668
12669 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12670 PyObject *resultobj;
12671 wxImage *arg1 = (wxImage *) 0 ;
12672 unsigned char *arg2 = (unsigned char *) 0 ;
12673 unsigned char *arg3 = (unsigned char *) 0 ;
12674 unsigned char *arg4 = (unsigned char *) 0 ;
12675 unsigned char temp2 ;
12676 int res2 = 0 ;
12677 unsigned char temp3 ;
12678 int res3 = 0 ;
12679 unsigned char temp4 ;
12680 int res4 = 0 ;
12681 PyObject * obj0 = 0 ;
12682 char *kwnames[] = {
12683 (char *) "self", NULL
12684 };
12685
12686 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12687 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12688 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) 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 {
12693 PyThreadState* __tstate = wxPyBeginAllowThreads();
12694 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12695
12696 wxPyEndAllowThreads(__tstate);
12697 if (PyErr_Occurred()) SWIG_fail;
12698 }
12699 Py_INCREF(Py_None); resultobj = Py_None;
12700 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12701 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12702 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12703 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12704 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12705 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12706 return resultobj;
12707 fail:
12708 return NULL;
12709 }
12710
12711
12712 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12713 PyObject *resultobj;
12714 wxImage *arg1 = (wxImage *) 0 ;
12715 unsigned char result;
12716 PyObject * obj0 = 0 ;
12717 char *kwnames[] = {
12718 (char *) "self", NULL
12719 };
12720
12721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12723 if (SWIG_arg_fail(1)) SWIG_fail;
12724 {
12725 PyThreadState* __tstate = wxPyBeginAllowThreads();
12726 result = (unsigned char)(arg1)->GetMaskRed();
12727
12728 wxPyEndAllowThreads(__tstate);
12729 if (PyErr_Occurred()) SWIG_fail;
12730 }
12731 {
12732 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12733 }
12734 return resultobj;
12735 fail:
12736 return NULL;
12737 }
12738
12739
12740 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12741 PyObject *resultobj;
12742 wxImage *arg1 = (wxImage *) 0 ;
12743 unsigned char result;
12744 PyObject * obj0 = 0 ;
12745 char *kwnames[] = {
12746 (char *) "self", NULL
12747 };
12748
12749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12751 if (SWIG_arg_fail(1)) SWIG_fail;
12752 {
12753 PyThreadState* __tstate = wxPyBeginAllowThreads();
12754 result = (unsigned char)(arg1)->GetMaskGreen();
12755
12756 wxPyEndAllowThreads(__tstate);
12757 if (PyErr_Occurred()) SWIG_fail;
12758 }
12759 {
12760 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12761 }
12762 return resultobj;
12763 fail:
12764 return NULL;
12765 }
12766
12767
12768 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12769 PyObject *resultobj;
12770 wxImage *arg1 = (wxImage *) 0 ;
12771 unsigned char result;
12772 PyObject * obj0 = 0 ;
12773 char *kwnames[] = {
12774 (char *) "self", NULL
12775 };
12776
12777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12779 if (SWIG_arg_fail(1)) SWIG_fail;
12780 {
12781 PyThreadState* __tstate = wxPyBeginAllowThreads();
12782 result = (unsigned char)(arg1)->GetMaskBlue();
12783
12784 wxPyEndAllowThreads(__tstate);
12785 if (PyErr_Occurred()) SWIG_fail;
12786 }
12787 {
12788 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12789 }
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12797 PyObject *resultobj;
12798 wxImage *arg1 = (wxImage *) 0 ;
12799 bool arg2 = (bool) true ;
12800 PyObject * obj0 = 0 ;
12801 PyObject * obj1 = 0 ;
12802 char *kwnames[] = {
12803 (char *) "self",(char *) "mask", NULL
12804 };
12805
12806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12808 if (SWIG_arg_fail(1)) SWIG_fail;
12809 if (obj1) {
12810 {
12811 arg2 = (bool)(SWIG_As_bool(obj1));
12812 if (SWIG_arg_fail(2)) SWIG_fail;
12813 }
12814 }
12815 {
12816 PyThreadState* __tstate = wxPyBeginAllowThreads();
12817 (arg1)->SetMask(arg2);
12818
12819 wxPyEndAllowThreads(__tstate);
12820 if (PyErr_Occurred()) SWIG_fail;
12821 }
12822 Py_INCREF(Py_None); resultobj = Py_None;
12823 return resultobj;
12824 fail:
12825 return NULL;
12826 }
12827
12828
12829 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12830 PyObject *resultobj;
12831 wxImage *arg1 = (wxImage *) 0 ;
12832 bool result;
12833 PyObject * obj0 = 0 ;
12834 char *kwnames[] = {
12835 (char *) "self", NULL
12836 };
12837
12838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12840 if (SWIG_arg_fail(1)) SWIG_fail;
12841 {
12842 PyThreadState* __tstate = wxPyBeginAllowThreads();
12843 result = (bool)(arg1)->HasMask();
12844
12845 wxPyEndAllowThreads(__tstate);
12846 if (PyErr_Occurred()) SWIG_fail;
12847 }
12848 {
12849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12850 }
12851 return resultobj;
12852 fail:
12853 return NULL;
12854 }
12855
12856
12857 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12858 PyObject *resultobj;
12859 wxImage *arg1 = (wxImage *) 0 ;
12860 double arg2 ;
12861 wxPoint *arg3 = 0 ;
12862 bool arg4 = (bool) true ;
12863 wxPoint *arg5 = (wxPoint *) NULL ;
12864 SwigValueWrapper<wxImage > result;
12865 wxPoint temp3 ;
12866 PyObject * obj0 = 0 ;
12867 PyObject * obj1 = 0 ;
12868 PyObject * obj2 = 0 ;
12869 PyObject * obj3 = 0 ;
12870 PyObject * obj4 = 0 ;
12871 char *kwnames[] = {
12872 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12873 };
12874
12875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12877 if (SWIG_arg_fail(1)) SWIG_fail;
12878 {
12879 arg2 = (double)(SWIG_As_double(obj1));
12880 if (SWIG_arg_fail(2)) SWIG_fail;
12881 }
12882 {
12883 arg3 = &temp3;
12884 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12885 }
12886 if (obj3) {
12887 {
12888 arg4 = (bool)(SWIG_As_bool(obj3));
12889 if (SWIG_arg_fail(4)) SWIG_fail;
12890 }
12891 }
12892 if (obj4) {
12893 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12894 if (SWIG_arg_fail(5)) SWIG_fail;
12895 }
12896 {
12897 PyThreadState* __tstate = wxPyBeginAllowThreads();
12898 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12899
12900 wxPyEndAllowThreads(__tstate);
12901 if (PyErr_Occurred()) SWIG_fail;
12902 }
12903 {
12904 wxImage * resultptr;
12905 resultptr = new wxImage((wxImage &)(result));
12906 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12907 }
12908 return resultobj;
12909 fail:
12910 return NULL;
12911 }
12912
12913
12914 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12915 PyObject *resultobj;
12916 wxImage *arg1 = (wxImage *) 0 ;
12917 bool arg2 = (bool) true ;
12918 SwigValueWrapper<wxImage > result;
12919 PyObject * obj0 = 0 ;
12920 PyObject * obj1 = 0 ;
12921 char *kwnames[] = {
12922 (char *) "self",(char *) "clockwise", NULL
12923 };
12924
12925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12927 if (SWIG_arg_fail(1)) SWIG_fail;
12928 if (obj1) {
12929 {
12930 arg2 = (bool)(SWIG_As_bool(obj1));
12931 if (SWIG_arg_fail(2)) SWIG_fail;
12932 }
12933 }
12934 {
12935 PyThreadState* __tstate = wxPyBeginAllowThreads();
12936 result = (arg1)->Rotate90(arg2);
12937
12938 wxPyEndAllowThreads(__tstate);
12939 if (PyErr_Occurred()) SWIG_fail;
12940 }
12941 {
12942 wxImage * resultptr;
12943 resultptr = new wxImage((wxImage &)(result));
12944 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12945 }
12946 return resultobj;
12947 fail:
12948 return NULL;
12949 }
12950
12951
12952 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12953 PyObject *resultobj;
12954 wxImage *arg1 = (wxImage *) 0 ;
12955 bool arg2 = (bool) true ;
12956 SwigValueWrapper<wxImage > result;
12957 PyObject * obj0 = 0 ;
12958 PyObject * obj1 = 0 ;
12959 char *kwnames[] = {
12960 (char *) "self",(char *) "horizontally", NULL
12961 };
12962
12963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12965 if (SWIG_arg_fail(1)) SWIG_fail;
12966 if (obj1) {
12967 {
12968 arg2 = (bool)(SWIG_As_bool(obj1));
12969 if (SWIG_arg_fail(2)) SWIG_fail;
12970 }
12971 }
12972 {
12973 PyThreadState* __tstate = wxPyBeginAllowThreads();
12974 result = (arg1)->Mirror(arg2);
12975
12976 wxPyEndAllowThreads(__tstate);
12977 if (PyErr_Occurred()) SWIG_fail;
12978 }
12979 {
12980 wxImage * resultptr;
12981 resultptr = new wxImage((wxImage &)(result));
12982 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12983 }
12984 return resultobj;
12985 fail:
12986 return NULL;
12987 }
12988
12989
12990 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12991 PyObject *resultobj;
12992 wxImage *arg1 = (wxImage *) 0 ;
12993 unsigned char arg2 ;
12994 unsigned char arg3 ;
12995 unsigned char arg4 ;
12996 unsigned char arg5 ;
12997 unsigned char arg6 ;
12998 unsigned char arg7 ;
12999 PyObject * obj0 = 0 ;
13000 PyObject * obj1 = 0 ;
13001 PyObject * obj2 = 0 ;
13002 PyObject * obj3 = 0 ;
13003 PyObject * obj4 = 0 ;
13004 PyObject * obj5 = 0 ;
13005 PyObject * obj6 = 0 ;
13006 char *kwnames[] = {
13007 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13008 };
13009
13010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13012 if (SWIG_arg_fail(1)) SWIG_fail;
13013 {
13014 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13015 if (SWIG_arg_fail(2)) SWIG_fail;
13016 }
13017 {
13018 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13019 if (SWIG_arg_fail(3)) SWIG_fail;
13020 }
13021 {
13022 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13023 if (SWIG_arg_fail(4)) SWIG_fail;
13024 }
13025 {
13026 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13027 if (SWIG_arg_fail(5)) SWIG_fail;
13028 }
13029 {
13030 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13031 if (SWIG_arg_fail(6)) SWIG_fail;
13032 }
13033 {
13034 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13035 if (SWIG_arg_fail(7)) SWIG_fail;
13036 }
13037 {
13038 PyThreadState* __tstate = wxPyBeginAllowThreads();
13039 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13040
13041 wxPyEndAllowThreads(__tstate);
13042 if (PyErr_Occurred()) SWIG_fail;
13043 }
13044 Py_INCREF(Py_None); resultobj = Py_None;
13045 return resultobj;
13046 fail:
13047 return NULL;
13048 }
13049
13050
13051 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13052 PyObject *resultobj;
13053 wxImage *arg1 = (wxImage *) 0 ;
13054 unsigned char arg2 ;
13055 unsigned char arg3 ;
13056 unsigned char arg4 ;
13057 SwigValueWrapper<wxImage > result;
13058 PyObject * obj0 = 0 ;
13059 PyObject * obj1 = 0 ;
13060 PyObject * obj2 = 0 ;
13061 PyObject * obj3 = 0 ;
13062 char *kwnames[] = {
13063 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13064 };
13065
13066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13068 if (SWIG_arg_fail(1)) SWIG_fail;
13069 {
13070 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13071 if (SWIG_arg_fail(2)) SWIG_fail;
13072 }
13073 {
13074 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13075 if (SWIG_arg_fail(3)) SWIG_fail;
13076 }
13077 {
13078 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13079 if (SWIG_arg_fail(4)) SWIG_fail;
13080 }
13081 {
13082 PyThreadState* __tstate = wxPyBeginAllowThreads();
13083 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13084
13085 wxPyEndAllowThreads(__tstate);
13086 if (PyErr_Occurred()) SWIG_fail;
13087 }
13088 {
13089 wxImage * resultptr;
13090 resultptr = new wxImage((wxImage &)(result));
13091 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13092 }
13093 return resultobj;
13094 fail:
13095 return NULL;
13096 }
13097
13098
13099 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13100 PyObject *resultobj;
13101 wxImage *arg1 = (wxImage *) 0 ;
13102 wxString *arg2 = 0 ;
13103 wxString *arg3 = 0 ;
13104 bool temp2 = false ;
13105 bool temp3 = false ;
13106 PyObject * obj0 = 0 ;
13107 PyObject * obj1 = 0 ;
13108 PyObject * obj2 = 0 ;
13109 char *kwnames[] = {
13110 (char *) "self",(char *) "name",(char *) "value", NULL
13111 };
13112
13113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13115 if (SWIG_arg_fail(1)) SWIG_fail;
13116 {
13117 arg2 = wxString_in_helper(obj1);
13118 if (arg2 == NULL) SWIG_fail;
13119 temp2 = true;
13120 }
13121 {
13122 arg3 = wxString_in_helper(obj2);
13123 if (arg3 == NULL) SWIG_fail;
13124 temp3 = true;
13125 }
13126 {
13127 PyThreadState* __tstate = wxPyBeginAllowThreads();
13128 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13129
13130 wxPyEndAllowThreads(__tstate);
13131 if (PyErr_Occurred()) SWIG_fail;
13132 }
13133 Py_INCREF(Py_None); resultobj = Py_None;
13134 {
13135 if (temp2)
13136 delete arg2;
13137 }
13138 {
13139 if (temp3)
13140 delete arg3;
13141 }
13142 return resultobj;
13143 fail:
13144 {
13145 if (temp2)
13146 delete arg2;
13147 }
13148 {
13149 if (temp3)
13150 delete arg3;
13151 }
13152 return NULL;
13153 }
13154
13155
13156 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13157 PyObject *resultobj;
13158 wxImage *arg1 = (wxImage *) 0 ;
13159 wxString *arg2 = 0 ;
13160 int arg3 ;
13161 bool temp2 = false ;
13162 PyObject * obj0 = 0 ;
13163 PyObject * obj1 = 0 ;
13164 PyObject * obj2 = 0 ;
13165 char *kwnames[] = {
13166 (char *) "self",(char *) "name",(char *) "value", NULL
13167 };
13168
13169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13171 if (SWIG_arg_fail(1)) SWIG_fail;
13172 {
13173 arg2 = wxString_in_helper(obj1);
13174 if (arg2 == NULL) SWIG_fail;
13175 temp2 = true;
13176 }
13177 {
13178 arg3 = (int)(SWIG_As_int(obj2));
13179 if (SWIG_arg_fail(3)) SWIG_fail;
13180 }
13181 {
13182 PyThreadState* __tstate = wxPyBeginAllowThreads();
13183 (arg1)->SetOption((wxString const &)*arg2,arg3);
13184
13185 wxPyEndAllowThreads(__tstate);
13186 if (PyErr_Occurred()) SWIG_fail;
13187 }
13188 Py_INCREF(Py_None); resultobj = Py_None;
13189 {
13190 if (temp2)
13191 delete arg2;
13192 }
13193 return resultobj;
13194 fail:
13195 {
13196 if (temp2)
13197 delete arg2;
13198 }
13199 return NULL;
13200 }
13201
13202
13203 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13204 PyObject *resultobj;
13205 wxImage *arg1 = (wxImage *) 0 ;
13206 wxString *arg2 = 0 ;
13207 wxString result;
13208 bool temp2 = false ;
13209 PyObject * obj0 = 0 ;
13210 PyObject * obj1 = 0 ;
13211 char *kwnames[] = {
13212 (char *) "self",(char *) "name", NULL
13213 };
13214
13215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13217 if (SWIG_arg_fail(1)) SWIG_fail;
13218 {
13219 arg2 = wxString_in_helper(obj1);
13220 if (arg2 == NULL) SWIG_fail;
13221 temp2 = true;
13222 }
13223 {
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13226
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 {
13231 #if wxUSE_UNICODE
13232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13233 #else
13234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13235 #endif
13236 }
13237 {
13238 if (temp2)
13239 delete arg2;
13240 }
13241 return resultobj;
13242 fail:
13243 {
13244 if (temp2)
13245 delete arg2;
13246 }
13247 return NULL;
13248 }
13249
13250
13251 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13252 PyObject *resultobj;
13253 wxImage *arg1 = (wxImage *) 0 ;
13254 wxString *arg2 = 0 ;
13255 int result;
13256 bool temp2 = false ;
13257 PyObject * obj0 = 0 ;
13258 PyObject * obj1 = 0 ;
13259 char *kwnames[] = {
13260 (char *) "self",(char *) "name", NULL
13261 };
13262
13263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13265 if (SWIG_arg_fail(1)) SWIG_fail;
13266 {
13267 arg2 = wxString_in_helper(obj1);
13268 if (arg2 == NULL) SWIG_fail;
13269 temp2 = true;
13270 }
13271 {
13272 PyThreadState* __tstate = wxPyBeginAllowThreads();
13273 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13274
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 {
13279 resultobj = SWIG_From_int((int)(result));
13280 }
13281 {
13282 if (temp2)
13283 delete arg2;
13284 }
13285 return resultobj;
13286 fail:
13287 {
13288 if (temp2)
13289 delete arg2;
13290 }
13291 return NULL;
13292 }
13293
13294
13295 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13296 PyObject *resultobj;
13297 wxImage *arg1 = (wxImage *) 0 ;
13298 wxString *arg2 = 0 ;
13299 bool result;
13300 bool temp2 = false ;
13301 PyObject * obj0 = 0 ;
13302 PyObject * obj1 = 0 ;
13303 char *kwnames[] = {
13304 (char *) "self",(char *) "name", NULL
13305 };
13306
13307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13309 if (SWIG_arg_fail(1)) SWIG_fail;
13310 {
13311 arg2 = wxString_in_helper(obj1);
13312 if (arg2 == NULL) SWIG_fail;
13313 temp2 = true;
13314 }
13315 {
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13318
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 {
13323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13324 }
13325 {
13326 if (temp2)
13327 delete arg2;
13328 }
13329 return resultobj;
13330 fail:
13331 {
13332 if (temp2)
13333 delete arg2;
13334 }
13335 return NULL;
13336 }
13337
13338
13339 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13340 PyObject *resultobj;
13341 wxImage *arg1 = (wxImage *) 0 ;
13342 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13343 unsigned long result;
13344 PyObject * obj0 = 0 ;
13345 PyObject * obj1 = 0 ;
13346 char *kwnames[] = {
13347 (char *) "self",(char *) "stopafter", NULL
13348 };
13349
13350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13352 if (SWIG_arg_fail(1)) SWIG_fail;
13353 if (obj1) {
13354 {
13355 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13356 if (SWIG_arg_fail(2)) SWIG_fail;
13357 }
13358 }
13359 {
13360 PyThreadState* __tstate = wxPyBeginAllowThreads();
13361 result = (unsigned long)(arg1)->CountColours(arg2);
13362
13363 wxPyEndAllowThreads(__tstate);
13364 if (PyErr_Occurred()) SWIG_fail;
13365 }
13366 {
13367 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13368 }
13369 return resultobj;
13370 fail:
13371 return NULL;
13372 }
13373
13374
13375 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13376 PyObject *resultobj;
13377 wxImage *arg1 = (wxImage *) 0 ;
13378 wxImageHistogram *arg2 = 0 ;
13379 unsigned long result;
13380 PyObject * obj0 = 0 ;
13381 PyObject * obj1 = 0 ;
13382 char *kwnames[] = {
13383 (char *) "self",(char *) "h", NULL
13384 };
13385
13386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13388 if (SWIG_arg_fail(1)) SWIG_fail;
13389 {
13390 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13391 if (SWIG_arg_fail(2)) SWIG_fail;
13392 if (arg2 == NULL) {
13393 SWIG_null_ref("wxImageHistogram");
13394 }
13395 if (SWIG_arg_fail(2)) SWIG_fail;
13396 }
13397 {
13398 PyThreadState* __tstate = wxPyBeginAllowThreads();
13399 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13400
13401 wxPyEndAllowThreads(__tstate);
13402 if (PyErr_Occurred()) SWIG_fail;
13403 }
13404 {
13405 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13406 }
13407 return resultobj;
13408 fail:
13409 return NULL;
13410 }
13411
13412
13413 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13414 PyObject *resultobj;
13415 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13416 PyObject * obj0 = 0 ;
13417 char *kwnames[] = {
13418 (char *) "handler", NULL
13419 };
13420
13421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13423 if (SWIG_arg_fail(1)) SWIG_fail;
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 wxImage::AddHandler(arg1);
13427
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 Py_INCREF(Py_None); resultobj = Py_None;
13432 return resultobj;
13433 fail:
13434 return NULL;
13435 }
13436
13437
13438 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13439 PyObject *resultobj;
13440 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13441 PyObject * obj0 = 0 ;
13442 char *kwnames[] = {
13443 (char *) "handler", NULL
13444 };
13445
13446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13448 if (SWIG_arg_fail(1)) SWIG_fail;
13449 {
13450 PyThreadState* __tstate = wxPyBeginAllowThreads();
13451 wxImage::InsertHandler(arg1);
13452
13453 wxPyEndAllowThreads(__tstate);
13454 if (PyErr_Occurred()) SWIG_fail;
13455 }
13456 Py_INCREF(Py_None); resultobj = Py_None;
13457 return resultobj;
13458 fail:
13459 return NULL;
13460 }
13461
13462
13463 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13464 PyObject *resultobj;
13465 wxString *arg1 = 0 ;
13466 bool result;
13467 bool temp1 = false ;
13468 PyObject * obj0 = 0 ;
13469 char *kwnames[] = {
13470 (char *) "name", NULL
13471 };
13472
13473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13474 {
13475 arg1 = wxString_in_helper(obj0);
13476 if (arg1 == NULL) SWIG_fail;
13477 temp1 = true;
13478 }
13479 {
13480 PyThreadState* __tstate = wxPyBeginAllowThreads();
13481 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13482
13483 wxPyEndAllowThreads(__tstate);
13484 if (PyErr_Occurred()) SWIG_fail;
13485 }
13486 {
13487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13488 }
13489 {
13490 if (temp1)
13491 delete arg1;
13492 }
13493 return resultobj;
13494 fail:
13495 {
13496 if (temp1)
13497 delete arg1;
13498 }
13499 return NULL;
13500 }
13501
13502
13503 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13504 PyObject *resultobj;
13505 wxString result;
13506 char *kwnames[] = {
13507 NULL
13508 };
13509
13510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13511 {
13512 PyThreadState* __tstate = wxPyBeginAllowThreads();
13513 result = wxImage::GetImageExtWildcard();
13514
13515 wxPyEndAllowThreads(__tstate);
13516 if (PyErr_Occurred()) SWIG_fail;
13517 }
13518 {
13519 #if wxUSE_UNICODE
13520 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13521 #else
13522 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13523 #endif
13524 }
13525 return resultobj;
13526 fail:
13527 return NULL;
13528 }
13529
13530
13531 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13532 PyObject *resultobj;
13533 wxImage *arg1 = (wxImage *) 0 ;
13534 int arg2 = (int) -1 ;
13535 wxBitmap result;
13536 PyObject * obj0 = 0 ;
13537 PyObject * obj1 = 0 ;
13538 char *kwnames[] = {
13539 (char *) "self",(char *) "depth", NULL
13540 };
13541
13542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13544 if (SWIG_arg_fail(1)) SWIG_fail;
13545 if (obj1) {
13546 {
13547 arg2 = (int)(SWIG_As_int(obj1));
13548 if (SWIG_arg_fail(2)) SWIG_fail;
13549 }
13550 }
13551 {
13552 if (!wxPyCheckForApp()) SWIG_fail;
13553 PyThreadState* __tstate = wxPyBeginAllowThreads();
13554 result = wxImage_ConvertToBitmap(arg1,arg2);
13555
13556 wxPyEndAllowThreads(__tstate);
13557 if (PyErr_Occurred()) SWIG_fail;
13558 }
13559 {
13560 wxBitmap * resultptr;
13561 resultptr = new wxBitmap((wxBitmap &)(result));
13562 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13563 }
13564 return resultobj;
13565 fail:
13566 return NULL;
13567 }
13568
13569
13570 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13571 PyObject *resultobj;
13572 wxImage *arg1 = (wxImage *) 0 ;
13573 unsigned char arg2 ;
13574 unsigned char arg3 ;
13575 unsigned char arg4 ;
13576 wxBitmap result;
13577 PyObject * obj0 = 0 ;
13578 PyObject * obj1 = 0 ;
13579 PyObject * obj2 = 0 ;
13580 PyObject * obj3 = 0 ;
13581 char *kwnames[] = {
13582 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13583 };
13584
13585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13587 if (SWIG_arg_fail(1)) SWIG_fail;
13588 {
13589 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13590 if (SWIG_arg_fail(2)) SWIG_fail;
13591 }
13592 {
13593 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13594 if (SWIG_arg_fail(3)) SWIG_fail;
13595 }
13596 {
13597 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13598 if (SWIG_arg_fail(4)) SWIG_fail;
13599 }
13600 {
13601 if (!wxPyCheckForApp()) SWIG_fail;
13602 PyThreadState* __tstate = wxPyBeginAllowThreads();
13603 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13604
13605 wxPyEndAllowThreads(__tstate);
13606 if (PyErr_Occurred()) SWIG_fail;
13607 }
13608 {
13609 wxBitmap * resultptr;
13610 resultptr = new wxBitmap((wxBitmap &)(result));
13611 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13612 }
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13620 PyObject *obj;
13621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13622 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13623 Py_INCREF(obj);
13624 return Py_BuildValue((char *)"");
13625 }
13626 static int _wrap_NullImage_set(PyObject *) {
13627 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13628 return 1;
13629 }
13630
13631
13632 static PyObject *_wrap_NullImage_get(void) {
13633 PyObject *pyobj;
13634
13635 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13636 return pyobj;
13637 }
13638
13639
13640 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13641 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13642 return 1;
13643 }
13644
13645
13646 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13647 PyObject *pyobj;
13648
13649 {
13650 #if wxUSE_UNICODE
13651 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13652 #else
13653 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13654 #endif
13655 }
13656 return pyobj;
13657 }
13658
13659
13660 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13661 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13662 return 1;
13663 }
13664
13665
13666 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13667 PyObject *pyobj;
13668
13669 {
13670 #if wxUSE_UNICODE
13671 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13672 #else
13673 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13674 #endif
13675 }
13676 return pyobj;
13677 }
13678
13679
13680 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13681 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13682 return 1;
13683 }
13684
13685
13686 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13687 PyObject *pyobj;
13688
13689 {
13690 #if wxUSE_UNICODE
13691 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13692 #else
13693 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13694 #endif
13695 }
13696 return pyobj;
13697 }
13698
13699
13700 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13701 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13702 return 1;
13703 }
13704
13705
13706 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13707 PyObject *pyobj;
13708
13709 {
13710 #if wxUSE_UNICODE
13711 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13712 #else
13713 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13714 #endif
13715 }
13716 return pyobj;
13717 }
13718
13719
13720 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13721 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13722 return 1;
13723 }
13724
13725
13726 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13727 PyObject *pyobj;
13728
13729 {
13730 #if wxUSE_UNICODE
13731 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13732 #else
13733 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13734 #endif
13735 }
13736 return pyobj;
13737 }
13738
13739
13740 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13741 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13742 return 1;
13743 }
13744
13745
13746 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13747 PyObject *pyobj;
13748
13749 {
13750 #if wxUSE_UNICODE
13751 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13752 #else
13753 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13754 #endif
13755 }
13756 return pyobj;
13757 }
13758
13759
13760 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13761 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13762 return 1;
13763 }
13764
13765
13766 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13767 PyObject *pyobj;
13768
13769 {
13770 #if wxUSE_UNICODE
13771 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13772 #else
13773 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13774 #endif
13775 }
13776 return pyobj;
13777 }
13778
13779
13780 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13781 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13782 return 1;
13783 }
13784
13785
13786 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13787 PyObject *pyobj;
13788
13789 {
13790 #if wxUSE_UNICODE
13791 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13792 #else
13793 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13794 #endif
13795 }
13796 return pyobj;
13797 }
13798
13799
13800 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13801 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13802 return 1;
13803 }
13804
13805
13806 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13807 PyObject *pyobj;
13808
13809 {
13810 #if wxUSE_UNICODE
13811 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13812 #else
13813 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13814 #endif
13815 }
13816 return pyobj;
13817 }
13818
13819
13820 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13821 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13822 return 1;
13823 }
13824
13825
13826 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13827 PyObject *pyobj;
13828
13829 {
13830 #if wxUSE_UNICODE
13831 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13832 #else
13833 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13834 #endif
13835 }
13836 return pyobj;
13837 }
13838
13839
13840 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13841 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13842 return 1;
13843 }
13844
13845
13846 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13847 PyObject *pyobj;
13848
13849 {
13850 #if wxUSE_UNICODE
13851 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13852 #else
13853 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13854 #endif
13855 }
13856 return pyobj;
13857 }
13858
13859
13860 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13861 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13862 return 1;
13863 }
13864
13865
13866 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13867 PyObject *pyobj;
13868
13869 {
13870 #if wxUSE_UNICODE
13871 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13872 #else
13873 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13874 #endif
13875 }
13876 return pyobj;
13877 }
13878
13879
13880 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13881 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13882 return 1;
13883 }
13884
13885
13886 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13887 PyObject *pyobj;
13888
13889 {
13890 #if wxUSE_UNICODE
13891 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13892 #else
13893 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13894 #endif
13895 }
13896 return pyobj;
13897 }
13898
13899
13900 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
13901 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
13902 return 1;
13903 }
13904
13905
13906 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
13907 PyObject *pyobj;
13908
13909 {
13910 #if wxUSE_UNICODE
13911 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13912 #else
13913 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13914 #endif
13915 }
13916 return pyobj;
13917 }
13918
13919
13920 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
13921 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
13922 return 1;
13923 }
13924
13925
13926 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
13927 PyObject *pyobj;
13928
13929 {
13930 #if wxUSE_UNICODE
13931 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13932 #else
13933 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13934 #endif
13935 }
13936 return pyobj;
13937 }
13938
13939
13940 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13941 PyObject *resultobj;
13942 wxBMPHandler *result;
13943 char *kwnames[] = {
13944 NULL
13945 };
13946
13947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13948 {
13949 PyThreadState* __tstate = wxPyBeginAllowThreads();
13950 result = (wxBMPHandler *)new wxBMPHandler();
13951
13952 wxPyEndAllowThreads(__tstate);
13953 if (PyErr_Occurred()) SWIG_fail;
13954 }
13955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13956 return resultobj;
13957 fail:
13958 return NULL;
13959 }
13960
13961
13962 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13963 PyObject *obj;
13964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13965 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13966 Py_INCREF(obj);
13967 return Py_BuildValue((char *)"");
13968 }
13969 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13970 PyObject *resultobj;
13971 wxICOHandler *result;
13972 char *kwnames[] = {
13973 NULL
13974 };
13975
13976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 result = (wxICOHandler *)new wxICOHandler();
13980
13981 wxPyEndAllowThreads(__tstate);
13982 if (PyErr_Occurred()) SWIG_fail;
13983 }
13984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13985 return resultobj;
13986 fail:
13987 return NULL;
13988 }
13989
13990
13991 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13992 PyObject *obj;
13993 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13994 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13995 Py_INCREF(obj);
13996 return Py_BuildValue((char *)"");
13997 }
13998 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13999 PyObject *resultobj;
14000 wxCURHandler *result;
14001 char *kwnames[] = {
14002 NULL
14003 };
14004
14005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14006 {
14007 PyThreadState* __tstate = wxPyBeginAllowThreads();
14008 result = (wxCURHandler *)new wxCURHandler();
14009
14010 wxPyEndAllowThreads(__tstate);
14011 if (PyErr_Occurred()) SWIG_fail;
14012 }
14013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14014 return resultobj;
14015 fail:
14016 return NULL;
14017 }
14018
14019
14020 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14021 PyObject *obj;
14022 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14023 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14024 Py_INCREF(obj);
14025 return Py_BuildValue((char *)"");
14026 }
14027 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14028 PyObject *resultobj;
14029 wxANIHandler *result;
14030 char *kwnames[] = {
14031 NULL
14032 };
14033
14034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14035 {
14036 PyThreadState* __tstate = wxPyBeginAllowThreads();
14037 result = (wxANIHandler *)new wxANIHandler();
14038
14039 wxPyEndAllowThreads(__tstate);
14040 if (PyErr_Occurred()) SWIG_fail;
14041 }
14042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14043 return resultobj;
14044 fail:
14045 return NULL;
14046 }
14047
14048
14049 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14050 PyObject *obj;
14051 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14052 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14053 Py_INCREF(obj);
14054 return Py_BuildValue((char *)"");
14055 }
14056 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14057 PyObject *resultobj;
14058 wxPNGHandler *result;
14059 char *kwnames[] = {
14060 NULL
14061 };
14062
14063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14064 {
14065 PyThreadState* __tstate = wxPyBeginAllowThreads();
14066 result = (wxPNGHandler *)new wxPNGHandler();
14067
14068 wxPyEndAllowThreads(__tstate);
14069 if (PyErr_Occurred()) SWIG_fail;
14070 }
14071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14072 return resultobj;
14073 fail:
14074 return NULL;
14075 }
14076
14077
14078 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14079 PyObject *obj;
14080 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14081 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14082 Py_INCREF(obj);
14083 return Py_BuildValue((char *)"");
14084 }
14085 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14086 PyObject *resultobj;
14087 wxGIFHandler *result;
14088 char *kwnames[] = {
14089 NULL
14090 };
14091
14092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14093 {
14094 PyThreadState* __tstate = wxPyBeginAllowThreads();
14095 result = (wxGIFHandler *)new wxGIFHandler();
14096
14097 wxPyEndAllowThreads(__tstate);
14098 if (PyErr_Occurred()) SWIG_fail;
14099 }
14100 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14101 return resultobj;
14102 fail:
14103 return NULL;
14104 }
14105
14106
14107 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14108 PyObject *obj;
14109 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14110 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14111 Py_INCREF(obj);
14112 return Py_BuildValue((char *)"");
14113 }
14114 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14115 PyObject *resultobj;
14116 wxPCXHandler *result;
14117 char *kwnames[] = {
14118 NULL
14119 };
14120
14121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14122 {
14123 PyThreadState* __tstate = wxPyBeginAllowThreads();
14124 result = (wxPCXHandler *)new wxPCXHandler();
14125
14126 wxPyEndAllowThreads(__tstate);
14127 if (PyErr_Occurred()) SWIG_fail;
14128 }
14129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14130 return resultobj;
14131 fail:
14132 return NULL;
14133 }
14134
14135
14136 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14137 PyObject *obj;
14138 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14139 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14140 Py_INCREF(obj);
14141 return Py_BuildValue((char *)"");
14142 }
14143 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14144 PyObject *resultobj;
14145 wxJPEGHandler *result;
14146 char *kwnames[] = {
14147 NULL
14148 };
14149
14150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14151 {
14152 PyThreadState* __tstate = wxPyBeginAllowThreads();
14153 result = (wxJPEGHandler *)new wxJPEGHandler();
14154
14155 wxPyEndAllowThreads(__tstate);
14156 if (PyErr_Occurred()) SWIG_fail;
14157 }
14158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14159 return resultobj;
14160 fail:
14161 return NULL;
14162 }
14163
14164
14165 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14166 PyObject *obj;
14167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14168 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14169 Py_INCREF(obj);
14170 return Py_BuildValue((char *)"");
14171 }
14172 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14173 PyObject *resultobj;
14174 wxPNMHandler *result;
14175 char *kwnames[] = {
14176 NULL
14177 };
14178
14179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14180 {
14181 PyThreadState* __tstate = wxPyBeginAllowThreads();
14182 result = (wxPNMHandler *)new wxPNMHandler();
14183
14184 wxPyEndAllowThreads(__tstate);
14185 if (PyErr_Occurred()) SWIG_fail;
14186 }
14187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14188 return resultobj;
14189 fail:
14190 return NULL;
14191 }
14192
14193
14194 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14195 PyObject *obj;
14196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14197 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14198 Py_INCREF(obj);
14199 return Py_BuildValue((char *)"");
14200 }
14201 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14202 PyObject *resultobj;
14203 wxXPMHandler *result;
14204 char *kwnames[] = {
14205 NULL
14206 };
14207
14208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14209 {
14210 PyThreadState* __tstate = wxPyBeginAllowThreads();
14211 result = (wxXPMHandler *)new wxXPMHandler();
14212
14213 wxPyEndAllowThreads(__tstate);
14214 if (PyErr_Occurred()) SWIG_fail;
14215 }
14216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14217 return resultobj;
14218 fail:
14219 return NULL;
14220 }
14221
14222
14223 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14224 PyObject *obj;
14225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14226 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14227 Py_INCREF(obj);
14228 return Py_BuildValue((char *)"");
14229 }
14230 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14231 PyObject *resultobj;
14232 wxTIFFHandler *result;
14233 char *kwnames[] = {
14234 NULL
14235 };
14236
14237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14238 {
14239 PyThreadState* __tstate = wxPyBeginAllowThreads();
14240 result = (wxTIFFHandler *)new wxTIFFHandler();
14241
14242 wxPyEndAllowThreads(__tstate);
14243 if (PyErr_Occurred()) SWIG_fail;
14244 }
14245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14246 return resultobj;
14247 fail:
14248 return NULL;
14249 }
14250
14251
14252 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14253 PyObject *obj;
14254 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14255 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14256 Py_INCREF(obj);
14257 return Py_BuildValue((char *)"");
14258 }
14259 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14260 PyObject *resultobj;
14261 wxImage *arg1 = 0 ;
14262 wxImage *arg2 = 0 ;
14263 int arg3 = (int) 236 ;
14264 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14265 bool result;
14266 PyObject * obj0 = 0 ;
14267 PyObject * obj1 = 0 ;
14268 PyObject * obj2 = 0 ;
14269 PyObject * obj3 = 0 ;
14270 char *kwnames[] = {
14271 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14272 };
14273
14274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14275 {
14276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14277 if (SWIG_arg_fail(1)) SWIG_fail;
14278 if (arg1 == NULL) {
14279 SWIG_null_ref("wxImage");
14280 }
14281 if (SWIG_arg_fail(1)) SWIG_fail;
14282 }
14283 {
14284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14285 if (SWIG_arg_fail(2)) SWIG_fail;
14286 if (arg2 == NULL) {
14287 SWIG_null_ref("wxImage");
14288 }
14289 if (SWIG_arg_fail(2)) SWIG_fail;
14290 }
14291 if (obj2) {
14292 {
14293 arg3 = (int)(SWIG_As_int(obj2));
14294 if (SWIG_arg_fail(3)) SWIG_fail;
14295 }
14296 }
14297 if (obj3) {
14298 {
14299 arg4 = (int)(SWIG_As_int(obj3));
14300 if (SWIG_arg_fail(4)) SWIG_fail;
14301 }
14302 }
14303 {
14304 PyThreadState* __tstate = wxPyBeginAllowThreads();
14305 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14306
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 {
14311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14312 }
14313 return resultobj;
14314 fail:
14315 return NULL;
14316 }
14317
14318
14319 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14320 PyObject *obj;
14321 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14322 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14323 Py_INCREF(obj);
14324 return Py_BuildValue((char *)"");
14325 }
14326 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14327 PyObject *resultobj;
14328 wxEvtHandler *result;
14329 char *kwnames[] = {
14330 NULL
14331 };
14332
14333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14334 {
14335 PyThreadState* __tstate = wxPyBeginAllowThreads();
14336 result = (wxEvtHandler *)new wxEvtHandler();
14337
14338 wxPyEndAllowThreads(__tstate);
14339 if (PyErr_Occurred()) SWIG_fail;
14340 }
14341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14342 return resultobj;
14343 fail:
14344 return NULL;
14345 }
14346
14347
14348 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14349 PyObject *resultobj;
14350 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14351 wxEvtHandler *result;
14352 PyObject * obj0 = 0 ;
14353 char *kwnames[] = {
14354 (char *) "self", NULL
14355 };
14356
14357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14359 if (SWIG_arg_fail(1)) SWIG_fail;
14360 {
14361 PyThreadState* __tstate = wxPyBeginAllowThreads();
14362 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14363
14364 wxPyEndAllowThreads(__tstate);
14365 if (PyErr_Occurred()) SWIG_fail;
14366 }
14367 {
14368 resultobj = wxPyMake_wxObject(result, 0);
14369 }
14370 return resultobj;
14371 fail:
14372 return NULL;
14373 }
14374
14375
14376 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14377 PyObject *resultobj;
14378 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14379 wxEvtHandler *result;
14380 PyObject * obj0 = 0 ;
14381 char *kwnames[] = {
14382 (char *) "self", NULL
14383 };
14384
14385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14387 if (SWIG_arg_fail(1)) SWIG_fail;
14388 {
14389 PyThreadState* __tstate = wxPyBeginAllowThreads();
14390 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14391
14392 wxPyEndAllowThreads(__tstate);
14393 if (PyErr_Occurred()) SWIG_fail;
14394 }
14395 {
14396 resultobj = wxPyMake_wxObject(result, 0);
14397 }
14398 return resultobj;
14399 fail:
14400 return NULL;
14401 }
14402
14403
14404 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14405 PyObject *resultobj;
14406 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14407 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14408 PyObject * obj0 = 0 ;
14409 PyObject * obj1 = 0 ;
14410 char *kwnames[] = {
14411 (char *) "self",(char *) "handler", NULL
14412 };
14413
14414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14416 if (SWIG_arg_fail(1)) SWIG_fail;
14417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14418 if (SWIG_arg_fail(2)) SWIG_fail;
14419 {
14420 PyThreadState* __tstate = wxPyBeginAllowThreads();
14421 (arg1)->SetNextHandler(arg2);
14422
14423 wxPyEndAllowThreads(__tstate);
14424 if (PyErr_Occurred()) SWIG_fail;
14425 }
14426 Py_INCREF(Py_None); resultobj = Py_None;
14427 return resultobj;
14428 fail:
14429 return NULL;
14430 }
14431
14432
14433 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14434 PyObject *resultobj;
14435 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14436 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14437 PyObject * obj0 = 0 ;
14438 PyObject * obj1 = 0 ;
14439 char *kwnames[] = {
14440 (char *) "self",(char *) "handler", NULL
14441 };
14442
14443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14445 if (SWIG_arg_fail(1)) SWIG_fail;
14446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14447 if (SWIG_arg_fail(2)) SWIG_fail;
14448 {
14449 PyThreadState* __tstate = wxPyBeginAllowThreads();
14450 (arg1)->SetPreviousHandler(arg2);
14451
14452 wxPyEndAllowThreads(__tstate);
14453 if (PyErr_Occurred()) SWIG_fail;
14454 }
14455 Py_INCREF(Py_None); resultobj = Py_None;
14456 return resultobj;
14457 fail:
14458 return NULL;
14459 }
14460
14461
14462 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14463 PyObject *resultobj;
14464 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14465 bool result;
14466 PyObject * obj0 = 0 ;
14467 char *kwnames[] = {
14468 (char *) "self", NULL
14469 };
14470
14471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14473 if (SWIG_arg_fail(1)) SWIG_fail;
14474 {
14475 PyThreadState* __tstate = wxPyBeginAllowThreads();
14476 result = (bool)(arg1)->GetEvtHandlerEnabled();
14477
14478 wxPyEndAllowThreads(__tstate);
14479 if (PyErr_Occurred()) SWIG_fail;
14480 }
14481 {
14482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14483 }
14484 return resultobj;
14485 fail:
14486 return NULL;
14487 }
14488
14489
14490 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14491 PyObject *resultobj;
14492 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14493 bool arg2 ;
14494 PyObject * obj0 = 0 ;
14495 PyObject * obj1 = 0 ;
14496 char *kwnames[] = {
14497 (char *) "self",(char *) "enabled", NULL
14498 };
14499
14500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14502 if (SWIG_arg_fail(1)) SWIG_fail;
14503 {
14504 arg2 = (bool)(SWIG_As_bool(obj1));
14505 if (SWIG_arg_fail(2)) SWIG_fail;
14506 }
14507 {
14508 PyThreadState* __tstate = wxPyBeginAllowThreads();
14509 (arg1)->SetEvtHandlerEnabled(arg2);
14510
14511 wxPyEndAllowThreads(__tstate);
14512 if (PyErr_Occurred()) SWIG_fail;
14513 }
14514 Py_INCREF(Py_None); resultobj = Py_None;
14515 return resultobj;
14516 fail:
14517 return NULL;
14518 }
14519
14520
14521 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14522 PyObject *resultobj;
14523 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14524 wxEvent *arg2 = 0 ;
14525 bool result;
14526 PyObject * obj0 = 0 ;
14527 PyObject * obj1 = 0 ;
14528 char *kwnames[] = {
14529 (char *) "self",(char *) "event", NULL
14530 };
14531
14532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14534 if (SWIG_arg_fail(1)) SWIG_fail;
14535 {
14536 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14537 if (SWIG_arg_fail(2)) SWIG_fail;
14538 if (arg2 == NULL) {
14539 SWIG_null_ref("wxEvent");
14540 }
14541 if (SWIG_arg_fail(2)) SWIG_fail;
14542 }
14543 {
14544 PyThreadState* __tstate = wxPyBeginAllowThreads();
14545 result = (bool)(arg1)->ProcessEvent(*arg2);
14546
14547 wxPyEndAllowThreads(__tstate);
14548 if (PyErr_Occurred()) SWIG_fail;
14549 }
14550 {
14551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14552 }
14553 return resultobj;
14554 fail:
14555 return NULL;
14556 }
14557
14558
14559 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14560 PyObject *resultobj;
14561 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14562 wxEvent *arg2 = 0 ;
14563 PyObject * obj0 = 0 ;
14564 PyObject * obj1 = 0 ;
14565 char *kwnames[] = {
14566 (char *) "self",(char *) "event", NULL
14567 };
14568
14569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14571 if (SWIG_arg_fail(1)) SWIG_fail;
14572 {
14573 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14574 if (SWIG_arg_fail(2)) SWIG_fail;
14575 if (arg2 == NULL) {
14576 SWIG_null_ref("wxEvent");
14577 }
14578 if (SWIG_arg_fail(2)) SWIG_fail;
14579 }
14580 {
14581 PyThreadState* __tstate = wxPyBeginAllowThreads();
14582 (arg1)->AddPendingEvent(*arg2);
14583
14584 wxPyEndAllowThreads(__tstate);
14585 if (PyErr_Occurred()) SWIG_fail;
14586 }
14587 Py_INCREF(Py_None); resultobj = Py_None;
14588 return resultobj;
14589 fail:
14590 return NULL;
14591 }
14592
14593
14594 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14595 PyObject *resultobj;
14596 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14597 PyObject * obj0 = 0 ;
14598 char *kwnames[] = {
14599 (char *) "self", NULL
14600 };
14601
14602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14604 if (SWIG_arg_fail(1)) SWIG_fail;
14605 {
14606 PyThreadState* __tstate = wxPyBeginAllowThreads();
14607 (arg1)->ProcessPendingEvents();
14608
14609 wxPyEndAllowThreads(__tstate);
14610 if (PyErr_Occurred()) SWIG_fail;
14611 }
14612 Py_INCREF(Py_None); resultobj = Py_None;
14613 return resultobj;
14614 fail:
14615 return NULL;
14616 }
14617
14618
14619 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14620 PyObject *resultobj;
14621 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14622 int arg2 ;
14623 int arg3 ;
14624 int arg4 ;
14625 PyObject *arg5 = (PyObject *) 0 ;
14626 PyObject * obj0 = 0 ;
14627 PyObject * obj1 = 0 ;
14628 PyObject * obj2 = 0 ;
14629 PyObject * obj3 = 0 ;
14630 PyObject * obj4 = 0 ;
14631 char *kwnames[] = {
14632 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14633 };
14634
14635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14637 if (SWIG_arg_fail(1)) SWIG_fail;
14638 {
14639 arg2 = (int)(SWIG_As_int(obj1));
14640 if (SWIG_arg_fail(2)) SWIG_fail;
14641 }
14642 {
14643 arg3 = (int)(SWIG_As_int(obj2));
14644 if (SWIG_arg_fail(3)) SWIG_fail;
14645 }
14646 {
14647 arg4 = (int)(SWIG_As_int(obj3));
14648 if (SWIG_arg_fail(4)) SWIG_fail;
14649 }
14650 arg5 = obj4;
14651 {
14652 PyThreadState* __tstate = wxPyBeginAllowThreads();
14653 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14654
14655 wxPyEndAllowThreads(__tstate);
14656 if (PyErr_Occurred()) SWIG_fail;
14657 }
14658 Py_INCREF(Py_None); resultobj = Py_None;
14659 return resultobj;
14660 fail:
14661 return NULL;
14662 }
14663
14664
14665 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14666 PyObject *resultobj;
14667 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14668 int arg2 ;
14669 int arg3 = (int) -1 ;
14670 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14671 bool result;
14672 PyObject * obj0 = 0 ;
14673 PyObject * obj1 = 0 ;
14674 PyObject * obj2 = 0 ;
14675 PyObject * obj3 = 0 ;
14676 char *kwnames[] = {
14677 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14678 };
14679
14680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14682 if (SWIG_arg_fail(1)) SWIG_fail;
14683 {
14684 arg2 = (int)(SWIG_As_int(obj1));
14685 if (SWIG_arg_fail(2)) SWIG_fail;
14686 }
14687 if (obj2) {
14688 {
14689 arg3 = (int)(SWIG_As_int(obj2));
14690 if (SWIG_arg_fail(3)) SWIG_fail;
14691 }
14692 }
14693 if (obj3) {
14694 {
14695 arg4 = (wxEventType)(SWIG_As_int(obj3));
14696 if (SWIG_arg_fail(4)) SWIG_fail;
14697 }
14698 }
14699 {
14700 PyThreadState* __tstate = wxPyBeginAllowThreads();
14701 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14702
14703 wxPyEndAllowThreads(__tstate);
14704 if (PyErr_Occurred()) SWIG_fail;
14705 }
14706 {
14707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14708 }
14709 return resultobj;
14710 fail:
14711 return NULL;
14712 }
14713
14714
14715 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14716 PyObject *resultobj;
14717 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14718 PyObject *arg2 = (PyObject *) 0 ;
14719 bool arg3 = (bool) true ;
14720 PyObject * obj0 = 0 ;
14721 PyObject * obj1 = 0 ;
14722 PyObject * obj2 = 0 ;
14723 char *kwnames[] = {
14724 (char *) "self",(char *) "_self",(char *) "incref", NULL
14725 };
14726
14727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14729 if (SWIG_arg_fail(1)) SWIG_fail;
14730 arg2 = obj1;
14731 if (obj2) {
14732 {
14733 arg3 = (bool)(SWIG_As_bool(obj2));
14734 if (SWIG_arg_fail(3)) SWIG_fail;
14735 }
14736 }
14737 {
14738 PyThreadState* __tstate = wxPyBeginAllowThreads();
14739 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14740
14741 wxPyEndAllowThreads(__tstate);
14742 if (PyErr_Occurred()) SWIG_fail;
14743 }
14744 Py_INCREF(Py_None); resultobj = Py_None;
14745 return resultobj;
14746 fail:
14747 return NULL;
14748 }
14749
14750
14751 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14752 PyObject *obj;
14753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14754 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14755 Py_INCREF(obj);
14756 return Py_BuildValue((char *)"");
14757 }
14758 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14759 PyObject *resultobj;
14760 wxEventType result;
14761 char *kwnames[] = {
14762 NULL
14763 };
14764
14765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14766 {
14767 PyThreadState* __tstate = wxPyBeginAllowThreads();
14768 result = (wxEventType)wxNewEventType();
14769
14770 wxPyEndAllowThreads(__tstate);
14771 if (PyErr_Occurred()) SWIG_fail;
14772 }
14773 {
14774 resultobj = SWIG_From_int((int)(result));
14775 }
14776 return resultobj;
14777 fail:
14778 return NULL;
14779 }
14780
14781
14782 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14783 PyObject *resultobj;
14784 wxEvent *arg1 = (wxEvent *) 0 ;
14785 PyObject * obj0 = 0 ;
14786 char *kwnames[] = {
14787 (char *) "self", NULL
14788 };
14789
14790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14792 if (SWIG_arg_fail(1)) SWIG_fail;
14793 {
14794 PyThreadState* __tstate = wxPyBeginAllowThreads();
14795 delete arg1;
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_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14808 PyObject *resultobj;
14809 wxEvent *arg1 = (wxEvent *) 0 ;
14810 wxEventType arg2 ;
14811 PyObject * obj0 = 0 ;
14812 PyObject * obj1 = 0 ;
14813 char *kwnames[] = {
14814 (char *) "self",(char *) "typ", NULL
14815 };
14816
14817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14819 if (SWIG_arg_fail(1)) SWIG_fail;
14820 {
14821 arg2 = (wxEventType)(SWIG_As_int(obj1));
14822 if (SWIG_arg_fail(2)) SWIG_fail;
14823 }
14824 {
14825 PyThreadState* __tstate = wxPyBeginAllowThreads();
14826 (arg1)->SetEventType(arg2);
14827
14828 wxPyEndAllowThreads(__tstate);
14829 if (PyErr_Occurred()) SWIG_fail;
14830 }
14831 Py_INCREF(Py_None); resultobj = Py_None;
14832 return resultobj;
14833 fail:
14834 return NULL;
14835 }
14836
14837
14838 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14839 PyObject *resultobj;
14840 wxEvent *arg1 = (wxEvent *) 0 ;
14841 wxEventType result;
14842 PyObject * obj0 = 0 ;
14843 char *kwnames[] = {
14844 (char *) "self", NULL
14845 };
14846
14847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14849 if (SWIG_arg_fail(1)) SWIG_fail;
14850 {
14851 PyThreadState* __tstate = wxPyBeginAllowThreads();
14852 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14853
14854 wxPyEndAllowThreads(__tstate);
14855 if (PyErr_Occurred()) SWIG_fail;
14856 }
14857 {
14858 resultobj = SWIG_From_int((int)(result));
14859 }
14860 return resultobj;
14861 fail:
14862 return NULL;
14863 }
14864
14865
14866 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14867 PyObject *resultobj;
14868 wxEvent *arg1 = (wxEvent *) 0 ;
14869 wxObject *result;
14870 PyObject * obj0 = 0 ;
14871 char *kwnames[] = {
14872 (char *) "self", NULL
14873 };
14874
14875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14877 if (SWIG_arg_fail(1)) SWIG_fail;
14878 {
14879 PyThreadState* __tstate = wxPyBeginAllowThreads();
14880 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14881
14882 wxPyEndAllowThreads(__tstate);
14883 if (PyErr_Occurred()) SWIG_fail;
14884 }
14885 {
14886 resultobj = wxPyMake_wxObject(result, 0);
14887 }
14888 return resultobj;
14889 fail:
14890 return NULL;
14891 }
14892
14893
14894 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14895 PyObject *resultobj;
14896 wxEvent *arg1 = (wxEvent *) 0 ;
14897 wxObject *arg2 = (wxObject *) 0 ;
14898 PyObject * obj0 = 0 ;
14899 PyObject * obj1 = 0 ;
14900 char *kwnames[] = {
14901 (char *) "self",(char *) "obj", NULL
14902 };
14903
14904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14906 if (SWIG_arg_fail(1)) SWIG_fail;
14907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14908 if (SWIG_arg_fail(2)) SWIG_fail;
14909 {
14910 PyThreadState* __tstate = wxPyBeginAllowThreads();
14911 (arg1)->SetEventObject(arg2);
14912
14913 wxPyEndAllowThreads(__tstate);
14914 if (PyErr_Occurred()) SWIG_fail;
14915 }
14916 Py_INCREF(Py_None); resultobj = Py_None;
14917 return resultobj;
14918 fail:
14919 return NULL;
14920 }
14921
14922
14923 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14924 PyObject *resultobj;
14925 wxEvent *arg1 = (wxEvent *) 0 ;
14926 long result;
14927 PyObject * obj0 = 0 ;
14928 char *kwnames[] = {
14929 (char *) "self", NULL
14930 };
14931
14932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14934 if (SWIG_arg_fail(1)) SWIG_fail;
14935 {
14936 PyThreadState* __tstate = wxPyBeginAllowThreads();
14937 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14938
14939 wxPyEndAllowThreads(__tstate);
14940 if (PyErr_Occurred()) SWIG_fail;
14941 }
14942 {
14943 resultobj = SWIG_From_long((long)(result));
14944 }
14945 return resultobj;
14946 fail:
14947 return NULL;
14948 }
14949
14950
14951 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14952 PyObject *resultobj;
14953 wxEvent *arg1 = (wxEvent *) 0 ;
14954 long arg2 = (long) 0 ;
14955 PyObject * obj0 = 0 ;
14956 PyObject * obj1 = 0 ;
14957 char *kwnames[] = {
14958 (char *) "self",(char *) "ts", NULL
14959 };
14960
14961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14963 if (SWIG_arg_fail(1)) SWIG_fail;
14964 if (obj1) {
14965 {
14966 arg2 = (long)(SWIG_As_long(obj1));
14967 if (SWIG_arg_fail(2)) SWIG_fail;
14968 }
14969 }
14970 {
14971 PyThreadState* __tstate = wxPyBeginAllowThreads();
14972 (arg1)->SetTimestamp(arg2);
14973
14974 wxPyEndAllowThreads(__tstate);
14975 if (PyErr_Occurred()) SWIG_fail;
14976 }
14977 Py_INCREF(Py_None); resultobj = Py_None;
14978 return resultobj;
14979 fail:
14980 return NULL;
14981 }
14982
14983
14984 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14985 PyObject *resultobj;
14986 wxEvent *arg1 = (wxEvent *) 0 ;
14987 int result;
14988 PyObject * obj0 = 0 ;
14989 char *kwnames[] = {
14990 (char *) "self", NULL
14991 };
14992
14993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14995 if (SWIG_arg_fail(1)) SWIG_fail;
14996 {
14997 PyThreadState* __tstate = wxPyBeginAllowThreads();
14998 result = (int)((wxEvent const *)arg1)->GetId();
14999
15000 wxPyEndAllowThreads(__tstate);
15001 if (PyErr_Occurred()) SWIG_fail;
15002 }
15003 {
15004 resultobj = SWIG_From_int((int)(result));
15005 }
15006 return resultobj;
15007 fail:
15008 return NULL;
15009 }
15010
15011
15012 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15013 PyObject *resultobj;
15014 wxEvent *arg1 = (wxEvent *) 0 ;
15015 int arg2 ;
15016 PyObject * obj0 = 0 ;
15017 PyObject * obj1 = 0 ;
15018 char *kwnames[] = {
15019 (char *) "self",(char *) "Id", NULL
15020 };
15021
15022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15024 if (SWIG_arg_fail(1)) SWIG_fail;
15025 {
15026 arg2 = (int)(SWIG_As_int(obj1));
15027 if (SWIG_arg_fail(2)) SWIG_fail;
15028 }
15029 {
15030 PyThreadState* __tstate = wxPyBeginAllowThreads();
15031 (arg1)->SetId(arg2);
15032
15033 wxPyEndAllowThreads(__tstate);
15034 if (PyErr_Occurred()) SWIG_fail;
15035 }
15036 Py_INCREF(Py_None); resultobj = Py_None;
15037 return resultobj;
15038 fail:
15039 return NULL;
15040 }
15041
15042
15043 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15044 PyObject *resultobj;
15045 wxEvent *arg1 = (wxEvent *) 0 ;
15046 bool result;
15047 PyObject * obj0 = 0 ;
15048 char *kwnames[] = {
15049 (char *) "self", NULL
15050 };
15051
15052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15054 if (SWIG_arg_fail(1)) SWIG_fail;
15055 {
15056 PyThreadState* __tstate = wxPyBeginAllowThreads();
15057 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15058
15059 wxPyEndAllowThreads(__tstate);
15060 if (PyErr_Occurred()) SWIG_fail;
15061 }
15062 {
15063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15064 }
15065 return resultobj;
15066 fail:
15067 return NULL;
15068 }
15069
15070
15071 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15072 PyObject *resultobj;
15073 wxEvent *arg1 = (wxEvent *) 0 ;
15074 bool arg2 = (bool) true ;
15075 PyObject * obj0 = 0 ;
15076 PyObject * obj1 = 0 ;
15077 char *kwnames[] = {
15078 (char *) "self",(char *) "skip", NULL
15079 };
15080
15081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15083 if (SWIG_arg_fail(1)) SWIG_fail;
15084 if (obj1) {
15085 {
15086 arg2 = (bool)(SWIG_As_bool(obj1));
15087 if (SWIG_arg_fail(2)) SWIG_fail;
15088 }
15089 }
15090 {
15091 PyThreadState* __tstate = wxPyBeginAllowThreads();
15092 (arg1)->Skip(arg2);
15093
15094 wxPyEndAllowThreads(__tstate);
15095 if (PyErr_Occurred()) SWIG_fail;
15096 }
15097 Py_INCREF(Py_None); resultobj = Py_None;
15098 return resultobj;
15099 fail:
15100 return NULL;
15101 }
15102
15103
15104 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15105 PyObject *resultobj;
15106 wxEvent *arg1 = (wxEvent *) 0 ;
15107 bool result;
15108 PyObject * obj0 = 0 ;
15109 char *kwnames[] = {
15110 (char *) "self", NULL
15111 };
15112
15113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15115 if (SWIG_arg_fail(1)) SWIG_fail;
15116 {
15117 PyThreadState* __tstate = wxPyBeginAllowThreads();
15118 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15119
15120 wxPyEndAllowThreads(__tstate);
15121 if (PyErr_Occurred()) SWIG_fail;
15122 }
15123 {
15124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15125 }
15126 return resultobj;
15127 fail:
15128 return NULL;
15129 }
15130
15131
15132 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15133 PyObject *resultobj;
15134 wxEvent *arg1 = (wxEvent *) 0 ;
15135 bool result;
15136 PyObject * obj0 = 0 ;
15137 char *kwnames[] = {
15138 (char *) "self", NULL
15139 };
15140
15141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15143 if (SWIG_arg_fail(1)) SWIG_fail;
15144 {
15145 PyThreadState* __tstate = wxPyBeginAllowThreads();
15146 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15147
15148 wxPyEndAllowThreads(__tstate);
15149 if (PyErr_Occurred()) SWIG_fail;
15150 }
15151 {
15152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15153 }
15154 return resultobj;
15155 fail:
15156 return NULL;
15157 }
15158
15159
15160 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15161 PyObject *resultobj;
15162 wxEvent *arg1 = (wxEvent *) 0 ;
15163 int result;
15164 PyObject * obj0 = 0 ;
15165 char *kwnames[] = {
15166 (char *) "self", NULL
15167 };
15168
15169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15171 if (SWIG_arg_fail(1)) SWIG_fail;
15172 {
15173 PyThreadState* __tstate = wxPyBeginAllowThreads();
15174 result = (int)(arg1)->StopPropagation();
15175
15176 wxPyEndAllowThreads(__tstate);
15177 if (PyErr_Occurred()) SWIG_fail;
15178 }
15179 {
15180 resultobj = SWIG_From_int((int)(result));
15181 }
15182 return resultobj;
15183 fail:
15184 return NULL;
15185 }
15186
15187
15188 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15189 PyObject *resultobj;
15190 wxEvent *arg1 = (wxEvent *) 0 ;
15191 int arg2 ;
15192 PyObject * obj0 = 0 ;
15193 PyObject * obj1 = 0 ;
15194 char *kwnames[] = {
15195 (char *) "self",(char *) "propagationLevel", NULL
15196 };
15197
15198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15200 if (SWIG_arg_fail(1)) SWIG_fail;
15201 {
15202 arg2 = (int)(SWIG_As_int(obj1));
15203 if (SWIG_arg_fail(2)) SWIG_fail;
15204 }
15205 {
15206 PyThreadState* __tstate = wxPyBeginAllowThreads();
15207 (arg1)->ResumePropagation(arg2);
15208
15209 wxPyEndAllowThreads(__tstate);
15210 if (PyErr_Occurred()) SWIG_fail;
15211 }
15212 Py_INCREF(Py_None); resultobj = Py_None;
15213 return resultobj;
15214 fail:
15215 return NULL;
15216 }
15217
15218
15219 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15220 PyObject *resultobj;
15221 wxEvent *arg1 = (wxEvent *) 0 ;
15222 wxEvent *result;
15223 PyObject * obj0 = 0 ;
15224 char *kwnames[] = {
15225 (char *) "self", NULL
15226 };
15227
15228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15230 if (SWIG_arg_fail(1)) SWIG_fail;
15231 {
15232 PyThreadState* __tstate = wxPyBeginAllowThreads();
15233 result = (wxEvent *)(arg1)->Clone();
15234
15235 wxPyEndAllowThreads(__tstate);
15236 if (PyErr_Occurred()) SWIG_fail;
15237 }
15238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15239 return resultobj;
15240 fail:
15241 return NULL;
15242 }
15243
15244
15245 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15246 PyObject *obj;
15247 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15248 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15249 Py_INCREF(obj);
15250 return Py_BuildValue((char *)"");
15251 }
15252 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15253 PyObject *resultobj;
15254 wxEvent *arg1 = 0 ;
15255 wxPropagationDisabler *result;
15256 PyObject * obj0 = 0 ;
15257 char *kwnames[] = {
15258 (char *) "event", NULL
15259 };
15260
15261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15262 {
15263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15264 if (SWIG_arg_fail(1)) SWIG_fail;
15265 if (arg1 == NULL) {
15266 SWIG_null_ref("wxEvent");
15267 }
15268 if (SWIG_arg_fail(1)) SWIG_fail;
15269 }
15270 {
15271 PyThreadState* __tstate = wxPyBeginAllowThreads();
15272 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15273
15274 wxPyEndAllowThreads(__tstate);
15275 if (PyErr_Occurred()) SWIG_fail;
15276 }
15277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15278 return resultobj;
15279 fail:
15280 return NULL;
15281 }
15282
15283
15284 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15285 PyObject *resultobj;
15286 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15287 PyObject * obj0 = 0 ;
15288 char *kwnames[] = {
15289 (char *) "self", NULL
15290 };
15291
15292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15294 if (SWIG_arg_fail(1)) SWIG_fail;
15295 {
15296 PyThreadState* __tstate = wxPyBeginAllowThreads();
15297 delete arg1;
15298
15299 wxPyEndAllowThreads(__tstate);
15300 if (PyErr_Occurred()) SWIG_fail;
15301 }
15302 Py_INCREF(Py_None); resultobj = Py_None;
15303 return resultobj;
15304 fail:
15305 return NULL;
15306 }
15307
15308
15309 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15310 PyObject *obj;
15311 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15312 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15313 Py_INCREF(obj);
15314 return Py_BuildValue((char *)"");
15315 }
15316 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15317 PyObject *resultobj;
15318 wxEvent *arg1 = 0 ;
15319 wxPropagateOnce *result;
15320 PyObject * obj0 = 0 ;
15321 char *kwnames[] = {
15322 (char *) "event", NULL
15323 };
15324
15325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15326 {
15327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15328 if (SWIG_arg_fail(1)) SWIG_fail;
15329 if (arg1 == NULL) {
15330 SWIG_null_ref("wxEvent");
15331 }
15332 if (SWIG_arg_fail(1)) SWIG_fail;
15333 }
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15337
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15342 return resultobj;
15343 fail:
15344 return NULL;
15345 }
15346
15347
15348 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15349 PyObject *resultobj;
15350 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15351 PyObject * obj0 = 0 ;
15352 char *kwnames[] = {
15353 (char *) "self", NULL
15354 };
15355
15356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15358 if (SWIG_arg_fail(1)) SWIG_fail;
15359 {
15360 PyThreadState* __tstate = wxPyBeginAllowThreads();
15361 delete arg1;
15362
15363 wxPyEndAllowThreads(__tstate);
15364 if (PyErr_Occurred()) SWIG_fail;
15365 }
15366 Py_INCREF(Py_None); resultobj = Py_None;
15367 return resultobj;
15368 fail:
15369 return NULL;
15370 }
15371
15372
15373 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15374 PyObject *obj;
15375 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15376 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15377 Py_INCREF(obj);
15378 return Py_BuildValue((char *)"");
15379 }
15380 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15381 PyObject *resultobj;
15382 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15383 int arg2 = (int) 0 ;
15384 wxCommandEvent *result;
15385 PyObject * obj0 = 0 ;
15386 PyObject * obj1 = 0 ;
15387 char *kwnames[] = {
15388 (char *) "commandType",(char *) "winid", NULL
15389 };
15390
15391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15392 if (obj0) {
15393 {
15394 arg1 = (wxEventType)(SWIG_As_int(obj0));
15395 if (SWIG_arg_fail(1)) SWIG_fail;
15396 }
15397 }
15398 if (obj1) {
15399 {
15400 arg2 = (int)(SWIG_As_int(obj1));
15401 if (SWIG_arg_fail(2)) SWIG_fail;
15402 }
15403 }
15404 {
15405 PyThreadState* __tstate = wxPyBeginAllowThreads();
15406 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15407
15408 wxPyEndAllowThreads(__tstate);
15409 if (PyErr_Occurred()) SWIG_fail;
15410 }
15411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15412 return resultobj;
15413 fail:
15414 return NULL;
15415 }
15416
15417
15418 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15419 PyObject *resultobj;
15420 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15421 int result;
15422 PyObject * obj0 = 0 ;
15423 char *kwnames[] = {
15424 (char *) "self", NULL
15425 };
15426
15427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15429 if (SWIG_arg_fail(1)) SWIG_fail;
15430 {
15431 PyThreadState* __tstate = wxPyBeginAllowThreads();
15432 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15433
15434 wxPyEndAllowThreads(__tstate);
15435 if (PyErr_Occurred()) SWIG_fail;
15436 }
15437 {
15438 resultobj = SWIG_From_int((int)(result));
15439 }
15440 return resultobj;
15441 fail:
15442 return NULL;
15443 }
15444
15445
15446 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15447 PyObject *resultobj;
15448 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15449 wxString *arg2 = 0 ;
15450 bool temp2 = false ;
15451 PyObject * obj0 = 0 ;
15452 PyObject * obj1 = 0 ;
15453 char *kwnames[] = {
15454 (char *) "self",(char *) "s", NULL
15455 };
15456
15457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15459 if (SWIG_arg_fail(1)) SWIG_fail;
15460 {
15461 arg2 = wxString_in_helper(obj1);
15462 if (arg2 == NULL) SWIG_fail;
15463 temp2 = true;
15464 }
15465 {
15466 PyThreadState* __tstate = wxPyBeginAllowThreads();
15467 (arg1)->SetString((wxString const &)*arg2);
15468
15469 wxPyEndAllowThreads(__tstate);
15470 if (PyErr_Occurred()) SWIG_fail;
15471 }
15472 Py_INCREF(Py_None); resultobj = Py_None;
15473 {
15474 if (temp2)
15475 delete arg2;
15476 }
15477 return resultobj;
15478 fail:
15479 {
15480 if (temp2)
15481 delete arg2;
15482 }
15483 return NULL;
15484 }
15485
15486
15487 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15488 PyObject *resultobj;
15489 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15490 wxString result;
15491 PyObject * obj0 = 0 ;
15492 char *kwnames[] = {
15493 (char *) "self", NULL
15494 };
15495
15496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15498 if (SWIG_arg_fail(1)) SWIG_fail;
15499 {
15500 PyThreadState* __tstate = wxPyBeginAllowThreads();
15501 result = ((wxCommandEvent const *)arg1)->GetString();
15502
15503 wxPyEndAllowThreads(__tstate);
15504 if (PyErr_Occurred()) SWIG_fail;
15505 }
15506 {
15507 #if wxUSE_UNICODE
15508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15509 #else
15510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15511 #endif
15512 }
15513 return resultobj;
15514 fail:
15515 return NULL;
15516 }
15517
15518
15519 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15520 PyObject *resultobj;
15521 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15522 bool result;
15523 PyObject * obj0 = 0 ;
15524 char *kwnames[] = {
15525 (char *) "self", NULL
15526 };
15527
15528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15530 if (SWIG_arg_fail(1)) SWIG_fail;
15531 {
15532 PyThreadState* __tstate = wxPyBeginAllowThreads();
15533 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15534
15535 wxPyEndAllowThreads(__tstate);
15536 if (PyErr_Occurred()) SWIG_fail;
15537 }
15538 {
15539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15540 }
15541 return resultobj;
15542 fail:
15543 return NULL;
15544 }
15545
15546
15547 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15548 PyObject *resultobj;
15549 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15550 bool result;
15551 PyObject * obj0 = 0 ;
15552 char *kwnames[] = {
15553 (char *) "self", NULL
15554 };
15555
15556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15558 if (SWIG_arg_fail(1)) SWIG_fail;
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15562
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 {
15567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15568 }
15569 return resultobj;
15570 fail:
15571 return NULL;
15572 }
15573
15574
15575 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15576 PyObject *resultobj;
15577 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15578 long arg2 ;
15579 PyObject * obj0 = 0 ;
15580 PyObject * obj1 = 0 ;
15581 char *kwnames[] = {
15582 (char *) "self",(char *) "extraLong", NULL
15583 };
15584
15585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15587 if (SWIG_arg_fail(1)) SWIG_fail;
15588 {
15589 arg2 = (long)(SWIG_As_long(obj1));
15590 if (SWIG_arg_fail(2)) SWIG_fail;
15591 }
15592 {
15593 PyThreadState* __tstate = wxPyBeginAllowThreads();
15594 (arg1)->SetExtraLong(arg2);
15595
15596 wxPyEndAllowThreads(__tstate);
15597 if (PyErr_Occurred()) SWIG_fail;
15598 }
15599 Py_INCREF(Py_None); resultobj = Py_None;
15600 return resultobj;
15601 fail:
15602 return NULL;
15603 }
15604
15605
15606 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15607 PyObject *resultobj;
15608 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15609 long result;
15610 PyObject * obj0 = 0 ;
15611 char *kwnames[] = {
15612 (char *) "self", NULL
15613 };
15614
15615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15617 if (SWIG_arg_fail(1)) SWIG_fail;
15618 {
15619 PyThreadState* __tstate = wxPyBeginAllowThreads();
15620 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15621
15622 wxPyEndAllowThreads(__tstate);
15623 if (PyErr_Occurred()) SWIG_fail;
15624 }
15625 {
15626 resultobj = SWIG_From_long((long)(result));
15627 }
15628 return resultobj;
15629 fail:
15630 return NULL;
15631 }
15632
15633
15634 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15635 PyObject *resultobj;
15636 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15637 int arg2 ;
15638 PyObject * obj0 = 0 ;
15639 PyObject * obj1 = 0 ;
15640 char *kwnames[] = {
15641 (char *) "self",(char *) "i", NULL
15642 };
15643
15644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15646 if (SWIG_arg_fail(1)) SWIG_fail;
15647 {
15648 arg2 = (int)(SWIG_As_int(obj1));
15649 if (SWIG_arg_fail(2)) SWIG_fail;
15650 }
15651 {
15652 PyThreadState* __tstate = wxPyBeginAllowThreads();
15653 (arg1)->SetInt(arg2);
15654
15655 wxPyEndAllowThreads(__tstate);
15656 if (PyErr_Occurred()) SWIG_fail;
15657 }
15658 Py_INCREF(Py_None); resultobj = Py_None;
15659 return resultobj;
15660 fail:
15661 return NULL;
15662 }
15663
15664
15665 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15666 PyObject *resultobj;
15667 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15668 long result;
15669 PyObject * obj0 = 0 ;
15670 char *kwnames[] = {
15671 (char *) "self", NULL
15672 };
15673
15674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15676 if (SWIG_arg_fail(1)) SWIG_fail;
15677 {
15678 PyThreadState* __tstate = wxPyBeginAllowThreads();
15679 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15680
15681 wxPyEndAllowThreads(__tstate);
15682 if (PyErr_Occurred()) SWIG_fail;
15683 }
15684 {
15685 resultobj = SWIG_From_long((long)(result));
15686 }
15687 return resultobj;
15688 fail:
15689 return NULL;
15690 }
15691
15692
15693 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15694 PyObject *resultobj;
15695 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15696 wxEvent *result;
15697 PyObject * obj0 = 0 ;
15698 char *kwnames[] = {
15699 (char *) "self", NULL
15700 };
15701
15702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15704 if (SWIG_arg_fail(1)) SWIG_fail;
15705 {
15706 PyThreadState* __tstate = wxPyBeginAllowThreads();
15707 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15708
15709 wxPyEndAllowThreads(__tstate);
15710 if (PyErr_Occurred()) SWIG_fail;
15711 }
15712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15713 return resultobj;
15714 fail:
15715 return NULL;
15716 }
15717
15718
15719 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15720 PyObject *obj;
15721 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15722 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15723 Py_INCREF(obj);
15724 return Py_BuildValue((char *)"");
15725 }
15726 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15727 PyObject *resultobj;
15728 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15729 int arg2 = (int) 0 ;
15730 wxNotifyEvent *result;
15731 PyObject * obj0 = 0 ;
15732 PyObject * obj1 = 0 ;
15733 char *kwnames[] = {
15734 (char *) "commandType",(char *) "winid", NULL
15735 };
15736
15737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15738 if (obj0) {
15739 {
15740 arg1 = (wxEventType)(SWIG_As_int(obj0));
15741 if (SWIG_arg_fail(1)) SWIG_fail;
15742 }
15743 }
15744 if (obj1) {
15745 {
15746 arg2 = (int)(SWIG_As_int(obj1));
15747 if (SWIG_arg_fail(2)) SWIG_fail;
15748 }
15749 }
15750 {
15751 PyThreadState* __tstate = wxPyBeginAllowThreads();
15752 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15753
15754 wxPyEndAllowThreads(__tstate);
15755 if (PyErr_Occurred()) SWIG_fail;
15756 }
15757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15758 return resultobj;
15759 fail:
15760 return NULL;
15761 }
15762
15763
15764 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15765 PyObject *resultobj;
15766 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15767 PyObject * obj0 = 0 ;
15768 char *kwnames[] = {
15769 (char *) "self", NULL
15770 };
15771
15772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15774 if (SWIG_arg_fail(1)) SWIG_fail;
15775 {
15776 PyThreadState* __tstate = wxPyBeginAllowThreads();
15777 (arg1)->Veto();
15778
15779 wxPyEndAllowThreads(__tstate);
15780 if (PyErr_Occurred()) SWIG_fail;
15781 }
15782 Py_INCREF(Py_None); resultobj = Py_None;
15783 return resultobj;
15784 fail:
15785 return NULL;
15786 }
15787
15788
15789 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15790 PyObject *resultobj;
15791 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15792 PyObject * obj0 = 0 ;
15793 char *kwnames[] = {
15794 (char *) "self", NULL
15795 };
15796
15797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15799 if (SWIG_arg_fail(1)) SWIG_fail;
15800 {
15801 PyThreadState* __tstate = wxPyBeginAllowThreads();
15802 (arg1)->Allow();
15803
15804 wxPyEndAllowThreads(__tstate);
15805 if (PyErr_Occurred()) SWIG_fail;
15806 }
15807 Py_INCREF(Py_None); resultobj = Py_None;
15808 return resultobj;
15809 fail:
15810 return NULL;
15811 }
15812
15813
15814 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15815 PyObject *resultobj;
15816 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15817 bool result;
15818 PyObject * obj0 = 0 ;
15819 char *kwnames[] = {
15820 (char *) "self", NULL
15821 };
15822
15823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15825 if (SWIG_arg_fail(1)) SWIG_fail;
15826 {
15827 PyThreadState* __tstate = wxPyBeginAllowThreads();
15828 result = (bool)(arg1)->IsAllowed();
15829
15830 wxPyEndAllowThreads(__tstate);
15831 if (PyErr_Occurred()) SWIG_fail;
15832 }
15833 {
15834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15835 }
15836 return resultobj;
15837 fail:
15838 return NULL;
15839 }
15840
15841
15842 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15843 PyObject *obj;
15844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15845 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15846 Py_INCREF(obj);
15847 return Py_BuildValue((char *)"");
15848 }
15849 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15850 PyObject *resultobj;
15851 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15852 int arg2 = (int) 0 ;
15853 int arg3 = (int) 0 ;
15854 int arg4 = (int) 0 ;
15855 wxScrollEvent *result;
15856 PyObject * obj0 = 0 ;
15857 PyObject * obj1 = 0 ;
15858 PyObject * obj2 = 0 ;
15859 PyObject * obj3 = 0 ;
15860 char *kwnames[] = {
15861 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15862 };
15863
15864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15865 if (obj0) {
15866 {
15867 arg1 = (wxEventType)(SWIG_As_int(obj0));
15868 if (SWIG_arg_fail(1)) SWIG_fail;
15869 }
15870 }
15871 if (obj1) {
15872 {
15873 arg2 = (int)(SWIG_As_int(obj1));
15874 if (SWIG_arg_fail(2)) SWIG_fail;
15875 }
15876 }
15877 if (obj2) {
15878 {
15879 arg3 = (int)(SWIG_As_int(obj2));
15880 if (SWIG_arg_fail(3)) SWIG_fail;
15881 }
15882 }
15883 if (obj3) {
15884 {
15885 arg4 = (int)(SWIG_As_int(obj3));
15886 if (SWIG_arg_fail(4)) SWIG_fail;
15887 }
15888 }
15889 {
15890 PyThreadState* __tstate = wxPyBeginAllowThreads();
15891 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15892
15893 wxPyEndAllowThreads(__tstate);
15894 if (PyErr_Occurred()) SWIG_fail;
15895 }
15896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15897 return resultobj;
15898 fail:
15899 return NULL;
15900 }
15901
15902
15903 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15904 PyObject *resultobj;
15905 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15906 int result;
15907 PyObject * obj0 = 0 ;
15908 char *kwnames[] = {
15909 (char *) "self", NULL
15910 };
15911
15912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15914 if (SWIG_arg_fail(1)) SWIG_fail;
15915 {
15916 PyThreadState* __tstate = wxPyBeginAllowThreads();
15917 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15918
15919 wxPyEndAllowThreads(__tstate);
15920 if (PyErr_Occurred()) SWIG_fail;
15921 }
15922 {
15923 resultobj = SWIG_From_int((int)(result));
15924 }
15925 return resultobj;
15926 fail:
15927 return NULL;
15928 }
15929
15930
15931 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15932 PyObject *resultobj;
15933 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15934 int result;
15935 PyObject * obj0 = 0 ;
15936 char *kwnames[] = {
15937 (char *) "self", NULL
15938 };
15939
15940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15942 if (SWIG_arg_fail(1)) SWIG_fail;
15943 {
15944 PyThreadState* __tstate = wxPyBeginAllowThreads();
15945 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15946
15947 wxPyEndAllowThreads(__tstate);
15948 if (PyErr_Occurred()) SWIG_fail;
15949 }
15950 {
15951 resultobj = SWIG_From_int((int)(result));
15952 }
15953 return resultobj;
15954 fail:
15955 return NULL;
15956 }
15957
15958
15959 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15960 PyObject *resultobj;
15961 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15962 int arg2 ;
15963 PyObject * obj0 = 0 ;
15964 PyObject * obj1 = 0 ;
15965 char *kwnames[] = {
15966 (char *) "self",(char *) "orient", NULL
15967 };
15968
15969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15971 if (SWIG_arg_fail(1)) SWIG_fail;
15972 {
15973 arg2 = (int)(SWIG_As_int(obj1));
15974 if (SWIG_arg_fail(2)) SWIG_fail;
15975 }
15976 {
15977 PyThreadState* __tstate = wxPyBeginAllowThreads();
15978 (arg1)->SetOrientation(arg2);
15979
15980 wxPyEndAllowThreads(__tstate);
15981 if (PyErr_Occurred()) SWIG_fail;
15982 }
15983 Py_INCREF(Py_None); resultobj = Py_None;
15984 return resultobj;
15985 fail:
15986 return NULL;
15987 }
15988
15989
15990 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15991 PyObject *resultobj;
15992 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15993 int arg2 ;
15994 PyObject * obj0 = 0 ;
15995 PyObject * obj1 = 0 ;
15996 char *kwnames[] = {
15997 (char *) "self",(char *) "pos", NULL
15998 };
15999
16000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16002 if (SWIG_arg_fail(1)) SWIG_fail;
16003 {
16004 arg2 = (int)(SWIG_As_int(obj1));
16005 if (SWIG_arg_fail(2)) SWIG_fail;
16006 }
16007 {
16008 PyThreadState* __tstate = wxPyBeginAllowThreads();
16009 (arg1)->SetPosition(arg2);
16010
16011 wxPyEndAllowThreads(__tstate);
16012 if (PyErr_Occurred()) SWIG_fail;
16013 }
16014 Py_INCREF(Py_None); resultobj = Py_None;
16015 return resultobj;
16016 fail:
16017 return NULL;
16018 }
16019
16020
16021 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16022 PyObject *obj;
16023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16024 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16025 Py_INCREF(obj);
16026 return Py_BuildValue((char *)"");
16027 }
16028 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16029 PyObject *resultobj;
16030 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16031 int arg2 = (int) 0 ;
16032 int arg3 = (int) 0 ;
16033 wxScrollWinEvent *result;
16034 PyObject * obj0 = 0 ;
16035 PyObject * obj1 = 0 ;
16036 PyObject * obj2 = 0 ;
16037 char *kwnames[] = {
16038 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16039 };
16040
16041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16042 if (obj0) {
16043 {
16044 arg1 = (wxEventType)(SWIG_As_int(obj0));
16045 if (SWIG_arg_fail(1)) SWIG_fail;
16046 }
16047 }
16048 if (obj1) {
16049 {
16050 arg2 = (int)(SWIG_As_int(obj1));
16051 if (SWIG_arg_fail(2)) SWIG_fail;
16052 }
16053 }
16054 if (obj2) {
16055 {
16056 arg3 = (int)(SWIG_As_int(obj2));
16057 if (SWIG_arg_fail(3)) SWIG_fail;
16058 }
16059 }
16060 {
16061 PyThreadState* __tstate = wxPyBeginAllowThreads();
16062 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16063
16064 wxPyEndAllowThreads(__tstate);
16065 if (PyErr_Occurred()) SWIG_fail;
16066 }
16067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16068 return resultobj;
16069 fail:
16070 return NULL;
16071 }
16072
16073
16074 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16075 PyObject *resultobj;
16076 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16077 int result;
16078 PyObject * obj0 = 0 ;
16079 char *kwnames[] = {
16080 (char *) "self", NULL
16081 };
16082
16083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16085 if (SWIG_arg_fail(1)) SWIG_fail;
16086 {
16087 PyThreadState* __tstate = wxPyBeginAllowThreads();
16088 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16089
16090 wxPyEndAllowThreads(__tstate);
16091 if (PyErr_Occurred()) SWIG_fail;
16092 }
16093 {
16094 resultobj = SWIG_From_int((int)(result));
16095 }
16096 return resultobj;
16097 fail:
16098 return NULL;
16099 }
16100
16101
16102 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16103 PyObject *resultobj;
16104 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16105 int result;
16106 PyObject * obj0 = 0 ;
16107 char *kwnames[] = {
16108 (char *) "self", NULL
16109 };
16110
16111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16113 if (SWIG_arg_fail(1)) SWIG_fail;
16114 {
16115 PyThreadState* __tstate = wxPyBeginAllowThreads();
16116 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16117
16118 wxPyEndAllowThreads(__tstate);
16119 if (PyErr_Occurred()) SWIG_fail;
16120 }
16121 {
16122 resultobj = SWIG_From_int((int)(result));
16123 }
16124 return resultobj;
16125 fail:
16126 return NULL;
16127 }
16128
16129
16130 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16131 PyObject *resultobj;
16132 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16133 int arg2 ;
16134 PyObject * obj0 = 0 ;
16135 PyObject * obj1 = 0 ;
16136 char *kwnames[] = {
16137 (char *) "self",(char *) "orient", NULL
16138 };
16139
16140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16142 if (SWIG_arg_fail(1)) SWIG_fail;
16143 {
16144 arg2 = (int)(SWIG_As_int(obj1));
16145 if (SWIG_arg_fail(2)) SWIG_fail;
16146 }
16147 {
16148 PyThreadState* __tstate = wxPyBeginAllowThreads();
16149 (arg1)->SetOrientation(arg2);
16150
16151 wxPyEndAllowThreads(__tstate);
16152 if (PyErr_Occurred()) SWIG_fail;
16153 }
16154 Py_INCREF(Py_None); resultobj = Py_None;
16155 return resultobj;
16156 fail:
16157 return NULL;
16158 }
16159
16160
16161 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16162 PyObject *resultobj;
16163 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16164 int arg2 ;
16165 PyObject * obj0 = 0 ;
16166 PyObject * obj1 = 0 ;
16167 char *kwnames[] = {
16168 (char *) "self",(char *) "pos", NULL
16169 };
16170
16171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16173 if (SWIG_arg_fail(1)) SWIG_fail;
16174 {
16175 arg2 = (int)(SWIG_As_int(obj1));
16176 if (SWIG_arg_fail(2)) SWIG_fail;
16177 }
16178 {
16179 PyThreadState* __tstate = wxPyBeginAllowThreads();
16180 (arg1)->SetPosition(arg2);
16181
16182 wxPyEndAllowThreads(__tstate);
16183 if (PyErr_Occurred()) SWIG_fail;
16184 }
16185 Py_INCREF(Py_None); resultobj = Py_None;
16186 return resultobj;
16187 fail:
16188 return NULL;
16189 }
16190
16191
16192 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16193 PyObject *obj;
16194 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16195 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16196 Py_INCREF(obj);
16197 return Py_BuildValue((char *)"");
16198 }
16199 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16200 PyObject *resultobj;
16201 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16202 wxMouseEvent *result;
16203 PyObject * obj0 = 0 ;
16204 char *kwnames[] = {
16205 (char *) "mouseType", NULL
16206 };
16207
16208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16209 if (obj0) {
16210 {
16211 arg1 = (wxEventType)(SWIG_As_int(obj0));
16212 if (SWIG_arg_fail(1)) SWIG_fail;
16213 }
16214 }
16215 {
16216 PyThreadState* __tstate = wxPyBeginAllowThreads();
16217 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16218
16219 wxPyEndAllowThreads(__tstate);
16220 if (PyErr_Occurred()) SWIG_fail;
16221 }
16222 {
16223 resultobj = wxPyMake_wxObject(result, 1);
16224 }
16225 return resultobj;
16226 fail:
16227 return NULL;
16228 }
16229
16230
16231 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16232 PyObject *resultobj;
16233 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16234 bool result;
16235 PyObject * obj0 = 0 ;
16236 char *kwnames[] = {
16237 (char *) "self", NULL
16238 };
16239
16240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16242 if (SWIG_arg_fail(1)) SWIG_fail;
16243 {
16244 PyThreadState* __tstate = wxPyBeginAllowThreads();
16245 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16246
16247 wxPyEndAllowThreads(__tstate);
16248 if (PyErr_Occurred()) SWIG_fail;
16249 }
16250 {
16251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16252 }
16253 return resultobj;
16254 fail:
16255 return NULL;
16256 }
16257
16258
16259 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16260 PyObject *resultobj;
16261 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16262 int arg2 = (int) wxMOUSE_BTN_ANY ;
16263 bool result;
16264 PyObject * obj0 = 0 ;
16265 PyObject * obj1 = 0 ;
16266 char *kwnames[] = {
16267 (char *) "self",(char *) "but", NULL
16268 };
16269
16270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16272 if (SWIG_arg_fail(1)) SWIG_fail;
16273 if (obj1) {
16274 {
16275 arg2 = (int)(SWIG_As_int(obj1));
16276 if (SWIG_arg_fail(2)) SWIG_fail;
16277 }
16278 }
16279 {
16280 PyThreadState* __tstate = wxPyBeginAllowThreads();
16281 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16282
16283 wxPyEndAllowThreads(__tstate);
16284 if (PyErr_Occurred()) SWIG_fail;
16285 }
16286 {
16287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16288 }
16289 return resultobj;
16290 fail:
16291 return NULL;
16292 }
16293
16294
16295 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16296 PyObject *resultobj;
16297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16298 int arg2 = (int) wxMOUSE_BTN_ANY ;
16299 bool result;
16300 PyObject * obj0 = 0 ;
16301 PyObject * obj1 = 0 ;
16302 char *kwnames[] = {
16303 (char *) "self",(char *) "but", NULL
16304 };
16305
16306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16308 if (SWIG_arg_fail(1)) SWIG_fail;
16309 if (obj1) {
16310 {
16311 arg2 = (int)(SWIG_As_int(obj1));
16312 if (SWIG_arg_fail(2)) SWIG_fail;
16313 }
16314 }
16315 {
16316 PyThreadState* __tstate = wxPyBeginAllowThreads();
16317 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16318
16319 wxPyEndAllowThreads(__tstate);
16320 if (PyErr_Occurred()) SWIG_fail;
16321 }
16322 {
16323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16324 }
16325 return resultobj;
16326 fail:
16327 return NULL;
16328 }
16329
16330
16331 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16332 PyObject *resultobj;
16333 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16334 int arg2 = (int) wxMOUSE_BTN_ANY ;
16335 bool result;
16336 PyObject * obj0 = 0 ;
16337 PyObject * obj1 = 0 ;
16338 char *kwnames[] = {
16339 (char *) "self",(char *) "but", NULL
16340 };
16341
16342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16344 if (SWIG_arg_fail(1)) SWIG_fail;
16345 if (obj1) {
16346 {
16347 arg2 = (int)(SWIG_As_int(obj1));
16348 if (SWIG_arg_fail(2)) SWIG_fail;
16349 }
16350 }
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
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_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16368 PyObject *resultobj;
16369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16370 int arg2 ;
16371 bool result;
16372 PyObject * obj0 = 0 ;
16373 PyObject * obj1 = 0 ;
16374 char *kwnames[] = {
16375 (char *) "self",(char *) "but", NULL
16376 };
16377
16378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16380 if (SWIG_arg_fail(1)) SWIG_fail;
16381 {
16382 arg2 = (int)(SWIG_As_int(obj1));
16383 if (SWIG_arg_fail(2)) SWIG_fail;
16384 }
16385 {
16386 PyThreadState* __tstate = wxPyBeginAllowThreads();
16387 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16388
16389 wxPyEndAllowThreads(__tstate);
16390 if (PyErr_Occurred()) SWIG_fail;
16391 }
16392 {
16393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16394 }
16395 return resultobj;
16396 fail:
16397 return NULL;
16398 }
16399
16400
16401 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16402 PyObject *resultobj;
16403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16404 int arg2 ;
16405 bool result;
16406 PyObject * obj0 = 0 ;
16407 PyObject * obj1 = 0 ;
16408 char *kwnames[] = {
16409 (char *) "self",(char *) "but", NULL
16410 };
16411
16412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16414 if (SWIG_arg_fail(1)) SWIG_fail;
16415 {
16416 arg2 = (int)(SWIG_As_int(obj1));
16417 if (SWIG_arg_fail(2)) SWIG_fail;
16418 }
16419 {
16420 PyThreadState* __tstate = wxPyBeginAllowThreads();
16421 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16422
16423 wxPyEndAllowThreads(__tstate);
16424 if (PyErr_Occurred()) SWIG_fail;
16425 }
16426 {
16427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16428 }
16429 return resultobj;
16430 fail:
16431 return NULL;
16432 }
16433
16434
16435 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16436 PyObject *resultobj;
16437 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16438 int result;
16439 PyObject * obj0 = 0 ;
16440 char *kwnames[] = {
16441 (char *) "self", NULL
16442 };
16443
16444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16446 if (SWIG_arg_fail(1)) SWIG_fail;
16447 {
16448 PyThreadState* __tstate = wxPyBeginAllowThreads();
16449 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16450
16451 wxPyEndAllowThreads(__tstate);
16452 if (PyErr_Occurred()) SWIG_fail;
16453 }
16454 {
16455 resultobj = SWIG_From_int((int)(result));
16456 }
16457 return resultobj;
16458 fail:
16459 return NULL;
16460 }
16461
16462
16463 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16464 PyObject *resultobj;
16465 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16466 bool result;
16467 PyObject * obj0 = 0 ;
16468 char *kwnames[] = {
16469 (char *) "self", NULL
16470 };
16471
16472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16474 if (SWIG_arg_fail(1)) SWIG_fail;
16475 {
16476 PyThreadState* __tstate = wxPyBeginAllowThreads();
16477 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16478
16479 wxPyEndAllowThreads(__tstate);
16480 if (PyErr_Occurred()) SWIG_fail;
16481 }
16482 {
16483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16484 }
16485 return resultobj;
16486 fail:
16487 return NULL;
16488 }
16489
16490
16491 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16492 PyObject *resultobj;
16493 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16494 bool result;
16495 PyObject * obj0 = 0 ;
16496 char *kwnames[] = {
16497 (char *) "self", NULL
16498 };
16499
16500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16502 if (SWIG_arg_fail(1)) SWIG_fail;
16503 {
16504 PyThreadState* __tstate = wxPyBeginAllowThreads();
16505 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16506
16507 wxPyEndAllowThreads(__tstate);
16508 if (PyErr_Occurred()) SWIG_fail;
16509 }
16510 {
16511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16512 }
16513 return resultobj;
16514 fail:
16515 return NULL;
16516 }
16517
16518
16519 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16520 PyObject *resultobj;
16521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16522 bool result;
16523 PyObject * obj0 = 0 ;
16524 char *kwnames[] = {
16525 (char *) "self", NULL
16526 };
16527
16528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16530 if (SWIG_arg_fail(1)) SWIG_fail;
16531 {
16532 PyThreadState* __tstate = wxPyBeginAllowThreads();
16533 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16534
16535 wxPyEndAllowThreads(__tstate);
16536 if (PyErr_Occurred()) SWIG_fail;
16537 }
16538 {
16539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16540 }
16541 return resultobj;
16542 fail:
16543 return NULL;
16544 }
16545
16546
16547 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16548 PyObject *resultobj;
16549 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16550 bool result;
16551 PyObject * obj0 = 0 ;
16552 char *kwnames[] = {
16553 (char *) "self", NULL
16554 };
16555
16556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16558 if (SWIG_arg_fail(1)) SWIG_fail;
16559 {
16560 PyThreadState* __tstate = wxPyBeginAllowThreads();
16561 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16562
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 {
16567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16568 }
16569 return resultobj;
16570 fail:
16571 return NULL;
16572 }
16573
16574
16575 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16576 PyObject *resultobj;
16577 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16578 bool result;
16579 PyObject * obj0 = 0 ;
16580 char *kwnames[] = {
16581 (char *) "self", NULL
16582 };
16583
16584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16586 if (SWIG_arg_fail(1)) SWIG_fail;
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16590
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 {
16595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16596 }
16597 return resultobj;
16598 fail:
16599 return NULL;
16600 }
16601
16602
16603 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16604 PyObject *resultobj;
16605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16606 bool result;
16607 PyObject * obj0 = 0 ;
16608 char *kwnames[] = {
16609 (char *) "self", NULL
16610 };
16611
16612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16614 if (SWIG_arg_fail(1)) SWIG_fail;
16615 {
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16618
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 {
16623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16624 }
16625 return resultobj;
16626 fail:
16627 return NULL;
16628 }
16629
16630
16631 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16632 PyObject *resultobj;
16633 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16634 bool result;
16635 PyObject * obj0 = 0 ;
16636 char *kwnames[] = {
16637 (char *) "self", NULL
16638 };
16639
16640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16642 if (SWIG_arg_fail(1)) SWIG_fail;
16643 {
16644 PyThreadState* __tstate = wxPyBeginAllowThreads();
16645 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16646
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 {
16651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16652 }
16653 return resultobj;
16654 fail:
16655 return NULL;
16656 }
16657
16658
16659 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16660 PyObject *resultobj;
16661 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16662 bool result;
16663 PyObject * obj0 = 0 ;
16664 char *kwnames[] = {
16665 (char *) "self", NULL
16666 };
16667
16668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16670 if (SWIG_arg_fail(1)) SWIG_fail;
16671 {
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16674
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 {
16679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16680 }
16681 return resultobj;
16682 fail:
16683 return NULL;
16684 }
16685
16686
16687 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16688 PyObject *resultobj;
16689 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16690 bool result;
16691 PyObject * obj0 = 0 ;
16692 char *kwnames[] = {
16693 (char *) "self", NULL
16694 };
16695
16696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16698 if (SWIG_arg_fail(1)) SWIG_fail;
16699 {
16700 PyThreadState* __tstate = wxPyBeginAllowThreads();
16701 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16702
16703 wxPyEndAllowThreads(__tstate);
16704 if (PyErr_Occurred()) SWIG_fail;
16705 }
16706 {
16707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16708 }
16709 return resultobj;
16710 fail:
16711 return NULL;
16712 }
16713
16714
16715 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16716 PyObject *resultobj;
16717 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16718 bool result;
16719 PyObject * obj0 = 0 ;
16720 char *kwnames[] = {
16721 (char *) "self", NULL
16722 };
16723
16724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16726 if (SWIG_arg_fail(1)) SWIG_fail;
16727 {
16728 PyThreadState* __tstate = wxPyBeginAllowThreads();
16729 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16730
16731 wxPyEndAllowThreads(__tstate);
16732 if (PyErr_Occurred()) SWIG_fail;
16733 }
16734 {
16735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16736 }
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16744 PyObject *resultobj;
16745 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16746 bool result;
16747 PyObject * obj0 = 0 ;
16748 char *kwnames[] = {
16749 (char *) "self", NULL
16750 };
16751
16752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16754 if (SWIG_arg_fail(1)) SWIG_fail;
16755 {
16756 PyThreadState* __tstate = wxPyBeginAllowThreads();
16757 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16758
16759 wxPyEndAllowThreads(__tstate);
16760 if (PyErr_Occurred()) SWIG_fail;
16761 }
16762 {
16763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16764 }
16765 return resultobj;
16766 fail:
16767 return NULL;
16768 }
16769
16770
16771 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16772 PyObject *resultobj;
16773 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16774 bool result;
16775 PyObject * obj0 = 0 ;
16776 char *kwnames[] = {
16777 (char *) "self", NULL
16778 };
16779
16780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16782 if (SWIG_arg_fail(1)) SWIG_fail;
16783 {
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16786
16787 wxPyEndAllowThreads(__tstate);
16788 if (PyErr_Occurred()) SWIG_fail;
16789 }
16790 {
16791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16792 }
16793 return resultobj;
16794 fail:
16795 return NULL;
16796 }
16797
16798
16799 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16800 PyObject *resultobj;
16801 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16802 bool result;
16803 PyObject * obj0 = 0 ;
16804 char *kwnames[] = {
16805 (char *) "self", NULL
16806 };
16807
16808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16810 if (SWIG_arg_fail(1)) SWIG_fail;
16811 {
16812 PyThreadState* __tstate = wxPyBeginAllowThreads();
16813 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16814
16815 wxPyEndAllowThreads(__tstate);
16816 if (PyErr_Occurred()) SWIG_fail;
16817 }
16818 {
16819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16820 }
16821 return resultobj;
16822 fail:
16823 return NULL;
16824 }
16825
16826
16827 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16828 PyObject *resultobj;
16829 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16830 bool result;
16831 PyObject * obj0 = 0 ;
16832 char *kwnames[] = {
16833 (char *) "self", NULL
16834 };
16835
16836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16838 if (SWIG_arg_fail(1)) SWIG_fail;
16839 {
16840 PyThreadState* __tstate = wxPyBeginAllowThreads();
16841 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16842
16843 wxPyEndAllowThreads(__tstate);
16844 if (PyErr_Occurred()) SWIG_fail;
16845 }
16846 {
16847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16848 }
16849 return resultobj;
16850 fail:
16851 return NULL;
16852 }
16853
16854
16855 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16856 PyObject *resultobj;
16857 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16858 bool result;
16859 PyObject * obj0 = 0 ;
16860 char *kwnames[] = {
16861 (char *) "self", NULL
16862 };
16863
16864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16866 if (SWIG_arg_fail(1)) SWIG_fail;
16867 {
16868 PyThreadState* __tstate = wxPyBeginAllowThreads();
16869 result = (bool)(arg1)->LeftIsDown();
16870
16871 wxPyEndAllowThreads(__tstate);
16872 if (PyErr_Occurred()) SWIG_fail;
16873 }
16874 {
16875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16876 }
16877 return resultobj;
16878 fail:
16879 return NULL;
16880 }
16881
16882
16883 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16884 PyObject *resultobj;
16885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16886 bool result;
16887 PyObject * obj0 = 0 ;
16888 char *kwnames[] = {
16889 (char *) "self", NULL
16890 };
16891
16892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16894 if (SWIG_arg_fail(1)) SWIG_fail;
16895 {
16896 PyThreadState* __tstate = wxPyBeginAllowThreads();
16897 result = (bool)(arg1)->MiddleIsDown();
16898
16899 wxPyEndAllowThreads(__tstate);
16900 if (PyErr_Occurred()) SWIG_fail;
16901 }
16902 {
16903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16904 }
16905 return resultobj;
16906 fail:
16907 return NULL;
16908 }
16909
16910
16911 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16912 PyObject *resultobj;
16913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16914 bool result;
16915 PyObject * obj0 = 0 ;
16916 char *kwnames[] = {
16917 (char *) "self", NULL
16918 };
16919
16920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16922 if (SWIG_arg_fail(1)) SWIG_fail;
16923 {
16924 PyThreadState* __tstate = wxPyBeginAllowThreads();
16925 result = (bool)(arg1)->RightIsDown();
16926
16927 wxPyEndAllowThreads(__tstate);
16928 if (PyErr_Occurred()) SWIG_fail;
16929 }
16930 {
16931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16932 }
16933 return resultobj;
16934 fail:
16935 return NULL;
16936 }
16937
16938
16939 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16940 PyObject *resultobj;
16941 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16942 bool result;
16943 PyObject * obj0 = 0 ;
16944 char *kwnames[] = {
16945 (char *) "self", NULL
16946 };
16947
16948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16950 if (SWIG_arg_fail(1)) SWIG_fail;
16951 {
16952 PyThreadState* __tstate = wxPyBeginAllowThreads();
16953 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16954
16955 wxPyEndAllowThreads(__tstate);
16956 if (PyErr_Occurred()) SWIG_fail;
16957 }
16958 {
16959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16960 }
16961 return resultobj;
16962 fail:
16963 return NULL;
16964 }
16965
16966
16967 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16968 PyObject *resultobj;
16969 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16970 bool result;
16971 PyObject * obj0 = 0 ;
16972 char *kwnames[] = {
16973 (char *) "self", NULL
16974 };
16975
16976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16978 if (SWIG_arg_fail(1)) SWIG_fail;
16979 {
16980 PyThreadState* __tstate = wxPyBeginAllowThreads();
16981 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16982
16983 wxPyEndAllowThreads(__tstate);
16984 if (PyErr_Occurred()) SWIG_fail;
16985 }
16986 {
16987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16988 }
16989 return resultobj;
16990 fail:
16991 return NULL;
16992 }
16993
16994
16995 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16996 PyObject *resultobj;
16997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16998 bool result;
16999 PyObject * obj0 = 0 ;
17000 char *kwnames[] = {
17001 (char *) "self", NULL
17002 };
17003
17004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17006 if (SWIG_arg_fail(1)) SWIG_fail;
17007 {
17008 PyThreadState* __tstate = wxPyBeginAllowThreads();
17009 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17010
17011 wxPyEndAllowThreads(__tstate);
17012 if (PyErr_Occurred()) SWIG_fail;
17013 }
17014 {
17015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17016 }
17017 return resultobj;
17018 fail:
17019 return NULL;
17020 }
17021
17022
17023 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17024 PyObject *resultobj;
17025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17026 bool result;
17027 PyObject * obj0 = 0 ;
17028 char *kwnames[] = {
17029 (char *) "self", NULL
17030 };
17031
17032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17034 if (SWIG_arg_fail(1)) SWIG_fail;
17035 {
17036 PyThreadState* __tstate = wxPyBeginAllowThreads();
17037 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17038
17039 wxPyEndAllowThreads(__tstate);
17040 if (PyErr_Occurred()) SWIG_fail;
17041 }
17042 {
17043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17044 }
17045 return resultobj;
17046 fail:
17047 return NULL;
17048 }
17049
17050
17051 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17052 PyObject *resultobj;
17053 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17054 wxPoint result;
17055 PyObject * obj0 = 0 ;
17056 char *kwnames[] = {
17057 (char *) "self", NULL
17058 };
17059
17060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17062 if (SWIG_arg_fail(1)) SWIG_fail;
17063 {
17064 PyThreadState* __tstate = wxPyBeginAllowThreads();
17065 result = (arg1)->GetPosition();
17066
17067 wxPyEndAllowThreads(__tstate);
17068 if (PyErr_Occurred()) SWIG_fail;
17069 }
17070 {
17071 wxPoint * resultptr;
17072 resultptr = new wxPoint((wxPoint &)(result));
17073 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17074 }
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17082 PyObject *resultobj;
17083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17084 long *arg2 = (long *) 0 ;
17085 long *arg3 = (long *) 0 ;
17086 long temp2 ;
17087 int res2 = 0 ;
17088 long temp3 ;
17089 int res3 = 0 ;
17090 PyObject * obj0 = 0 ;
17091 char *kwnames[] = {
17092 (char *) "self", NULL
17093 };
17094
17095 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17096 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17099 if (SWIG_arg_fail(1)) SWIG_fail;
17100 {
17101 PyThreadState* __tstate = wxPyBeginAllowThreads();
17102 (arg1)->GetPosition(arg2,arg3);
17103
17104 wxPyEndAllowThreads(__tstate);
17105 if (PyErr_Occurred()) SWIG_fail;
17106 }
17107 Py_INCREF(Py_None); resultobj = Py_None;
17108 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17109 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17110 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17111 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17112 return resultobj;
17113 fail:
17114 return NULL;
17115 }
17116
17117
17118 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17119 PyObject *resultobj;
17120 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17121 wxDC *arg2 = 0 ;
17122 wxPoint result;
17123 PyObject * obj0 = 0 ;
17124 PyObject * obj1 = 0 ;
17125 char *kwnames[] = {
17126 (char *) "self",(char *) "dc", NULL
17127 };
17128
17129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17131 if (SWIG_arg_fail(1)) SWIG_fail;
17132 {
17133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17134 if (SWIG_arg_fail(2)) SWIG_fail;
17135 if (arg2 == NULL) {
17136 SWIG_null_ref("wxDC");
17137 }
17138 if (SWIG_arg_fail(2)) SWIG_fail;
17139 }
17140 {
17141 PyThreadState* __tstate = wxPyBeginAllowThreads();
17142 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17143
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 {
17148 wxPoint * resultptr;
17149 resultptr = new wxPoint((wxPoint &)(result));
17150 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17151 }
17152 return resultobj;
17153 fail:
17154 return NULL;
17155 }
17156
17157
17158 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17159 PyObject *resultobj;
17160 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17161 int result;
17162 PyObject * obj0 = 0 ;
17163 char *kwnames[] = {
17164 (char *) "self", NULL
17165 };
17166
17167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17169 if (SWIG_arg_fail(1)) SWIG_fail;
17170 {
17171 PyThreadState* __tstate = wxPyBeginAllowThreads();
17172 result = (int)((wxMouseEvent const *)arg1)->GetX();
17173
17174 wxPyEndAllowThreads(__tstate);
17175 if (PyErr_Occurred()) SWIG_fail;
17176 }
17177 {
17178 resultobj = SWIG_From_int((int)(result));
17179 }
17180 return resultobj;
17181 fail:
17182 return NULL;
17183 }
17184
17185
17186 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17187 PyObject *resultobj;
17188 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17189 int result;
17190 PyObject * obj0 = 0 ;
17191 char *kwnames[] = {
17192 (char *) "self", NULL
17193 };
17194
17195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17197 if (SWIG_arg_fail(1)) SWIG_fail;
17198 {
17199 PyThreadState* __tstate = wxPyBeginAllowThreads();
17200 result = (int)((wxMouseEvent const *)arg1)->GetY();
17201
17202 wxPyEndAllowThreads(__tstate);
17203 if (PyErr_Occurred()) SWIG_fail;
17204 }
17205 {
17206 resultobj = SWIG_From_int((int)(result));
17207 }
17208 return resultobj;
17209 fail:
17210 return NULL;
17211 }
17212
17213
17214 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17215 PyObject *resultobj;
17216 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17217 int result;
17218 PyObject * obj0 = 0 ;
17219 char *kwnames[] = {
17220 (char *) "self", NULL
17221 };
17222
17223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",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 {
17227 PyThreadState* __tstate = wxPyBeginAllowThreads();
17228 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17229
17230 wxPyEndAllowThreads(__tstate);
17231 if (PyErr_Occurred()) SWIG_fail;
17232 }
17233 {
17234 resultobj = SWIG_From_int((int)(result));
17235 }
17236 return resultobj;
17237 fail:
17238 return NULL;
17239 }
17240
17241
17242 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17243 PyObject *resultobj;
17244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17245 int result;
17246 PyObject * obj0 = 0 ;
17247 char *kwnames[] = {
17248 (char *) "self", NULL
17249 };
17250
17251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17253 if (SWIG_arg_fail(1)) SWIG_fail;
17254 {
17255 PyThreadState* __tstate = wxPyBeginAllowThreads();
17256 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17257
17258 wxPyEndAllowThreads(__tstate);
17259 if (PyErr_Occurred()) SWIG_fail;
17260 }
17261 {
17262 resultobj = SWIG_From_int((int)(result));
17263 }
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj;
17272 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17273 int result;
17274 PyObject * obj0 = 0 ;
17275 char *kwnames[] = {
17276 (char *) "self", NULL
17277 };
17278
17279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17281 if (SWIG_arg_fail(1)) SWIG_fail;
17282 {
17283 PyThreadState* __tstate = wxPyBeginAllowThreads();
17284 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17285
17286 wxPyEndAllowThreads(__tstate);
17287 if (PyErr_Occurred()) SWIG_fail;
17288 }
17289 {
17290 resultobj = SWIG_From_int((int)(result));
17291 }
17292 return resultobj;
17293 fail:
17294 return NULL;
17295 }
17296
17297
17298 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17299 PyObject *resultobj;
17300 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17301 bool result;
17302 PyObject * obj0 = 0 ;
17303 char *kwnames[] = {
17304 (char *) "self", NULL
17305 };
17306
17307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17309 if (SWIG_arg_fail(1)) SWIG_fail;
17310 {
17311 PyThreadState* __tstate = wxPyBeginAllowThreads();
17312 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17313
17314 wxPyEndAllowThreads(__tstate);
17315 if (PyErr_Occurred()) SWIG_fail;
17316 }
17317 {
17318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17319 }
17320 return resultobj;
17321 fail:
17322 return NULL;
17323 }
17324
17325
17326 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17327 PyObject *resultobj;
17328 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17329 int arg2 ;
17330 PyObject * obj0 = 0 ;
17331 PyObject * obj1 = 0 ;
17332 char *kwnames[] = {
17333 (char *) "self",(char *) "m_x", NULL
17334 };
17335
17336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17338 if (SWIG_arg_fail(1)) SWIG_fail;
17339 {
17340 arg2 = (int)(SWIG_As_int(obj1));
17341 if (SWIG_arg_fail(2)) SWIG_fail;
17342 }
17343 if (arg1) (arg1)->m_x = arg2;
17344
17345 Py_INCREF(Py_None); resultobj = Py_None;
17346 return resultobj;
17347 fail:
17348 return NULL;
17349 }
17350
17351
17352 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17353 PyObject *resultobj;
17354 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17355 int result;
17356 PyObject * obj0 = 0 ;
17357 char *kwnames[] = {
17358 (char *) "self", NULL
17359 };
17360
17361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17363 if (SWIG_arg_fail(1)) SWIG_fail;
17364 result = (int) ((arg1)->m_x);
17365
17366 {
17367 resultobj = SWIG_From_int((int)(result));
17368 }
17369 return resultobj;
17370 fail:
17371 return NULL;
17372 }
17373
17374
17375 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17376 PyObject *resultobj;
17377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17378 int arg2 ;
17379 PyObject * obj0 = 0 ;
17380 PyObject * obj1 = 0 ;
17381 char *kwnames[] = {
17382 (char *) "self",(char *) "m_y", NULL
17383 };
17384
17385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17387 if (SWIG_arg_fail(1)) SWIG_fail;
17388 {
17389 arg2 = (int)(SWIG_As_int(obj1));
17390 if (SWIG_arg_fail(2)) SWIG_fail;
17391 }
17392 if (arg1) (arg1)->m_y = arg2;
17393
17394 Py_INCREF(Py_None); resultobj = Py_None;
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17404 int result;
17405 PyObject * obj0 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 result = (int) ((arg1)->m_y);
17414
17415 {
17416 resultobj = SWIG_From_int((int)(result));
17417 }
17418 return resultobj;
17419 fail:
17420 return NULL;
17421 }
17422
17423
17424 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17425 PyObject *resultobj;
17426 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17427 bool arg2 ;
17428 PyObject * obj0 = 0 ;
17429 PyObject * obj1 = 0 ;
17430 char *kwnames[] = {
17431 (char *) "self",(char *) "m_leftDown", NULL
17432 };
17433
17434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17436 if (SWIG_arg_fail(1)) SWIG_fail;
17437 {
17438 arg2 = (bool)(SWIG_As_bool(obj1));
17439 if (SWIG_arg_fail(2)) SWIG_fail;
17440 }
17441 if (arg1) (arg1)->m_leftDown = arg2;
17442
17443 Py_INCREF(Py_None); resultobj = Py_None;
17444 return resultobj;
17445 fail:
17446 return NULL;
17447 }
17448
17449
17450 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17451 PyObject *resultobj;
17452 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17453 bool result;
17454 PyObject * obj0 = 0 ;
17455 char *kwnames[] = {
17456 (char *) "self", NULL
17457 };
17458
17459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17461 if (SWIG_arg_fail(1)) SWIG_fail;
17462 result = (bool) ((arg1)->m_leftDown);
17463
17464 {
17465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17466 }
17467 return resultobj;
17468 fail:
17469 return NULL;
17470 }
17471
17472
17473 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17474 PyObject *resultobj;
17475 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17476 bool arg2 ;
17477 PyObject * obj0 = 0 ;
17478 PyObject * obj1 = 0 ;
17479 char *kwnames[] = {
17480 (char *) "self",(char *) "m_middleDown", NULL
17481 };
17482
17483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17485 if (SWIG_arg_fail(1)) SWIG_fail;
17486 {
17487 arg2 = (bool)(SWIG_As_bool(obj1));
17488 if (SWIG_arg_fail(2)) SWIG_fail;
17489 }
17490 if (arg1) (arg1)->m_middleDown = arg2;
17491
17492 Py_INCREF(Py_None); resultobj = Py_None;
17493 return resultobj;
17494 fail:
17495 return NULL;
17496 }
17497
17498
17499 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj;
17501 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17502 bool result;
17503 PyObject * obj0 = 0 ;
17504 char *kwnames[] = {
17505 (char *) "self", NULL
17506 };
17507
17508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17510 if (SWIG_arg_fail(1)) SWIG_fail;
17511 result = (bool) ((arg1)->m_middleDown);
17512
17513 {
17514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17515 }
17516 return resultobj;
17517 fail:
17518 return NULL;
17519 }
17520
17521
17522 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17523 PyObject *resultobj;
17524 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17525 bool arg2 ;
17526 PyObject * obj0 = 0 ;
17527 PyObject * obj1 = 0 ;
17528 char *kwnames[] = {
17529 (char *) "self",(char *) "m_rightDown", NULL
17530 };
17531
17532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17534 if (SWIG_arg_fail(1)) SWIG_fail;
17535 {
17536 arg2 = (bool)(SWIG_As_bool(obj1));
17537 if (SWIG_arg_fail(2)) SWIG_fail;
17538 }
17539 if (arg1) (arg1)->m_rightDown = arg2;
17540
17541 Py_INCREF(Py_None); resultobj = Py_None;
17542 return resultobj;
17543 fail:
17544 return NULL;
17545 }
17546
17547
17548 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17549 PyObject *resultobj;
17550 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17551 bool result;
17552 PyObject * obj0 = 0 ;
17553 char *kwnames[] = {
17554 (char *) "self", NULL
17555 };
17556
17557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17559 if (SWIG_arg_fail(1)) SWIG_fail;
17560 result = (bool) ((arg1)->m_rightDown);
17561
17562 {
17563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17564 }
17565 return resultobj;
17566 fail:
17567 return NULL;
17568 }
17569
17570
17571 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17572 PyObject *resultobj;
17573 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17574 bool arg2 ;
17575 PyObject * obj0 = 0 ;
17576 PyObject * obj1 = 0 ;
17577 char *kwnames[] = {
17578 (char *) "self",(char *) "m_controlDown", NULL
17579 };
17580
17581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17583 if (SWIG_arg_fail(1)) SWIG_fail;
17584 {
17585 arg2 = (bool)(SWIG_As_bool(obj1));
17586 if (SWIG_arg_fail(2)) SWIG_fail;
17587 }
17588 if (arg1) (arg1)->m_controlDown = arg2;
17589
17590 Py_INCREF(Py_None); resultobj = Py_None;
17591 return resultobj;
17592 fail:
17593 return NULL;
17594 }
17595
17596
17597 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17598 PyObject *resultobj;
17599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17600 bool result;
17601 PyObject * obj0 = 0 ;
17602 char *kwnames[] = {
17603 (char *) "self", NULL
17604 };
17605
17606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17608 if (SWIG_arg_fail(1)) SWIG_fail;
17609 result = (bool) ((arg1)->m_controlDown);
17610
17611 {
17612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17613 }
17614 return resultobj;
17615 fail:
17616 return NULL;
17617 }
17618
17619
17620 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17621 PyObject *resultobj;
17622 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17623 bool arg2 ;
17624 PyObject * obj0 = 0 ;
17625 PyObject * obj1 = 0 ;
17626 char *kwnames[] = {
17627 (char *) "self",(char *) "m_shiftDown", NULL
17628 };
17629
17630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17632 if (SWIG_arg_fail(1)) SWIG_fail;
17633 {
17634 arg2 = (bool)(SWIG_As_bool(obj1));
17635 if (SWIG_arg_fail(2)) SWIG_fail;
17636 }
17637 if (arg1) (arg1)->m_shiftDown = arg2;
17638
17639 Py_INCREF(Py_None); resultobj = Py_None;
17640 return resultobj;
17641 fail:
17642 return NULL;
17643 }
17644
17645
17646 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17647 PyObject *resultobj;
17648 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17649 bool result;
17650 PyObject * obj0 = 0 ;
17651 char *kwnames[] = {
17652 (char *) "self", NULL
17653 };
17654
17655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17657 if (SWIG_arg_fail(1)) SWIG_fail;
17658 result = (bool) ((arg1)->m_shiftDown);
17659
17660 {
17661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17662 }
17663 return resultobj;
17664 fail:
17665 return NULL;
17666 }
17667
17668
17669 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17670 PyObject *resultobj;
17671 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17672 bool arg2 ;
17673 PyObject * obj0 = 0 ;
17674 PyObject * obj1 = 0 ;
17675 char *kwnames[] = {
17676 (char *) "self",(char *) "m_altDown", NULL
17677 };
17678
17679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17681 if (SWIG_arg_fail(1)) SWIG_fail;
17682 {
17683 arg2 = (bool)(SWIG_As_bool(obj1));
17684 if (SWIG_arg_fail(2)) SWIG_fail;
17685 }
17686 if (arg1) (arg1)->m_altDown = arg2;
17687
17688 Py_INCREF(Py_None); resultobj = Py_None;
17689 return resultobj;
17690 fail:
17691 return NULL;
17692 }
17693
17694
17695 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17696 PyObject *resultobj;
17697 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17698 bool result;
17699 PyObject * obj0 = 0 ;
17700 char *kwnames[] = {
17701 (char *) "self", NULL
17702 };
17703
17704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17706 if (SWIG_arg_fail(1)) SWIG_fail;
17707 result = (bool) ((arg1)->m_altDown);
17708
17709 {
17710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17711 }
17712 return resultobj;
17713 fail:
17714 return NULL;
17715 }
17716
17717
17718 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17719 PyObject *resultobj;
17720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17721 bool arg2 ;
17722 PyObject * obj0 = 0 ;
17723 PyObject * obj1 = 0 ;
17724 char *kwnames[] = {
17725 (char *) "self",(char *) "m_metaDown", NULL
17726 };
17727
17728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17730 if (SWIG_arg_fail(1)) SWIG_fail;
17731 {
17732 arg2 = (bool)(SWIG_As_bool(obj1));
17733 if (SWIG_arg_fail(2)) SWIG_fail;
17734 }
17735 if (arg1) (arg1)->m_metaDown = arg2;
17736
17737 Py_INCREF(Py_None); resultobj = Py_None;
17738 return resultobj;
17739 fail:
17740 return NULL;
17741 }
17742
17743
17744 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17745 PyObject *resultobj;
17746 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17747 bool result;
17748 PyObject * obj0 = 0 ;
17749 char *kwnames[] = {
17750 (char *) "self", NULL
17751 };
17752
17753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17755 if (SWIG_arg_fail(1)) SWIG_fail;
17756 result = (bool) ((arg1)->m_metaDown);
17757
17758 {
17759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17760 }
17761 return resultobj;
17762 fail:
17763 return NULL;
17764 }
17765
17766
17767 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17768 PyObject *resultobj;
17769 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17770 int arg2 ;
17771 PyObject * obj0 = 0 ;
17772 PyObject * obj1 = 0 ;
17773 char *kwnames[] = {
17774 (char *) "self",(char *) "m_wheelRotation", NULL
17775 };
17776
17777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17779 if (SWIG_arg_fail(1)) SWIG_fail;
17780 {
17781 arg2 = (int)(SWIG_As_int(obj1));
17782 if (SWIG_arg_fail(2)) SWIG_fail;
17783 }
17784 if (arg1) (arg1)->m_wheelRotation = arg2;
17785
17786 Py_INCREF(Py_None); resultobj = Py_None;
17787 return resultobj;
17788 fail:
17789 return NULL;
17790 }
17791
17792
17793 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17794 PyObject *resultobj;
17795 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17796 int result;
17797 PyObject * obj0 = 0 ;
17798 char *kwnames[] = {
17799 (char *) "self", NULL
17800 };
17801
17802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17804 if (SWIG_arg_fail(1)) SWIG_fail;
17805 result = (int) ((arg1)->m_wheelRotation);
17806
17807 {
17808 resultobj = SWIG_From_int((int)(result));
17809 }
17810 return resultobj;
17811 fail:
17812 return NULL;
17813 }
17814
17815
17816 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17817 PyObject *resultobj;
17818 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17819 int arg2 ;
17820 PyObject * obj0 = 0 ;
17821 PyObject * obj1 = 0 ;
17822 char *kwnames[] = {
17823 (char *) "self",(char *) "m_wheelDelta", NULL
17824 };
17825
17826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17828 if (SWIG_arg_fail(1)) SWIG_fail;
17829 {
17830 arg2 = (int)(SWIG_As_int(obj1));
17831 if (SWIG_arg_fail(2)) SWIG_fail;
17832 }
17833 if (arg1) (arg1)->m_wheelDelta = arg2;
17834
17835 Py_INCREF(Py_None); resultobj = Py_None;
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17843 PyObject *resultobj;
17844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17845 int result;
17846 PyObject * obj0 = 0 ;
17847 char *kwnames[] = {
17848 (char *) "self", NULL
17849 };
17850
17851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17853 if (SWIG_arg_fail(1)) SWIG_fail;
17854 result = (int) ((arg1)->m_wheelDelta);
17855
17856 {
17857 resultobj = SWIG_From_int((int)(result));
17858 }
17859 return resultobj;
17860 fail:
17861 return NULL;
17862 }
17863
17864
17865 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17866 PyObject *resultobj;
17867 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17868 int arg2 ;
17869 PyObject * obj0 = 0 ;
17870 PyObject * obj1 = 0 ;
17871 char *kwnames[] = {
17872 (char *) "self",(char *) "m_linesPerAction", NULL
17873 };
17874
17875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17877 if (SWIG_arg_fail(1)) SWIG_fail;
17878 {
17879 arg2 = (int)(SWIG_As_int(obj1));
17880 if (SWIG_arg_fail(2)) SWIG_fail;
17881 }
17882 if (arg1) (arg1)->m_linesPerAction = arg2;
17883
17884 Py_INCREF(Py_None); resultobj = Py_None;
17885 return resultobj;
17886 fail:
17887 return NULL;
17888 }
17889
17890
17891 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17892 PyObject *resultobj;
17893 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17894 int result;
17895 PyObject * obj0 = 0 ;
17896 char *kwnames[] = {
17897 (char *) "self", NULL
17898 };
17899
17900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17902 if (SWIG_arg_fail(1)) SWIG_fail;
17903 result = (int) ((arg1)->m_linesPerAction);
17904
17905 {
17906 resultobj = SWIG_From_int((int)(result));
17907 }
17908 return resultobj;
17909 fail:
17910 return NULL;
17911 }
17912
17913
17914 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17915 PyObject *obj;
17916 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17917 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17918 Py_INCREF(obj);
17919 return Py_BuildValue((char *)"");
17920 }
17921 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17922 PyObject *resultobj;
17923 int arg1 = (int) 0 ;
17924 int arg2 = (int) 0 ;
17925 wxSetCursorEvent *result;
17926 PyObject * obj0 = 0 ;
17927 PyObject * obj1 = 0 ;
17928 char *kwnames[] = {
17929 (char *) "x",(char *) "y", NULL
17930 };
17931
17932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17933 if (obj0) {
17934 {
17935 arg1 = (int)(SWIG_As_int(obj0));
17936 if (SWIG_arg_fail(1)) SWIG_fail;
17937 }
17938 }
17939 if (obj1) {
17940 {
17941 arg2 = (int)(SWIG_As_int(obj1));
17942 if (SWIG_arg_fail(2)) SWIG_fail;
17943 }
17944 }
17945 {
17946 PyThreadState* __tstate = wxPyBeginAllowThreads();
17947 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17948
17949 wxPyEndAllowThreads(__tstate);
17950 if (PyErr_Occurred()) SWIG_fail;
17951 }
17952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17953 return resultobj;
17954 fail:
17955 return NULL;
17956 }
17957
17958
17959 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17960 PyObject *resultobj;
17961 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17962 int result;
17963 PyObject * obj0 = 0 ;
17964 char *kwnames[] = {
17965 (char *) "self", NULL
17966 };
17967
17968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17970 if (SWIG_arg_fail(1)) SWIG_fail;
17971 {
17972 PyThreadState* __tstate = wxPyBeginAllowThreads();
17973 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17974
17975 wxPyEndAllowThreads(__tstate);
17976 if (PyErr_Occurred()) SWIG_fail;
17977 }
17978 {
17979 resultobj = SWIG_From_int((int)(result));
17980 }
17981 return resultobj;
17982 fail:
17983 return NULL;
17984 }
17985
17986
17987 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17988 PyObject *resultobj;
17989 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17990 int result;
17991 PyObject * obj0 = 0 ;
17992 char *kwnames[] = {
17993 (char *) "self", NULL
17994 };
17995
17996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17998 if (SWIG_arg_fail(1)) SWIG_fail;
17999 {
18000 PyThreadState* __tstate = wxPyBeginAllowThreads();
18001 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18002
18003 wxPyEndAllowThreads(__tstate);
18004 if (PyErr_Occurred()) SWIG_fail;
18005 }
18006 {
18007 resultobj = SWIG_From_int((int)(result));
18008 }
18009 return resultobj;
18010 fail:
18011 return NULL;
18012 }
18013
18014
18015 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18016 PyObject *resultobj;
18017 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18018 wxCursor *arg2 = 0 ;
18019 PyObject * obj0 = 0 ;
18020 PyObject * obj1 = 0 ;
18021 char *kwnames[] = {
18022 (char *) "self",(char *) "cursor", NULL
18023 };
18024
18025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18027 if (SWIG_arg_fail(1)) SWIG_fail;
18028 {
18029 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18030 if (SWIG_arg_fail(2)) SWIG_fail;
18031 if (arg2 == NULL) {
18032 SWIG_null_ref("wxCursor");
18033 }
18034 if (SWIG_arg_fail(2)) SWIG_fail;
18035 }
18036 {
18037 PyThreadState* __tstate = wxPyBeginAllowThreads();
18038 (arg1)->SetCursor((wxCursor const &)*arg2);
18039
18040 wxPyEndAllowThreads(__tstate);
18041 if (PyErr_Occurred()) SWIG_fail;
18042 }
18043 Py_INCREF(Py_None); resultobj = Py_None;
18044 return resultobj;
18045 fail:
18046 return NULL;
18047 }
18048
18049
18050 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18051 PyObject *resultobj;
18052 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18053 wxCursor *result;
18054 PyObject * obj0 = 0 ;
18055 char *kwnames[] = {
18056 (char *) "self", NULL
18057 };
18058
18059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18061 if (SWIG_arg_fail(1)) SWIG_fail;
18062 {
18063 PyThreadState* __tstate = wxPyBeginAllowThreads();
18064 {
18065 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18066 result = (wxCursor *) &_result_ref;
18067 }
18068
18069 wxPyEndAllowThreads(__tstate);
18070 if (PyErr_Occurred()) SWIG_fail;
18071 }
18072 {
18073 wxCursor* resultptr = new wxCursor(*result);
18074 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18075 }
18076 return resultobj;
18077 fail:
18078 return NULL;
18079 }
18080
18081
18082 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18083 PyObject *resultobj;
18084 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18085 bool result;
18086 PyObject * obj0 = 0 ;
18087 char *kwnames[] = {
18088 (char *) "self", NULL
18089 };
18090
18091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18093 if (SWIG_arg_fail(1)) SWIG_fail;
18094 {
18095 PyThreadState* __tstate = wxPyBeginAllowThreads();
18096 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18097
18098 wxPyEndAllowThreads(__tstate);
18099 if (PyErr_Occurred()) SWIG_fail;
18100 }
18101 {
18102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18103 }
18104 return resultobj;
18105 fail:
18106 return NULL;
18107 }
18108
18109
18110 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18111 PyObject *obj;
18112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18113 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18114 Py_INCREF(obj);
18115 return Py_BuildValue((char *)"");
18116 }
18117 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18118 PyObject *resultobj;
18119 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18120 wxKeyEvent *result;
18121 PyObject * obj0 = 0 ;
18122 char *kwnames[] = {
18123 (char *) "keyType", NULL
18124 };
18125
18126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18127 if (obj0) {
18128 {
18129 arg1 = (wxEventType)(SWIG_As_int(obj0));
18130 if (SWIG_arg_fail(1)) SWIG_fail;
18131 }
18132 }
18133 {
18134 PyThreadState* __tstate = wxPyBeginAllowThreads();
18135 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18136
18137 wxPyEndAllowThreads(__tstate);
18138 if (PyErr_Occurred()) SWIG_fail;
18139 }
18140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18141 return resultobj;
18142 fail:
18143 return NULL;
18144 }
18145
18146
18147 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18148 PyObject *resultobj;
18149 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18150 bool result;
18151 PyObject * obj0 = 0 ;
18152 char *kwnames[] = {
18153 (char *) "self", NULL
18154 };
18155
18156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18158 if (SWIG_arg_fail(1)) SWIG_fail;
18159 {
18160 PyThreadState* __tstate = wxPyBeginAllowThreads();
18161 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18162
18163 wxPyEndAllowThreads(__tstate);
18164 if (PyErr_Occurred()) SWIG_fail;
18165 }
18166 {
18167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18168 }
18169 return resultobj;
18170 fail:
18171 return NULL;
18172 }
18173
18174
18175 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18176 PyObject *resultobj;
18177 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18178 bool result;
18179 PyObject * obj0 = 0 ;
18180 char *kwnames[] = {
18181 (char *) "self", NULL
18182 };
18183
18184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18186 if (SWIG_arg_fail(1)) SWIG_fail;
18187 {
18188 PyThreadState* __tstate = wxPyBeginAllowThreads();
18189 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18190
18191 wxPyEndAllowThreads(__tstate);
18192 if (PyErr_Occurred()) SWIG_fail;
18193 }
18194 {
18195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18196 }
18197 return resultobj;
18198 fail:
18199 return NULL;
18200 }
18201
18202
18203 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18204 PyObject *resultobj;
18205 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18206 bool result;
18207 PyObject * obj0 = 0 ;
18208 char *kwnames[] = {
18209 (char *) "self", NULL
18210 };
18211
18212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18214 if (SWIG_arg_fail(1)) SWIG_fail;
18215 {
18216 PyThreadState* __tstate = wxPyBeginAllowThreads();
18217 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18218
18219 wxPyEndAllowThreads(__tstate);
18220 if (PyErr_Occurred()) SWIG_fail;
18221 }
18222 {
18223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18224 }
18225 return resultobj;
18226 fail:
18227 return NULL;
18228 }
18229
18230
18231 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18232 PyObject *resultobj;
18233 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18234 bool result;
18235 PyObject * obj0 = 0 ;
18236 char *kwnames[] = {
18237 (char *) "self", NULL
18238 };
18239
18240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18242 if (SWIG_arg_fail(1)) SWIG_fail;
18243 {
18244 PyThreadState* __tstate = wxPyBeginAllowThreads();
18245 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18246
18247 wxPyEndAllowThreads(__tstate);
18248 if (PyErr_Occurred()) SWIG_fail;
18249 }
18250 {
18251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18252 }
18253 return resultobj;
18254 fail:
18255 return NULL;
18256 }
18257
18258
18259 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18260 PyObject *resultobj;
18261 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18262 bool result;
18263 PyObject * obj0 = 0 ;
18264 char *kwnames[] = {
18265 (char *) "self", NULL
18266 };
18267
18268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18270 if (SWIG_arg_fail(1)) SWIG_fail;
18271 {
18272 PyThreadState* __tstate = wxPyBeginAllowThreads();
18273 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18274
18275 wxPyEndAllowThreads(__tstate);
18276 if (PyErr_Occurred()) SWIG_fail;
18277 }
18278 {
18279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18280 }
18281 return resultobj;
18282 fail:
18283 return NULL;
18284 }
18285
18286
18287 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18288 PyObject *resultobj;
18289 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18290 bool result;
18291 PyObject * obj0 = 0 ;
18292 char *kwnames[] = {
18293 (char *) "self", NULL
18294 };
18295
18296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18298 if (SWIG_arg_fail(1)) SWIG_fail;
18299 {
18300 PyThreadState* __tstate = wxPyBeginAllowThreads();
18301 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18302
18303 wxPyEndAllowThreads(__tstate);
18304 if (PyErr_Occurred()) SWIG_fail;
18305 }
18306 {
18307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18308 }
18309 return resultobj;
18310 fail:
18311 return NULL;
18312 }
18313
18314
18315 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18316 PyObject *resultobj;
18317 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18318 int result;
18319 PyObject * obj0 = 0 ;
18320 char *kwnames[] = {
18321 (char *) "self", NULL
18322 };
18323
18324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
18329 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18330
18331 wxPyEndAllowThreads(__tstate);
18332 if (PyErr_Occurred()) SWIG_fail;
18333 }
18334 {
18335 resultobj = SWIG_From_int((int)(result));
18336 }
18337 return resultobj;
18338 fail:
18339 return NULL;
18340 }
18341
18342
18343 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18344 PyObject *resultobj;
18345 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18346 int result;
18347 PyObject * obj0 = 0 ;
18348 char *kwnames[] = {
18349 (char *) "self", NULL
18350 };
18351
18352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18354 if (SWIG_arg_fail(1)) SWIG_fail;
18355 {
18356 PyThreadState* __tstate = wxPyBeginAllowThreads();
18357 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18358
18359 wxPyEndAllowThreads(__tstate);
18360 if (PyErr_Occurred()) SWIG_fail;
18361 }
18362 {
18363 resultobj = SWIG_From_int((int)(result));
18364 }
18365 return resultobj;
18366 fail:
18367 return NULL;
18368 }
18369
18370
18371 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18372 PyObject *resultobj;
18373 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18374 unsigned int result;
18375 PyObject * obj0 = 0 ;
18376 char *kwnames[] = {
18377 (char *) "self", NULL
18378 };
18379
18380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18382 if (SWIG_arg_fail(1)) SWIG_fail;
18383 {
18384 PyThreadState* __tstate = wxPyBeginAllowThreads();
18385 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18386
18387 wxPyEndAllowThreads(__tstate);
18388 if (PyErr_Occurred()) SWIG_fail;
18389 }
18390 {
18391 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18392 }
18393 return resultobj;
18394 fail:
18395 return NULL;
18396 }
18397
18398
18399 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18400 PyObject *resultobj;
18401 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18402 unsigned int result;
18403 PyObject * obj0 = 0 ;
18404 char *kwnames[] = {
18405 (char *) "self", NULL
18406 };
18407
18408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18410 if (SWIG_arg_fail(1)) SWIG_fail;
18411 {
18412 PyThreadState* __tstate = wxPyBeginAllowThreads();
18413 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18414
18415 wxPyEndAllowThreads(__tstate);
18416 if (PyErr_Occurred()) SWIG_fail;
18417 }
18418 {
18419 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18420 }
18421 return resultobj;
18422 fail:
18423 return NULL;
18424 }
18425
18426
18427 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18428 PyObject *resultobj;
18429 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18430 wxPoint result;
18431 PyObject * obj0 = 0 ;
18432 char *kwnames[] = {
18433 (char *) "self", NULL
18434 };
18435
18436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18438 if (SWIG_arg_fail(1)) SWIG_fail;
18439 {
18440 PyThreadState* __tstate = wxPyBeginAllowThreads();
18441 result = (arg1)->GetPosition();
18442
18443 wxPyEndAllowThreads(__tstate);
18444 if (PyErr_Occurred()) SWIG_fail;
18445 }
18446 {
18447 wxPoint * resultptr;
18448 resultptr = new wxPoint((wxPoint &)(result));
18449 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18450 }
18451 return resultobj;
18452 fail:
18453 return NULL;
18454 }
18455
18456
18457 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18458 PyObject *resultobj;
18459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18460 long *arg2 = (long *) 0 ;
18461 long *arg3 = (long *) 0 ;
18462 long temp2 ;
18463 int res2 = 0 ;
18464 long temp3 ;
18465 int res3 = 0 ;
18466 PyObject * obj0 = 0 ;
18467 char *kwnames[] = {
18468 (char *) "self", NULL
18469 };
18470
18471 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18472 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18475 if (SWIG_arg_fail(1)) SWIG_fail;
18476 {
18477 PyThreadState* __tstate = wxPyBeginAllowThreads();
18478 (arg1)->GetPosition(arg2,arg3);
18479
18480 wxPyEndAllowThreads(__tstate);
18481 if (PyErr_Occurred()) SWIG_fail;
18482 }
18483 Py_INCREF(Py_None); resultobj = Py_None;
18484 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18485 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18486 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18487 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18488 return resultobj;
18489 fail:
18490 return NULL;
18491 }
18492
18493
18494 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18495 PyObject *resultobj;
18496 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18497 int result;
18498 PyObject * obj0 = 0 ;
18499 char *kwnames[] = {
18500 (char *) "self", NULL
18501 };
18502
18503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18505 if (SWIG_arg_fail(1)) SWIG_fail;
18506 {
18507 PyThreadState* __tstate = wxPyBeginAllowThreads();
18508 result = (int)((wxKeyEvent const *)arg1)->GetX();
18509
18510 wxPyEndAllowThreads(__tstate);
18511 if (PyErr_Occurred()) SWIG_fail;
18512 }
18513 {
18514 resultobj = SWIG_From_int((int)(result));
18515 }
18516 return resultobj;
18517 fail:
18518 return NULL;
18519 }
18520
18521
18522 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18523 PyObject *resultobj;
18524 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18525 int result;
18526 PyObject * obj0 = 0 ;
18527 char *kwnames[] = {
18528 (char *) "self", NULL
18529 };
18530
18531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18533 if (SWIG_arg_fail(1)) SWIG_fail;
18534 {
18535 PyThreadState* __tstate = wxPyBeginAllowThreads();
18536 result = (int)((wxKeyEvent const *)arg1)->GetY();
18537
18538 wxPyEndAllowThreads(__tstate);
18539 if (PyErr_Occurred()) SWIG_fail;
18540 }
18541 {
18542 resultobj = SWIG_From_int((int)(result));
18543 }
18544 return resultobj;
18545 fail:
18546 return NULL;
18547 }
18548
18549
18550 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18551 PyObject *resultobj;
18552 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18553 int arg2 ;
18554 PyObject * obj0 = 0 ;
18555 PyObject * obj1 = 0 ;
18556 char *kwnames[] = {
18557 (char *) "self",(char *) "m_x", NULL
18558 };
18559
18560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18562 if (SWIG_arg_fail(1)) SWIG_fail;
18563 {
18564 arg2 = (int)(SWIG_As_int(obj1));
18565 if (SWIG_arg_fail(2)) SWIG_fail;
18566 }
18567 if (arg1) (arg1)->m_x = arg2;
18568
18569 Py_INCREF(Py_None); resultobj = Py_None;
18570 return resultobj;
18571 fail:
18572 return NULL;
18573 }
18574
18575
18576 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18577 PyObject *resultobj;
18578 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18579 int result;
18580 PyObject * obj0 = 0 ;
18581 char *kwnames[] = {
18582 (char *) "self", NULL
18583 };
18584
18585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18587 if (SWIG_arg_fail(1)) SWIG_fail;
18588 result = (int) ((arg1)->m_x);
18589
18590 {
18591 resultobj = SWIG_From_int((int)(result));
18592 }
18593 return resultobj;
18594 fail:
18595 return NULL;
18596 }
18597
18598
18599 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18600 PyObject *resultobj;
18601 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18602 int arg2 ;
18603 PyObject * obj0 = 0 ;
18604 PyObject * obj1 = 0 ;
18605 char *kwnames[] = {
18606 (char *) "self",(char *) "m_y", NULL
18607 };
18608
18609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18611 if (SWIG_arg_fail(1)) SWIG_fail;
18612 {
18613 arg2 = (int)(SWIG_As_int(obj1));
18614 if (SWIG_arg_fail(2)) SWIG_fail;
18615 }
18616 if (arg1) (arg1)->m_y = arg2;
18617
18618 Py_INCREF(Py_None); resultobj = Py_None;
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18626 PyObject *resultobj;
18627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18628 int result;
18629 PyObject * obj0 = 0 ;
18630 char *kwnames[] = {
18631 (char *) "self", NULL
18632 };
18633
18634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18636 if (SWIG_arg_fail(1)) SWIG_fail;
18637 result = (int) ((arg1)->m_y);
18638
18639 {
18640 resultobj = SWIG_From_int((int)(result));
18641 }
18642 return resultobj;
18643 fail:
18644 return NULL;
18645 }
18646
18647
18648 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18649 PyObject *resultobj;
18650 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18651 long arg2 ;
18652 PyObject * obj0 = 0 ;
18653 PyObject * obj1 = 0 ;
18654 char *kwnames[] = {
18655 (char *) "self",(char *) "m_keyCode", NULL
18656 };
18657
18658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18660 if (SWIG_arg_fail(1)) SWIG_fail;
18661 {
18662 arg2 = (long)(SWIG_As_long(obj1));
18663 if (SWIG_arg_fail(2)) SWIG_fail;
18664 }
18665 if (arg1) (arg1)->m_keyCode = arg2;
18666
18667 Py_INCREF(Py_None); resultobj = Py_None;
18668 return resultobj;
18669 fail:
18670 return NULL;
18671 }
18672
18673
18674 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18675 PyObject *resultobj;
18676 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18677 long result;
18678 PyObject * obj0 = 0 ;
18679 char *kwnames[] = {
18680 (char *) "self", NULL
18681 };
18682
18683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18685 if (SWIG_arg_fail(1)) SWIG_fail;
18686 result = (long) ((arg1)->m_keyCode);
18687
18688 {
18689 resultobj = SWIG_From_long((long)(result));
18690 }
18691 return resultobj;
18692 fail:
18693 return NULL;
18694 }
18695
18696
18697 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18698 PyObject *resultobj;
18699 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18700 bool arg2 ;
18701 PyObject * obj0 = 0 ;
18702 PyObject * obj1 = 0 ;
18703 char *kwnames[] = {
18704 (char *) "self",(char *) "m_controlDown", NULL
18705 };
18706
18707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18709 if (SWIG_arg_fail(1)) SWIG_fail;
18710 {
18711 arg2 = (bool)(SWIG_As_bool(obj1));
18712 if (SWIG_arg_fail(2)) SWIG_fail;
18713 }
18714 if (arg1) (arg1)->m_controlDown = arg2;
18715
18716 Py_INCREF(Py_None); resultobj = Py_None;
18717 return resultobj;
18718 fail:
18719 return NULL;
18720 }
18721
18722
18723 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18724 PyObject *resultobj;
18725 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18726 bool result;
18727 PyObject * obj0 = 0 ;
18728 char *kwnames[] = {
18729 (char *) "self", NULL
18730 };
18731
18732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18734 if (SWIG_arg_fail(1)) SWIG_fail;
18735 result = (bool) ((arg1)->m_controlDown);
18736
18737 {
18738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18739 }
18740 return resultobj;
18741 fail:
18742 return NULL;
18743 }
18744
18745
18746 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18747 PyObject *resultobj;
18748 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18749 bool arg2 ;
18750 PyObject * obj0 = 0 ;
18751 PyObject * obj1 = 0 ;
18752 char *kwnames[] = {
18753 (char *) "self",(char *) "m_shiftDown", NULL
18754 };
18755
18756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18758 if (SWIG_arg_fail(1)) SWIG_fail;
18759 {
18760 arg2 = (bool)(SWIG_As_bool(obj1));
18761 if (SWIG_arg_fail(2)) SWIG_fail;
18762 }
18763 if (arg1) (arg1)->m_shiftDown = arg2;
18764
18765 Py_INCREF(Py_None); resultobj = Py_None;
18766 return resultobj;
18767 fail:
18768 return NULL;
18769 }
18770
18771
18772 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18773 PyObject *resultobj;
18774 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18775 bool result;
18776 PyObject * obj0 = 0 ;
18777 char *kwnames[] = {
18778 (char *) "self", NULL
18779 };
18780
18781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18783 if (SWIG_arg_fail(1)) SWIG_fail;
18784 result = (bool) ((arg1)->m_shiftDown);
18785
18786 {
18787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18788 }
18789 return resultobj;
18790 fail:
18791 return NULL;
18792 }
18793
18794
18795 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18796 PyObject *resultobj;
18797 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18798 bool arg2 ;
18799 PyObject * obj0 = 0 ;
18800 PyObject * obj1 = 0 ;
18801 char *kwnames[] = {
18802 (char *) "self",(char *) "m_altDown", NULL
18803 };
18804
18805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18807 if (SWIG_arg_fail(1)) SWIG_fail;
18808 {
18809 arg2 = (bool)(SWIG_As_bool(obj1));
18810 if (SWIG_arg_fail(2)) SWIG_fail;
18811 }
18812 if (arg1) (arg1)->m_altDown = arg2;
18813
18814 Py_INCREF(Py_None); resultobj = Py_None;
18815 return resultobj;
18816 fail:
18817 return NULL;
18818 }
18819
18820
18821 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18822 PyObject *resultobj;
18823 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18824 bool result;
18825 PyObject * obj0 = 0 ;
18826 char *kwnames[] = {
18827 (char *) "self", NULL
18828 };
18829
18830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18832 if (SWIG_arg_fail(1)) SWIG_fail;
18833 result = (bool) ((arg1)->m_altDown);
18834
18835 {
18836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18837 }
18838 return resultobj;
18839 fail:
18840 return NULL;
18841 }
18842
18843
18844 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18845 PyObject *resultobj;
18846 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18847 bool arg2 ;
18848 PyObject * obj0 = 0 ;
18849 PyObject * obj1 = 0 ;
18850 char *kwnames[] = {
18851 (char *) "self",(char *) "m_metaDown", NULL
18852 };
18853
18854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18856 if (SWIG_arg_fail(1)) SWIG_fail;
18857 {
18858 arg2 = (bool)(SWIG_As_bool(obj1));
18859 if (SWIG_arg_fail(2)) SWIG_fail;
18860 }
18861 if (arg1) (arg1)->m_metaDown = arg2;
18862
18863 Py_INCREF(Py_None); resultobj = Py_None;
18864 return resultobj;
18865 fail:
18866 return NULL;
18867 }
18868
18869
18870 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18871 PyObject *resultobj;
18872 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18873 bool result;
18874 PyObject * obj0 = 0 ;
18875 char *kwnames[] = {
18876 (char *) "self", NULL
18877 };
18878
18879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18881 if (SWIG_arg_fail(1)) SWIG_fail;
18882 result = (bool) ((arg1)->m_metaDown);
18883
18884 {
18885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18886 }
18887 return resultobj;
18888 fail:
18889 return NULL;
18890 }
18891
18892
18893 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18894 PyObject *resultobj;
18895 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18896 bool arg2 ;
18897 PyObject * obj0 = 0 ;
18898 PyObject * obj1 = 0 ;
18899 char *kwnames[] = {
18900 (char *) "self",(char *) "m_scanCode", NULL
18901 };
18902
18903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18905 if (SWIG_arg_fail(1)) SWIG_fail;
18906 {
18907 arg2 = (bool)(SWIG_As_bool(obj1));
18908 if (SWIG_arg_fail(2)) SWIG_fail;
18909 }
18910 if (arg1) (arg1)->m_scanCode = arg2;
18911
18912 Py_INCREF(Py_None); resultobj = Py_None;
18913 return resultobj;
18914 fail:
18915 return NULL;
18916 }
18917
18918
18919 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18920 PyObject *resultobj;
18921 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18922 bool result;
18923 PyObject * obj0 = 0 ;
18924 char *kwnames[] = {
18925 (char *) "self", NULL
18926 };
18927
18928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18930 if (SWIG_arg_fail(1)) SWIG_fail;
18931 result = (bool) ((arg1)->m_scanCode);
18932
18933 {
18934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18935 }
18936 return resultobj;
18937 fail:
18938 return NULL;
18939 }
18940
18941
18942 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18943 PyObject *resultobj;
18944 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18945 unsigned int arg2 ;
18946 PyObject * obj0 = 0 ;
18947 PyObject * obj1 = 0 ;
18948 char *kwnames[] = {
18949 (char *) "self",(char *) "m_rawCode", NULL
18950 };
18951
18952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18954 if (SWIG_arg_fail(1)) SWIG_fail;
18955 {
18956 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18957 if (SWIG_arg_fail(2)) SWIG_fail;
18958 }
18959 if (arg1) (arg1)->m_rawCode = arg2;
18960
18961 Py_INCREF(Py_None); resultobj = Py_None;
18962 return resultobj;
18963 fail:
18964 return NULL;
18965 }
18966
18967
18968 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18969 PyObject *resultobj;
18970 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18971 unsigned int result;
18972 PyObject * obj0 = 0 ;
18973 char *kwnames[] = {
18974 (char *) "self", NULL
18975 };
18976
18977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18979 if (SWIG_arg_fail(1)) SWIG_fail;
18980 result = (unsigned int) ((arg1)->m_rawCode);
18981
18982 {
18983 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18984 }
18985 return resultobj;
18986 fail:
18987 return NULL;
18988 }
18989
18990
18991 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18992 PyObject *resultobj;
18993 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18994 unsigned int arg2 ;
18995 PyObject * obj0 = 0 ;
18996 PyObject * obj1 = 0 ;
18997 char *kwnames[] = {
18998 (char *) "self",(char *) "m_rawFlags", NULL
18999 };
19000
19001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19003 if (SWIG_arg_fail(1)) SWIG_fail;
19004 {
19005 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19006 if (SWIG_arg_fail(2)) SWIG_fail;
19007 }
19008 if (arg1) (arg1)->m_rawFlags = arg2;
19009
19010 Py_INCREF(Py_None); resultobj = Py_None;
19011 return resultobj;
19012 fail:
19013 return NULL;
19014 }
19015
19016
19017 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19018 PyObject *resultobj;
19019 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19020 unsigned int result;
19021 PyObject * obj0 = 0 ;
19022 char *kwnames[] = {
19023 (char *) "self", NULL
19024 };
19025
19026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19028 if (SWIG_arg_fail(1)) SWIG_fail;
19029 result = (unsigned int) ((arg1)->m_rawFlags);
19030
19031 {
19032 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19033 }
19034 return resultobj;
19035 fail:
19036 return NULL;
19037 }
19038
19039
19040 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19041 PyObject *obj;
19042 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19043 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19044 Py_INCREF(obj);
19045 return Py_BuildValue((char *)"");
19046 }
19047 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19048 PyObject *resultobj;
19049 wxSize const &arg1_defvalue = wxDefaultSize ;
19050 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19051 int arg2 = (int) 0 ;
19052 wxSizeEvent *result;
19053 wxSize temp1 ;
19054 PyObject * obj0 = 0 ;
19055 PyObject * obj1 = 0 ;
19056 char *kwnames[] = {
19057 (char *) "sz",(char *) "winid", NULL
19058 };
19059
19060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19061 if (obj0) {
19062 {
19063 arg1 = &temp1;
19064 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19065 }
19066 }
19067 if (obj1) {
19068 {
19069 arg2 = (int)(SWIG_As_int(obj1));
19070 if (SWIG_arg_fail(2)) SWIG_fail;
19071 }
19072 }
19073 {
19074 PyThreadState* __tstate = wxPyBeginAllowThreads();
19075 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19076
19077 wxPyEndAllowThreads(__tstate);
19078 if (PyErr_Occurred()) SWIG_fail;
19079 }
19080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19081 return resultobj;
19082 fail:
19083 return NULL;
19084 }
19085
19086
19087 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19088 PyObject *resultobj;
19089 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19090 wxSize result;
19091 PyObject * obj0 = 0 ;
19092 char *kwnames[] = {
19093 (char *) "self", NULL
19094 };
19095
19096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19098 if (SWIG_arg_fail(1)) SWIG_fail;
19099 {
19100 PyThreadState* __tstate = wxPyBeginAllowThreads();
19101 result = ((wxSizeEvent const *)arg1)->GetSize();
19102
19103 wxPyEndAllowThreads(__tstate);
19104 if (PyErr_Occurred()) SWIG_fail;
19105 }
19106 {
19107 wxSize * resultptr;
19108 resultptr = new wxSize((wxSize &)(result));
19109 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19110 }
19111 return resultobj;
19112 fail:
19113 return NULL;
19114 }
19115
19116
19117 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19118 PyObject *resultobj;
19119 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19120 wxRect result;
19121 PyObject * obj0 = 0 ;
19122 char *kwnames[] = {
19123 (char *) "self", NULL
19124 };
19125
19126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19128 if (SWIG_arg_fail(1)) SWIG_fail;
19129 {
19130 PyThreadState* __tstate = wxPyBeginAllowThreads();
19131 result = ((wxSizeEvent const *)arg1)->GetRect();
19132
19133 wxPyEndAllowThreads(__tstate);
19134 if (PyErr_Occurred()) SWIG_fail;
19135 }
19136 {
19137 wxRect * resultptr;
19138 resultptr = new wxRect((wxRect &)(result));
19139 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19140 }
19141 return resultobj;
19142 fail:
19143 return NULL;
19144 }
19145
19146
19147 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19148 PyObject *resultobj;
19149 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19150 wxRect arg2 ;
19151 PyObject * obj0 = 0 ;
19152 PyObject * obj1 = 0 ;
19153 char *kwnames[] = {
19154 (char *) "self",(char *) "rect", NULL
19155 };
19156
19157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19159 if (SWIG_arg_fail(1)) SWIG_fail;
19160 {
19161 wxRect * argp;
19162 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19163 if (SWIG_arg_fail(2)) SWIG_fail;
19164 if (argp == NULL) {
19165 SWIG_null_ref("wxRect");
19166 }
19167 if (SWIG_arg_fail(2)) SWIG_fail;
19168 arg2 = *argp;
19169 }
19170 {
19171 PyThreadState* __tstate = wxPyBeginAllowThreads();
19172 (arg1)->SetRect(arg2);
19173
19174 wxPyEndAllowThreads(__tstate);
19175 if (PyErr_Occurred()) SWIG_fail;
19176 }
19177 Py_INCREF(Py_None); resultobj = Py_None;
19178 return resultobj;
19179 fail:
19180 return NULL;
19181 }
19182
19183
19184 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19185 PyObject *resultobj;
19186 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19187 wxSize arg2 ;
19188 PyObject * obj0 = 0 ;
19189 PyObject * obj1 = 0 ;
19190 char *kwnames[] = {
19191 (char *) "self",(char *) "size", NULL
19192 };
19193
19194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19196 if (SWIG_arg_fail(1)) SWIG_fail;
19197 {
19198 wxSize * argp;
19199 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19200 if (SWIG_arg_fail(2)) SWIG_fail;
19201 if (argp == NULL) {
19202 SWIG_null_ref("wxSize");
19203 }
19204 if (SWIG_arg_fail(2)) SWIG_fail;
19205 arg2 = *argp;
19206 }
19207 {
19208 PyThreadState* __tstate = wxPyBeginAllowThreads();
19209 wxSizeEvent_SetSize(arg1,arg2);
19210
19211 wxPyEndAllowThreads(__tstate);
19212 if (PyErr_Occurred()) SWIG_fail;
19213 }
19214 Py_INCREF(Py_None); resultobj = Py_None;
19215 return resultobj;
19216 fail:
19217 return NULL;
19218 }
19219
19220
19221 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19222 PyObject *resultobj;
19223 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19224 wxSize *arg2 = (wxSize *) 0 ;
19225 PyObject * obj0 = 0 ;
19226 PyObject * obj1 = 0 ;
19227 char *kwnames[] = {
19228 (char *) "self",(char *) "m_size", NULL
19229 };
19230
19231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19233 if (SWIG_arg_fail(1)) SWIG_fail;
19234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19235 if (SWIG_arg_fail(2)) SWIG_fail;
19236 if (arg1) (arg1)->m_size = *arg2;
19237
19238 Py_INCREF(Py_None); resultobj = Py_None;
19239 return resultobj;
19240 fail:
19241 return NULL;
19242 }
19243
19244
19245 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19246 PyObject *resultobj;
19247 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19248 wxSize *result;
19249 PyObject * obj0 = 0 ;
19250 char *kwnames[] = {
19251 (char *) "self", NULL
19252 };
19253
19254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19256 if (SWIG_arg_fail(1)) SWIG_fail;
19257 result = (wxSize *)& ((arg1)->m_size);
19258
19259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19260 return resultobj;
19261 fail:
19262 return NULL;
19263 }
19264
19265
19266 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19267 PyObject *resultobj;
19268 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19269 wxRect *arg2 = (wxRect *) 0 ;
19270 PyObject * obj0 = 0 ;
19271 PyObject * obj1 = 0 ;
19272 char *kwnames[] = {
19273 (char *) "self",(char *) "m_rect", NULL
19274 };
19275
19276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19278 if (SWIG_arg_fail(1)) SWIG_fail;
19279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19280 if (SWIG_arg_fail(2)) SWIG_fail;
19281 if (arg1) (arg1)->m_rect = *arg2;
19282
19283 Py_INCREF(Py_None); resultobj = Py_None;
19284 return resultobj;
19285 fail:
19286 return NULL;
19287 }
19288
19289
19290 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19291 PyObject *resultobj;
19292 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19293 wxRect *result;
19294 PyObject * obj0 = 0 ;
19295 char *kwnames[] = {
19296 (char *) "self", NULL
19297 };
19298
19299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19301 if (SWIG_arg_fail(1)) SWIG_fail;
19302 result = (wxRect *)& ((arg1)->m_rect);
19303
19304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19305 return resultobj;
19306 fail:
19307 return NULL;
19308 }
19309
19310
19311 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19312 PyObject *obj;
19313 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19314 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19315 Py_INCREF(obj);
19316 return Py_BuildValue((char *)"");
19317 }
19318 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19319 PyObject *resultobj;
19320 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19321 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19322 int arg2 = (int) 0 ;
19323 wxMoveEvent *result;
19324 wxPoint temp1 ;
19325 PyObject * obj0 = 0 ;
19326 PyObject * obj1 = 0 ;
19327 char *kwnames[] = {
19328 (char *) "pos",(char *) "winid", NULL
19329 };
19330
19331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19332 if (obj0) {
19333 {
19334 arg1 = &temp1;
19335 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19336 }
19337 }
19338 if (obj1) {
19339 {
19340 arg2 = (int)(SWIG_As_int(obj1));
19341 if (SWIG_arg_fail(2)) SWIG_fail;
19342 }
19343 }
19344 {
19345 PyThreadState* __tstate = wxPyBeginAllowThreads();
19346 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19347
19348 wxPyEndAllowThreads(__tstate);
19349 if (PyErr_Occurred()) SWIG_fail;
19350 }
19351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19352 return resultobj;
19353 fail:
19354 return NULL;
19355 }
19356
19357
19358 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19359 PyObject *resultobj;
19360 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19361 wxPoint result;
19362 PyObject * obj0 = 0 ;
19363 char *kwnames[] = {
19364 (char *) "self", NULL
19365 };
19366
19367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19369 if (SWIG_arg_fail(1)) SWIG_fail;
19370 {
19371 PyThreadState* __tstate = wxPyBeginAllowThreads();
19372 result = ((wxMoveEvent const *)arg1)->GetPosition();
19373
19374 wxPyEndAllowThreads(__tstate);
19375 if (PyErr_Occurred()) SWIG_fail;
19376 }
19377 {
19378 wxPoint * resultptr;
19379 resultptr = new wxPoint((wxPoint &)(result));
19380 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19381 }
19382 return resultobj;
19383 fail:
19384 return NULL;
19385 }
19386
19387
19388 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19389 PyObject *resultobj;
19390 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19391 wxRect result;
19392 PyObject * obj0 = 0 ;
19393 char *kwnames[] = {
19394 (char *) "self", NULL
19395 };
19396
19397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19399 if (SWIG_arg_fail(1)) SWIG_fail;
19400 {
19401 PyThreadState* __tstate = wxPyBeginAllowThreads();
19402 result = ((wxMoveEvent const *)arg1)->GetRect();
19403
19404 wxPyEndAllowThreads(__tstate);
19405 if (PyErr_Occurred()) SWIG_fail;
19406 }
19407 {
19408 wxRect * resultptr;
19409 resultptr = new wxRect((wxRect &)(result));
19410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19411 }
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj;
19420 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19421 wxRect *arg2 = 0 ;
19422 wxRect temp2 ;
19423 PyObject * obj0 = 0 ;
19424 PyObject * obj1 = 0 ;
19425 char *kwnames[] = {
19426 (char *) "self",(char *) "rect", NULL
19427 };
19428
19429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19431 if (SWIG_arg_fail(1)) SWIG_fail;
19432 {
19433 arg2 = &temp2;
19434 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19435 }
19436 {
19437 PyThreadState* __tstate = wxPyBeginAllowThreads();
19438 (arg1)->SetRect((wxRect const &)*arg2);
19439
19440 wxPyEndAllowThreads(__tstate);
19441 if (PyErr_Occurred()) SWIG_fail;
19442 }
19443 Py_INCREF(Py_None); resultobj = Py_None;
19444 return resultobj;
19445 fail:
19446 return NULL;
19447 }
19448
19449
19450 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19451 PyObject *resultobj;
19452 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19453 wxPoint *arg2 = 0 ;
19454 wxPoint temp2 ;
19455 PyObject * obj0 = 0 ;
19456 PyObject * obj1 = 0 ;
19457 char *kwnames[] = {
19458 (char *) "self",(char *) "pos", NULL
19459 };
19460
19461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19463 if (SWIG_arg_fail(1)) SWIG_fail;
19464 {
19465 arg2 = &temp2;
19466 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19467 }
19468 {
19469 PyThreadState* __tstate = wxPyBeginAllowThreads();
19470 (arg1)->SetPosition((wxPoint const &)*arg2);
19471
19472 wxPyEndAllowThreads(__tstate);
19473 if (PyErr_Occurred()) SWIG_fail;
19474 }
19475 Py_INCREF(Py_None); resultobj = Py_None;
19476 return resultobj;
19477 fail:
19478 return NULL;
19479 }
19480
19481
19482 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19483 PyObject *obj;
19484 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19485 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19486 Py_INCREF(obj);
19487 return Py_BuildValue((char *)"");
19488 }
19489 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19490 PyObject *resultobj;
19491 int arg1 = (int) 0 ;
19492 wxPaintEvent *result;
19493 PyObject * obj0 = 0 ;
19494 char *kwnames[] = {
19495 (char *) "Id", NULL
19496 };
19497
19498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19499 if (obj0) {
19500 {
19501 arg1 = (int)(SWIG_As_int(obj0));
19502 if (SWIG_arg_fail(1)) SWIG_fail;
19503 }
19504 }
19505 {
19506 PyThreadState* __tstate = wxPyBeginAllowThreads();
19507 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19508
19509 wxPyEndAllowThreads(__tstate);
19510 if (PyErr_Occurred()) SWIG_fail;
19511 }
19512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19513 return resultobj;
19514 fail:
19515 return NULL;
19516 }
19517
19518
19519 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19520 PyObject *obj;
19521 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19522 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19523 Py_INCREF(obj);
19524 return Py_BuildValue((char *)"");
19525 }
19526 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19527 PyObject *resultobj;
19528 int arg1 = (int) 0 ;
19529 wxNcPaintEvent *result;
19530 PyObject * obj0 = 0 ;
19531 char *kwnames[] = {
19532 (char *) "winid", NULL
19533 };
19534
19535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19536 if (obj0) {
19537 {
19538 arg1 = (int)(SWIG_As_int(obj0));
19539 if (SWIG_arg_fail(1)) SWIG_fail;
19540 }
19541 }
19542 {
19543 PyThreadState* __tstate = wxPyBeginAllowThreads();
19544 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19545
19546 wxPyEndAllowThreads(__tstate);
19547 if (PyErr_Occurred()) SWIG_fail;
19548 }
19549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19550 return resultobj;
19551 fail:
19552 return NULL;
19553 }
19554
19555
19556 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19557 PyObject *obj;
19558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19559 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19560 Py_INCREF(obj);
19561 return Py_BuildValue((char *)"");
19562 }
19563 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19564 PyObject *resultobj;
19565 int arg1 = (int) 0 ;
19566 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19567 wxEraseEvent *result;
19568 PyObject * obj0 = 0 ;
19569 PyObject * obj1 = 0 ;
19570 char *kwnames[] = {
19571 (char *) "Id",(char *) "dc", NULL
19572 };
19573
19574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19575 if (obj0) {
19576 {
19577 arg1 = (int)(SWIG_As_int(obj0));
19578 if (SWIG_arg_fail(1)) SWIG_fail;
19579 }
19580 }
19581 if (obj1) {
19582 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19583 if (SWIG_arg_fail(2)) SWIG_fail;
19584 }
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19588
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj;
19601 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19602 wxDC *result;
19603 PyObject * obj0 = 0 ;
19604 char *kwnames[] = {
19605 (char *) "self", NULL
19606 };
19607
19608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19610 if (SWIG_arg_fail(1)) SWIG_fail;
19611 {
19612 PyThreadState* __tstate = wxPyBeginAllowThreads();
19613 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19614
19615 wxPyEndAllowThreads(__tstate);
19616 if (PyErr_Occurred()) SWIG_fail;
19617 }
19618 {
19619 resultobj = wxPyMake_wxObject(result, 0);
19620 }
19621 return resultobj;
19622 fail:
19623 return NULL;
19624 }
19625
19626
19627 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19628 PyObject *obj;
19629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19630 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19631 Py_INCREF(obj);
19632 return Py_BuildValue((char *)"");
19633 }
19634 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19635 PyObject *resultobj;
19636 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19637 int arg2 = (int) 0 ;
19638 wxFocusEvent *result;
19639 PyObject * obj0 = 0 ;
19640 PyObject * obj1 = 0 ;
19641 char *kwnames[] = {
19642 (char *) "type",(char *) "winid", NULL
19643 };
19644
19645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19646 if (obj0) {
19647 {
19648 arg1 = (wxEventType)(SWIG_As_int(obj0));
19649 if (SWIG_arg_fail(1)) SWIG_fail;
19650 }
19651 }
19652 if (obj1) {
19653 {
19654 arg2 = (int)(SWIG_As_int(obj1));
19655 if (SWIG_arg_fail(2)) SWIG_fail;
19656 }
19657 }
19658 {
19659 PyThreadState* __tstate = wxPyBeginAllowThreads();
19660 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19661
19662 wxPyEndAllowThreads(__tstate);
19663 if (PyErr_Occurred()) SWIG_fail;
19664 }
19665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19666 return resultobj;
19667 fail:
19668 return NULL;
19669 }
19670
19671
19672 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19673 PyObject *resultobj;
19674 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19675 wxWindow *result;
19676 PyObject * obj0 = 0 ;
19677 char *kwnames[] = {
19678 (char *) "self", NULL
19679 };
19680
19681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19683 if (SWIG_arg_fail(1)) SWIG_fail;
19684 {
19685 PyThreadState* __tstate = wxPyBeginAllowThreads();
19686 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19687
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 {
19692 resultobj = wxPyMake_wxObject(result, 0);
19693 }
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj;
19702 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19703 wxWindow *arg2 = (wxWindow *) 0 ;
19704 PyObject * obj0 = 0 ;
19705 PyObject * obj1 = 0 ;
19706 char *kwnames[] = {
19707 (char *) "self",(char *) "win", NULL
19708 };
19709
19710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19712 if (SWIG_arg_fail(1)) SWIG_fail;
19713 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19714 if (SWIG_arg_fail(2)) SWIG_fail;
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 (arg1)->SetWindow(arg2);
19718
19719 wxPyEndAllowThreads(__tstate);
19720 if (PyErr_Occurred()) SWIG_fail;
19721 }
19722 Py_INCREF(Py_None); resultobj = Py_None;
19723 return resultobj;
19724 fail:
19725 return NULL;
19726 }
19727
19728
19729 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19730 PyObject *obj;
19731 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19732 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19733 Py_INCREF(obj);
19734 return Py_BuildValue((char *)"");
19735 }
19736 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19737 PyObject *resultobj;
19738 wxWindow *arg1 = (wxWindow *) NULL ;
19739 wxChildFocusEvent *result;
19740 PyObject * obj0 = 0 ;
19741 char *kwnames[] = {
19742 (char *) "win", NULL
19743 };
19744
19745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19746 if (obj0) {
19747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19748 if (SWIG_arg_fail(1)) SWIG_fail;
19749 }
19750 {
19751 PyThreadState* __tstate = wxPyBeginAllowThreads();
19752 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19753
19754 wxPyEndAllowThreads(__tstate);
19755 if (PyErr_Occurred()) SWIG_fail;
19756 }
19757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19758 return resultobj;
19759 fail:
19760 return NULL;
19761 }
19762
19763
19764 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19765 PyObject *resultobj;
19766 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19767 wxWindow *result;
19768 PyObject * obj0 = 0 ;
19769 char *kwnames[] = {
19770 (char *) "self", NULL
19771 };
19772
19773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19775 if (SWIG_arg_fail(1)) SWIG_fail;
19776 {
19777 PyThreadState* __tstate = wxPyBeginAllowThreads();
19778 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19779
19780 wxPyEndAllowThreads(__tstate);
19781 if (PyErr_Occurred()) SWIG_fail;
19782 }
19783 {
19784 resultobj = wxPyMake_wxObject(result, 0);
19785 }
19786 return resultobj;
19787 fail:
19788 return NULL;
19789 }
19790
19791
19792 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19793 PyObject *obj;
19794 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19795 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19796 Py_INCREF(obj);
19797 return Py_BuildValue((char *)"");
19798 }
19799 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19800 PyObject *resultobj;
19801 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19802 bool arg2 = (bool) true ;
19803 int arg3 = (int) 0 ;
19804 wxActivateEvent *result;
19805 PyObject * obj0 = 0 ;
19806 PyObject * obj1 = 0 ;
19807 PyObject * obj2 = 0 ;
19808 char *kwnames[] = {
19809 (char *) "type",(char *) "active",(char *) "Id", NULL
19810 };
19811
19812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19813 if (obj0) {
19814 {
19815 arg1 = (wxEventType)(SWIG_As_int(obj0));
19816 if (SWIG_arg_fail(1)) SWIG_fail;
19817 }
19818 }
19819 if (obj1) {
19820 {
19821 arg2 = (bool)(SWIG_As_bool(obj1));
19822 if (SWIG_arg_fail(2)) SWIG_fail;
19823 }
19824 }
19825 if (obj2) {
19826 {
19827 arg3 = (int)(SWIG_As_int(obj2));
19828 if (SWIG_arg_fail(3)) SWIG_fail;
19829 }
19830 }
19831 {
19832 PyThreadState* __tstate = wxPyBeginAllowThreads();
19833 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19834
19835 wxPyEndAllowThreads(__tstate);
19836 if (PyErr_Occurred()) SWIG_fail;
19837 }
19838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19839 return resultobj;
19840 fail:
19841 return NULL;
19842 }
19843
19844
19845 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19846 PyObject *resultobj;
19847 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19848 bool result;
19849 PyObject * obj0 = 0 ;
19850 char *kwnames[] = {
19851 (char *) "self", NULL
19852 };
19853
19854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19856 if (SWIG_arg_fail(1)) SWIG_fail;
19857 {
19858 PyThreadState* __tstate = wxPyBeginAllowThreads();
19859 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19860
19861 wxPyEndAllowThreads(__tstate);
19862 if (PyErr_Occurred()) SWIG_fail;
19863 }
19864 {
19865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19866 }
19867 return resultobj;
19868 fail:
19869 return NULL;
19870 }
19871
19872
19873 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19874 PyObject *obj;
19875 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19876 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19877 Py_INCREF(obj);
19878 return Py_BuildValue((char *)"");
19879 }
19880 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19881 PyObject *resultobj;
19882 int arg1 = (int) 0 ;
19883 wxInitDialogEvent *result;
19884 PyObject * obj0 = 0 ;
19885 char *kwnames[] = {
19886 (char *) "Id", NULL
19887 };
19888
19889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19890 if (obj0) {
19891 {
19892 arg1 = (int)(SWIG_As_int(obj0));
19893 if (SWIG_arg_fail(1)) SWIG_fail;
19894 }
19895 }
19896 {
19897 PyThreadState* __tstate = wxPyBeginAllowThreads();
19898 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19899
19900 wxPyEndAllowThreads(__tstate);
19901 if (PyErr_Occurred()) SWIG_fail;
19902 }
19903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19911 PyObject *obj;
19912 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19913 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19914 Py_INCREF(obj);
19915 return Py_BuildValue((char *)"");
19916 }
19917 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19918 PyObject *resultobj;
19919 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19920 int arg2 = (int) 0 ;
19921 wxMenu *arg3 = (wxMenu *) NULL ;
19922 wxMenuEvent *result;
19923 PyObject * obj0 = 0 ;
19924 PyObject * obj1 = 0 ;
19925 PyObject * obj2 = 0 ;
19926 char *kwnames[] = {
19927 (char *) "type",(char *) "winid",(char *) "menu", NULL
19928 };
19929
19930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19931 if (obj0) {
19932 {
19933 arg1 = (wxEventType)(SWIG_As_int(obj0));
19934 if (SWIG_arg_fail(1)) SWIG_fail;
19935 }
19936 }
19937 if (obj1) {
19938 {
19939 arg2 = (int)(SWIG_As_int(obj1));
19940 if (SWIG_arg_fail(2)) SWIG_fail;
19941 }
19942 }
19943 if (obj2) {
19944 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19945 if (SWIG_arg_fail(3)) SWIG_fail;
19946 }
19947 {
19948 PyThreadState* __tstate = wxPyBeginAllowThreads();
19949 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19950
19951 wxPyEndAllowThreads(__tstate);
19952 if (PyErr_Occurred()) SWIG_fail;
19953 }
19954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19955 return resultobj;
19956 fail:
19957 return NULL;
19958 }
19959
19960
19961 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19962 PyObject *resultobj;
19963 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19964 int result;
19965 PyObject * obj0 = 0 ;
19966 char *kwnames[] = {
19967 (char *) "self", NULL
19968 };
19969
19970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19972 if (SWIG_arg_fail(1)) SWIG_fail;
19973 {
19974 PyThreadState* __tstate = wxPyBeginAllowThreads();
19975 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19976
19977 wxPyEndAllowThreads(__tstate);
19978 if (PyErr_Occurred()) SWIG_fail;
19979 }
19980 {
19981 resultobj = SWIG_From_int((int)(result));
19982 }
19983 return resultobj;
19984 fail:
19985 return NULL;
19986 }
19987
19988
19989 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19990 PyObject *resultobj;
19991 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19992 bool result;
19993 PyObject * obj0 = 0 ;
19994 char *kwnames[] = {
19995 (char *) "self", NULL
19996 };
19997
19998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20000 if (SWIG_arg_fail(1)) SWIG_fail;
20001 {
20002 PyThreadState* __tstate = wxPyBeginAllowThreads();
20003 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20004
20005 wxPyEndAllowThreads(__tstate);
20006 if (PyErr_Occurred()) SWIG_fail;
20007 }
20008 {
20009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20010 }
20011 return resultobj;
20012 fail:
20013 return NULL;
20014 }
20015
20016
20017 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20018 PyObject *resultobj;
20019 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20020 wxMenu *result;
20021 PyObject * obj0 = 0 ;
20022 char *kwnames[] = {
20023 (char *) "self", NULL
20024 };
20025
20026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20028 if (SWIG_arg_fail(1)) SWIG_fail;
20029 {
20030 PyThreadState* __tstate = wxPyBeginAllowThreads();
20031 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20032
20033 wxPyEndAllowThreads(__tstate);
20034 if (PyErr_Occurred()) SWIG_fail;
20035 }
20036 {
20037 resultobj = wxPyMake_wxObject(result, 0);
20038 }
20039 return resultobj;
20040 fail:
20041 return NULL;
20042 }
20043
20044
20045 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20046 PyObject *obj;
20047 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20048 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20049 Py_INCREF(obj);
20050 return Py_BuildValue((char *)"");
20051 }
20052 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20053 PyObject *resultobj;
20054 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20055 int arg2 = (int) 0 ;
20056 wxCloseEvent *result;
20057 PyObject * obj0 = 0 ;
20058 PyObject * obj1 = 0 ;
20059 char *kwnames[] = {
20060 (char *) "type",(char *) "winid", NULL
20061 };
20062
20063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20064 if (obj0) {
20065 {
20066 arg1 = (wxEventType)(SWIG_As_int(obj0));
20067 if (SWIG_arg_fail(1)) SWIG_fail;
20068 }
20069 }
20070 if (obj1) {
20071 {
20072 arg2 = (int)(SWIG_As_int(obj1));
20073 if (SWIG_arg_fail(2)) SWIG_fail;
20074 }
20075 }
20076 {
20077 PyThreadState* __tstate = wxPyBeginAllowThreads();
20078 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20079
20080 wxPyEndAllowThreads(__tstate);
20081 if (PyErr_Occurred()) SWIG_fail;
20082 }
20083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20084 return resultobj;
20085 fail:
20086 return NULL;
20087 }
20088
20089
20090 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20091 PyObject *resultobj;
20092 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20093 bool arg2 ;
20094 PyObject * obj0 = 0 ;
20095 PyObject * obj1 = 0 ;
20096 char *kwnames[] = {
20097 (char *) "self",(char *) "logOff", NULL
20098 };
20099
20100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20102 if (SWIG_arg_fail(1)) SWIG_fail;
20103 {
20104 arg2 = (bool)(SWIG_As_bool(obj1));
20105 if (SWIG_arg_fail(2)) SWIG_fail;
20106 }
20107 {
20108 PyThreadState* __tstate = wxPyBeginAllowThreads();
20109 (arg1)->SetLoggingOff(arg2);
20110
20111 wxPyEndAllowThreads(__tstate);
20112 if (PyErr_Occurred()) SWIG_fail;
20113 }
20114 Py_INCREF(Py_None); resultobj = Py_None;
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20122 PyObject *resultobj;
20123 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20124 bool result;
20125 PyObject * obj0 = 0 ;
20126 char *kwnames[] = {
20127 (char *) "self", NULL
20128 };
20129
20130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20132 if (SWIG_arg_fail(1)) SWIG_fail;
20133 {
20134 PyThreadState* __tstate = wxPyBeginAllowThreads();
20135 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20136
20137 wxPyEndAllowThreads(__tstate);
20138 if (PyErr_Occurred()) SWIG_fail;
20139 }
20140 {
20141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20142 }
20143 return resultobj;
20144 fail:
20145 return NULL;
20146 }
20147
20148
20149 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20150 PyObject *resultobj;
20151 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20152 bool arg2 = (bool) true ;
20153 PyObject * obj0 = 0 ;
20154 PyObject * obj1 = 0 ;
20155 char *kwnames[] = {
20156 (char *) "self",(char *) "veto", NULL
20157 };
20158
20159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20161 if (SWIG_arg_fail(1)) SWIG_fail;
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 (arg1)->Veto(arg2);
20171
20172 wxPyEndAllowThreads(__tstate);
20173 if (PyErr_Occurred()) SWIG_fail;
20174 }
20175 Py_INCREF(Py_None); resultobj = Py_None;
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20183 PyObject *resultobj;
20184 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20185 bool arg2 ;
20186 PyObject * obj0 = 0 ;
20187 PyObject * obj1 = 0 ;
20188 char *kwnames[] = {
20189 (char *) "self",(char *) "canVeto", NULL
20190 };
20191
20192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20194 if (SWIG_arg_fail(1)) SWIG_fail;
20195 {
20196 arg2 = (bool)(SWIG_As_bool(obj1));
20197 if (SWIG_arg_fail(2)) SWIG_fail;
20198 }
20199 {
20200 PyThreadState* __tstate = wxPyBeginAllowThreads();
20201 (arg1)->SetCanVeto(arg2);
20202
20203 wxPyEndAllowThreads(__tstate);
20204 if (PyErr_Occurred()) SWIG_fail;
20205 }
20206 Py_INCREF(Py_None); resultobj = Py_None;
20207 return resultobj;
20208 fail:
20209 return NULL;
20210 }
20211
20212
20213 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20214 PyObject *resultobj;
20215 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20216 bool result;
20217 PyObject * obj0 = 0 ;
20218 char *kwnames[] = {
20219 (char *) "self", NULL
20220 };
20221
20222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20224 if (SWIG_arg_fail(1)) SWIG_fail;
20225 {
20226 PyThreadState* __tstate = wxPyBeginAllowThreads();
20227 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20228
20229 wxPyEndAllowThreads(__tstate);
20230 if (PyErr_Occurred()) SWIG_fail;
20231 }
20232 {
20233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20234 }
20235 return resultobj;
20236 fail:
20237 return NULL;
20238 }
20239
20240
20241 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20242 PyObject *resultobj;
20243 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20244 bool result;
20245 PyObject * obj0 = 0 ;
20246 char *kwnames[] = {
20247 (char *) "self", NULL
20248 };
20249
20250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20252 if (SWIG_arg_fail(1)) SWIG_fail;
20253 {
20254 PyThreadState* __tstate = wxPyBeginAllowThreads();
20255 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20256
20257 wxPyEndAllowThreads(__tstate);
20258 if (PyErr_Occurred()) SWIG_fail;
20259 }
20260 {
20261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20262 }
20263 return resultobj;
20264 fail:
20265 return NULL;
20266 }
20267
20268
20269 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20270 PyObject *obj;
20271 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20272 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20273 Py_INCREF(obj);
20274 return Py_BuildValue((char *)"");
20275 }
20276 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20277 PyObject *resultobj;
20278 int arg1 = (int) 0 ;
20279 bool arg2 = (bool) false ;
20280 wxShowEvent *result;
20281 PyObject * obj0 = 0 ;
20282 PyObject * obj1 = 0 ;
20283 char *kwnames[] = {
20284 (char *) "winid",(char *) "show", NULL
20285 };
20286
20287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20288 if (obj0) {
20289 {
20290 arg1 = (int)(SWIG_As_int(obj0));
20291 if (SWIG_arg_fail(1)) SWIG_fail;
20292 }
20293 }
20294 if (obj1) {
20295 {
20296 arg2 = (bool)(SWIG_As_bool(obj1));
20297 if (SWIG_arg_fail(2)) SWIG_fail;
20298 }
20299 }
20300 {
20301 PyThreadState* __tstate = wxPyBeginAllowThreads();
20302 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20303
20304 wxPyEndAllowThreads(__tstate);
20305 if (PyErr_Occurred()) SWIG_fail;
20306 }
20307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20308 return resultobj;
20309 fail:
20310 return NULL;
20311 }
20312
20313
20314 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20315 PyObject *resultobj;
20316 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20317 bool arg2 ;
20318 PyObject * obj0 = 0 ;
20319 PyObject * obj1 = 0 ;
20320 char *kwnames[] = {
20321 (char *) "self",(char *) "show", NULL
20322 };
20323
20324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20326 if (SWIG_arg_fail(1)) SWIG_fail;
20327 {
20328 arg2 = (bool)(SWIG_As_bool(obj1));
20329 if (SWIG_arg_fail(2)) SWIG_fail;
20330 }
20331 {
20332 PyThreadState* __tstate = wxPyBeginAllowThreads();
20333 (arg1)->SetShow(arg2);
20334
20335 wxPyEndAllowThreads(__tstate);
20336 if (PyErr_Occurred()) SWIG_fail;
20337 }
20338 Py_INCREF(Py_None); resultobj = Py_None;
20339 return resultobj;
20340 fail:
20341 return NULL;
20342 }
20343
20344
20345 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20346 PyObject *resultobj;
20347 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20348 bool result;
20349 PyObject * obj0 = 0 ;
20350 char *kwnames[] = {
20351 (char *) "self", NULL
20352 };
20353
20354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20356 if (SWIG_arg_fail(1)) SWIG_fail;
20357 {
20358 PyThreadState* __tstate = wxPyBeginAllowThreads();
20359 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20360
20361 wxPyEndAllowThreads(__tstate);
20362 if (PyErr_Occurred()) SWIG_fail;
20363 }
20364 {
20365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20366 }
20367 return resultobj;
20368 fail:
20369 return NULL;
20370 }
20371
20372
20373 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20374 PyObject *obj;
20375 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20376 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20377 Py_INCREF(obj);
20378 return Py_BuildValue((char *)"");
20379 }
20380 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20381 PyObject *resultobj;
20382 int arg1 = (int) 0 ;
20383 bool arg2 = (bool) true ;
20384 wxIconizeEvent *result;
20385 PyObject * obj0 = 0 ;
20386 PyObject * obj1 = 0 ;
20387 char *kwnames[] = {
20388 (char *) "id",(char *) "iconized", NULL
20389 };
20390
20391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20392 if (obj0) {
20393 {
20394 arg1 = (int)(SWIG_As_int(obj0));
20395 if (SWIG_arg_fail(1)) SWIG_fail;
20396 }
20397 }
20398 if (obj1) {
20399 {
20400 arg2 = (bool)(SWIG_As_bool(obj1));
20401 if (SWIG_arg_fail(2)) SWIG_fail;
20402 }
20403 }
20404 {
20405 PyThreadState* __tstate = wxPyBeginAllowThreads();
20406 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20407
20408 wxPyEndAllowThreads(__tstate);
20409 if (PyErr_Occurred()) SWIG_fail;
20410 }
20411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20412 return resultobj;
20413 fail:
20414 return NULL;
20415 }
20416
20417
20418 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20419 PyObject *resultobj;
20420 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20421 bool result;
20422 PyObject * obj0 = 0 ;
20423 char *kwnames[] = {
20424 (char *) "self", NULL
20425 };
20426
20427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20429 if (SWIG_arg_fail(1)) SWIG_fail;
20430 {
20431 PyThreadState* __tstate = wxPyBeginAllowThreads();
20432 result = (bool)(arg1)->Iconized();
20433
20434 wxPyEndAllowThreads(__tstate);
20435 if (PyErr_Occurred()) SWIG_fail;
20436 }
20437 {
20438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20439 }
20440 return resultobj;
20441 fail:
20442 return NULL;
20443 }
20444
20445
20446 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20447 PyObject *obj;
20448 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20449 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20450 Py_INCREF(obj);
20451 return Py_BuildValue((char *)"");
20452 }
20453 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20454 PyObject *resultobj;
20455 int arg1 = (int) 0 ;
20456 wxMaximizeEvent *result;
20457 PyObject * obj0 = 0 ;
20458 char *kwnames[] = {
20459 (char *) "id", NULL
20460 };
20461
20462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20463 if (obj0) {
20464 {
20465 arg1 = (int)(SWIG_As_int(obj0));
20466 if (SWIG_arg_fail(1)) SWIG_fail;
20467 }
20468 }
20469 {
20470 PyThreadState* __tstate = wxPyBeginAllowThreads();
20471 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20472
20473 wxPyEndAllowThreads(__tstate);
20474 if (PyErr_Occurred()) SWIG_fail;
20475 }
20476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20477 return resultobj;
20478 fail:
20479 return NULL;
20480 }
20481
20482
20483 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20484 PyObject *obj;
20485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20486 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20487 Py_INCREF(obj);
20488 return Py_BuildValue((char *)"");
20489 }
20490 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20491 PyObject *resultobj;
20492 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20493 wxPoint result;
20494 PyObject * obj0 = 0 ;
20495 char *kwnames[] = {
20496 (char *) "self", NULL
20497 };
20498
20499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20501 if (SWIG_arg_fail(1)) SWIG_fail;
20502 {
20503 PyThreadState* __tstate = wxPyBeginAllowThreads();
20504 result = (arg1)->GetPosition();
20505
20506 wxPyEndAllowThreads(__tstate);
20507 if (PyErr_Occurred()) SWIG_fail;
20508 }
20509 {
20510 wxPoint * resultptr;
20511 resultptr = new wxPoint((wxPoint &)(result));
20512 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20513 }
20514 return resultobj;
20515 fail:
20516 return NULL;
20517 }
20518
20519
20520 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20521 PyObject *resultobj;
20522 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20523 int result;
20524 PyObject * obj0 = 0 ;
20525 char *kwnames[] = {
20526 (char *) "self", NULL
20527 };
20528
20529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20531 if (SWIG_arg_fail(1)) SWIG_fail;
20532 {
20533 PyThreadState* __tstate = wxPyBeginAllowThreads();
20534 result = (int)(arg1)->GetNumberOfFiles();
20535
20536 wxPyEndAllowThreads(__tstate);
20537 if (PyErr_Occurred()) SWIG_fail;
20538 }
20539 {
20540 resultobj = SWIG_From_int((int)(result));
20541 }
20542 return resultobj;
20543 fail:
20544 return NULL;
20545 }
20546
20547
20548 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20549 PyObject *resultobj;
20550 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20551 PyObject *result;
20552 PyObject * obj0 = 0 ;
20553 char *kwnames[] = {
20554 (char *) "self", NULL
20555 };
20556
20557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20559 if (SWIG_arg_fail(1)) SWIG_fail;
20560 {
20561 PyThreadState* __tstate = wxPyBeginAllowThreads();
20562 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20563
20564 wxPyEndAllowThreads(__tstate);
20565 if (PyErr_Occurred()) SWIG_fail;
20566 }
20567 resultobj = result;
20568 return resultobj;
20569 fail:
20570 return NULL;
20571 }
20572
20573
20574 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20575 PyObject *obj;
20576 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20577 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20578 Py_INCREF(obj);
20579 return Py_BuildValue((char *)"");
20580 }
20581 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20582 PyObject *resultobj;
20583 int arg1 = (int) 0 ;
20584 wxUpdateUIEvent *result;
20585 PyObject * obj0 = 0 ;
20586 char *kwnames[] = {
20587 (char *) "commandId", NULL
20588 };
20589
20590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20591 if (obj0) {
20592 {
20593 arg1 = (int)(SWIG_As_int(obj0));
20594 if (SWIG_arg_fail(1)) SWIG_fail;
20595 }
20596 }
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20600
20601 wxPyEndAllowThreads(__tstate);
20602 if (PyErr_Occurred()) SWIG_fail;
20603 }
20604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20605 return resultobj;
20606 fail:
20607 return NULL;
20608 }
20609
20610
20611 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20612 PyObject *resultobj;
20613 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20614 bool result;
20615 PyObject * obj0 = 0 ;
20616 char *kwnames[] = {
20617 (char *) "self", NULL
20618 };
20619
20620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
20625 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20626
20627 wxPyEndAllowThreads(__tstate);
20628 if (PyErr_Occurred()) SWIG_fail;
20629 }
20630 {
20631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20632 }
20633 return resultobj;
20634 fail:
20635 return NULL;
20636 }
20637
20638
20639 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20640 PyObject *resultobj;
20641 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20642 bool result;
20643 PyObject * obj0 = 0 ;
20644 char *kwnames[] = {
20645 (char *) "self", NULL
20646 };
20647
20648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20650 if (SWIG_arg_fail(1)) SWIG_fail;
20651 {
20652 PyThreadState* __tstate = wxPyBeginAllowThreads();
20653 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20654
20655 wxPyEndAllowThreads(__tstate);
20656 if (PyErr_Occurred()) SWIG_fail;
20657 }
20658 {
20659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20660 }
20661 return resultobj;
20662 fail:
20663 return NULL;
20664 }
20665
20666
20667 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20668 PyObject *resultobj;
20669 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20670 wxString result;
20671 PyObject * obj0 = 0 ;
20672 char *kwnames[] = {
20673 (char *) "self", NULL
20674 };
20675
20676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20678 if (SWIG_arg_fail(1)) SWIG_fail;
20679 {
20680 PyThreadState* __tstate = wxPyBeginAllowThreads();
20681 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20682
20683 wxPyEndAllowThreads(__tstate);
20684 if (PyErr_Occurred()) SWIG_fail;
20685 }
20686 {
20687 #if wxUSE_UNICODE
20688 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20689 #else
20690 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20691 #endif
20692 }
20693 return resultobj;
20694 fail:
20695 return NULL;
20696 }
20697
20698
20699 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20700 PyObject *resultobj;
20701 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20702 bool result;
20703 PyObject * obj0 = 0 ;
20704 char *kwnames[] = {
20705 (char *) "self", NULL
20706 };
20707
20708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20710 if (SWIG_arg_fail(1)) SWIG_fail;
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20714
20715 wxPyEndAllowThreads(__tstate);
20716 if (PyErr_Occurred()) SWIG_fail;
20717 }
20718 {
20719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20720 }
20721 return resultobj;
20722 fail:
20723 return NULL;
20724 }
20725
20726
20727 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20728 PyObject *resultobj;
20729 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20730 bool result;
20731 PyObject * obj0 = 0 ;
20732 char *kwnames[] = {
20733 (char *) "self", NULL
20734 };
20735
20736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20738 if (SWIG_arg_fail(1)) SWIG_fail;
20739 {
20740 PyThreadState* __tstate = wxPyBeginAllowThreads();
20741 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20742
20743 wxPyEndAllowThreads(__tstate);
20744 if (PyErr_Occurred()) SWIG_fail;
20745 }
20746 {
20747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20748 }
20749 return resultobj;
20750 fail:
20751 return NULL;
20752 }
20753
20754
20755 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20756 PyObject *resultobj;
20757 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20758 bool result;
20759 PyObject * obj0 = 0 ;
20760 char *kwnames[] = {
20761 (char *) "self", NULL
20762 };
20763
20764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20766 if (SWIG_arg_fail(1)) SWIG_fail;
20767 {
20768 PyThreadState* __tstate = wxPyBeginAllowThreads();
20769 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20770
20771 wxPyEndAllowThreads(__tstate);
20772 if (PyErr_Occurred()) SWIG_fail;
20773 }
20774 {
20775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20776 }
20777 return resultobj;
20778 fail:
20779 return NULL;
20780 }
20781
20782
20783 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20784 PyObject *resultobj;
20785 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20786 bool arg2 ;
20787 PyObject * obj0 = 0 ;
20788 PyObject * obj1 = 0 ;
20789 char *kwnames[] = {
20790 (char *) "self",(char *) "check", NULL
20791 };
20792
20793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20795 if (SWIG_arg_fail(1)) SWIG_fail;
20796 {
20797 arg2 = (bool)(SWIG_As_bool(obj1));
20798 if (SWIG_arg_fail(2)) SWIG_fail;
20799 }
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 (arg1)->Check(arg2);
20803
20804 wxPyEndAllowThreads(__tstate);
20805 if (PyErr_Occurred()) SWIG_fail;
20806 }
20807 Py_INCREF(Py_None); resultobj = Py_None;
20808 return resultobj;
20809 fail:
20810 return NULL;
20811 }
20812
20813
20814 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20815 PyObject *resultobj;
20816 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20817 bool arg2 ;
20818 PyObject * obj0 = 0 ;
20819 PyObject * obj1 = 0 ;
20820 char *kwnames[] = {
20821 (char *) "self",(char *) "enable", NULL
20822 };
20823
20824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20826 if (SWIG_arg_fail(1)) SWIG_fail;
20827 {
20828 arg2 = (bool)(SWIG_As_bool(obj1));
20829 if (SWIG_arg_fail(2)) SWIG_fail;
20830 }
20831 {
20832 PyThreadState* __tstate = wxPyBeginAllowThreads();
20833 (arg1)->Enable(arg2);
20834
20835 wxPyEndAllowThreads(__tstate);
20836 if (PyErr_Occurred()) SWIG_fail;
20837 }
20838 Py_INCREF(Py_None); resultobj = Py_None;
20839 return resultobj;
20840 fail:
20841 return NULL;
20842 }
20843
20844
20845 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20846 PyObject *resultobj;
20847 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20848 wxString *arg2 = 0 ;
20849 bool temp2 = false ;
20850 PyObject * obj0 = 0 ;
20851 PyObject * obj1 = 0 ;
20852 char *kwnames[] = {
20853 (char *) "self",(char *) "text", NULL
20854 };
20855
20856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20858 if (SWIG_arg_fail(1)) SWIG_fail;
20859 {
20860 arg2 = wxString_in_helper(obj1);
20861 if (arg2 == NULL) SWIG_fail;
20862 temp2 = true;
20863 }
20864 {
20865 PyThreadState* __tstate = wxPyBeginAllowThreads();
20866 (arg1)->SetText((wxString const &)*arg2);
20867
20868 wxPyEndAllowThreads(__tstate);
20869 if (PyErr_Occurred()) SWIG_fail;
20870 }
20871 Py_INCREF(Py_None); resultobj = Py_None;
20872 {
20873 if (temp2)
20874 delete arg2;
20875 }
20876 return resultobj;
20877 fail:
20878 {
20879 if (temp2)
20880 delete arg2;
20881 }
20882 return NULL;
20883 }
20884
20885
20886 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20887 PyObject *resultobj;
20888 long arg1 ;
20889 PyObject * obj0 = 0 ;
20890 char *kwnames[] = {
20891 (char *) "updateInterval", NULL
20892 };
20893
20894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20895 {
20896 arg1 = (long)(SWIG_As_long(obj0));
20897 if (SWIG_arg_fail(1)) SWIG_fail;
20898 }
20899 {
20900 PyThreadState* __tstate = wxPyBeginAllowThreads();
20901 wxUpdateUIEvent::SetUpdateInterval(arg1);
20902
20903 wxPyEndAllowThreads(__tstate);
20904 if (PyErr_Occurred()) SWIG_fail;
20905 }
20906 Py_INCREF(Py_None); resultobj = Py_None;
20907 return resultobj;
20908 fail:
20909 return NULL;
20910 }
20911
20912
20913 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20914 PyObject *resultobj;
20915 long result;
20916 char *kwnames[] = {
20917 NULL
20918 };
20919
20920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20921 {
20922 PyThreadState* __tstate = wxPyBeginAllowThreads();
20923 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20924
20925 wxPyEndAllowThreads(__tstate);
20926 if (PyErr_Occurred()) SWIG_fail;
20927 }
20928 {
20929 resultobj = SWIG_From_long((long)(result));
20930 }
20931 return resultobj;
20932 fail:
20933 return NULL;
20934 }
20935
20936
20937 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20938 PyObject *resultobj;
20939 wxWindow *arg1 = (wxWindow *) 0 ;
20940 bool result;
20941 PyObject * obj0 = 0 ;
20942 char *kwnames[] = {
20943 (char *) "win", NULL
20944 };
20945
20946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20948 if (SWIG_arg_fail(1)) SWIG_fail;
20949 {
20950 PyThreadState* __tstate = wxPyBeginAllowThreads();
20951 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20952
20953 wxPyEndAllowThreads(__tstate);
20954 if (PyErr_Occurred()) SWIG_fail;
20955 }
20956 {
20957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20958 }
20959 return resultobj;
20960 fail:
20961 return NULL;
20962 }
20963
20964
20965 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20966 PyObject *resultobj;
20967 char *kwnames[] = {
20968 NULL
20969 };
20970
20971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20972 {
20973 PyThreadState* __tstate = wxPyBeginAllowThreads();
20974 wxUpdateUIEvent::ResetUpdateTime();
20975
20976 wxPyEndAllowThreads(__tstate);
20977 if (PyErr_Occurred()) SWIG_fail;
20978 }
20979 Py_INCREF(Py_None); resultobj = Py_None;
20980 return resultobj;
20981 fail:
20982 return NULL;
20983 }
20984
20985
20986 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20987 PyObject *resultobj;
20988 wxUpdateUIMode arg1 ;
20989 PyObject * obj0 = 0 ;
20990 char *kwnames[] = {
20991 (char *) "mode", NULL
20992 };
20993
20994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20995 {
20996 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20997 if (SWIG_arg_fail(1)) SWIG_fail;
20998 }
20999 {
21000 PyThreadState* __tstate = wxPyBeginAllowThreads();
21001 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21002
21003 wxPyEndAllowThreads(__tstate);
21004 if (PyErr_Occurred()) SWIG_fail;
21005 }
21006 Py_INCREF(Py_None); resultobj = Py_None;
21007 return resultobj;
21008 fail:
21009 return NULL;
21010 }
21011
21012
21013 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21014 PyObject *resultobj;
21015 wxUpdateUIMode result;
21016 char *kwnames[] = {
21017 NULL
21018 };
21019
21020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21021 {
21022 PyThreadState* __tstate = wxPyBeginAllowThreads();
21023 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21024
21025 wxPyEndAllowThreads(__tstate);
21026 if (PyErr_Occurred()) SWIG_fail;
21027 }
21028 resultobj = SWIG_From_int((result));
21029 return resultobj;
21030 fail:
21031 return NULL;
21032 }
21033
21034
21035 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21036 PyObject *obj;
21037 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21038 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21039 Py_INCREF(obj);
21040 return Py_BuildValue((char *)"");
21041 }
21042 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21043 PyObject *resultobj;
21044 wxSysColourChangedEvent *result;
21045 char *kwnames[] = {
21046 NULL
21047 };
21048
21049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21050 {
21051 PyThreadState* __tstate = wxPyBeginAllowThreads();
21052 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21053
21054 wxPyEndAllowThreads(__tstate);
21055 if (PyErr_Occurred()) SWIG_fail;
21056 }
21057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21058 return resultobj;
21059 fail:
21060 return NULL;
21061 }
21062
21063
21064 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21065 PyObject *obj;
21066 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21067 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21068 Py_INCREF(obj);
21069 return Py_BuildValue((char *)"");
21070 }
21071 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21072 PyObject *resultobj;
21073 int arg1 = (int) 0 ;
21074 wxWindow *arg2 = (wxWindow *) NULL ;
21075 wxMouseCaptureChangedEvent *result;
21076 PyObject * obj0 = 0 ;
21077 PyObject * obj1 = 0 ;
21078 char *kwnames[] = {
21079 (char *) "winid",(char *) "gainedCapture", NULL
21080 };
21081
21082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21083 if (obj0) {
21084 {
21085 arg1 = (int)(SWIG_As_int(obj0));
21086 if (SWIG_arg_fail(1)) SWIG_fail;
21087 }
21088 }
21089 if (obj1) {
21090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21091 if (SWIG_arg_fail(2)) SWIG_fail;
21092 }
21093 {
21094 PyThreadState* __tstate = wxPyBeginAllowThreads();
21095 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21096
21097 wxPyEndAllowThreads(__tstate);
21098 if (PyErr_Occurred()) SWIG_fail;
21099 }
21100 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21101 return resultobj;
21102 fail:
21103 return NULL;
21104 }
21105
21106
21107 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21108 PyObject *resultobj;
21109 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21110 wxWindow *result;
21111 PyObject * obj0 = 0 ;
21112 char *kwnames[] = {
21113 (char *) "self", NULL
21114 };
21115
21116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21118 if (SWIG_arg_fail(1)) SWIG_fail;
21119 {
21120 PyThreadState* __tstate = wxPyBeginAllowThreads();
21121 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21122
21123 wxPyEndAllowThreads(__tstate);
21124 if (PyErr_Occurred()) SWIG_fail;
21125 }
21126 {
21127 resultobj = wxPyMake_wxObject(result, 0);
21128 }
21129 return resultobj;
21130 fail:
21131 return NULL;
21132 }
21133
21134
21135 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21136 PyObject *obj;
21137 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21138 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21139 Py_INCREF(obj);
21140 return Py_BuildValue((char *)"");
21141 }
21142 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21143 PyObject *resultobj;
21144 wxDisplayChangedEvent *result;
21145 char *kwnames[] = {
21146 NULL
21147 };
21148
21149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21150 {
21151 PyThreadState* __tstate = wxPyBeginAllowThreads();
21152 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21153
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21165 PyObject *obj;
21166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21167 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21168 Py_INCREF(obj);
21169 return Py_BuildValue((char *)"");
21170 }
21171 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21172 PyObject *resultobj;
21173 int arg1 = (int) 0 ;
21174 wxPaletteChangedEvent *result;
21175 PyObject * obj0 = 0 ;
21176 char *kwnames[] = {
21177 (char *) "id", NULL
21178 };
21179
21180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21181 if (obj0) {
21182 {
21183 arg1 = (int)(SWIG_As_int(obj0));
21184 if (SWIG_arg_fail(1)) SWIG_fail;
21185 }
21186 }
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21190
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21195 return resultobj;
21196 fail:
21197 return NULL;
21198 }
21199
21200
21201 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21202 PyObject *resultobj;
21203 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21204 wxWindow *arg2 = (wxWindow *) 0 ;
21205 PyObject * obj0 = 0 ;
21206 PyObject * obj1 = 0 ;
21207 char *kwnames[] = {
21208 (char *) "self",(char *) "win", NULL
21209 };
21210
21211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21213 if (SWIG_arg_fail(1)) SWIG_fail;
21214 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21215 if (SWIG_arg_fail(2)) SWIG_fail;
21216 {
21217 PyThreadState* __tstate = wxPyBeginAllowThreads();
21218 (arg1)->SetChangedWindow(arg2);
21219
21220 wxPyEndAllowThreads(__tstate);
21221 if (PyErr_Occurred()) SWIG_fail;
21222 }
21223 Py_INCREF(Py_None); resultobj = Py_None;
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21231 PyObject *resultobj;
21232 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21233 wxWindow *result;
21234 PyObject * obj0 = 0 ;
21235 char *kwnames[] = {
21236 (char *) "self", NULL
21237 };
21238
21239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21241 if (SWIG_arg_fail(1)) SWIG_fail;
21242 {
21243 PyThreadState* __tstate = wxPyBeginAllowThreads();
21244 result = (wxWindow *)(arg1)->GetChangedWindow();
21245
21246 wxPyEndAllowThreads(__tstate);
21247 if (PyErr_Occurred()) SWIG_fail;
21248 }
21249 {
21250 resultobj = wxPyMake_wxObject(result, 0);
21251 }
21252 return resultobj;
21253 fail:
21254 return NULL;
21255 }
21256
21257
21258 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21259 PyObject *obj;
21260 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21261 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21262 Py_INCREF(obj);
21263 return Py_BuildValue((char *)"");
21264 }
21265 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21266 PyObject *resultobj;
21267 int arg1 = (int) 0 ;
21268 wxQueryNewPaletteEvent *result;
21269 PyObject * obj0 = 0 ;
21270 char *kwnames[] = {
21271 (char *) "winid", NULL
21272 };
21273
21274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21275 if (obj0) {
21276 {
21277 arg1 = (int)(SWIG_As_int(obj0));
21278 if (SWIG_arg_fail(1)) SWIG_fail;
21279 }
21280 }
21281 {
21282 PyThreadState* __tstate = wxPyBeginAllowThreads();
21283 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21284
21285 wxPyEndAllowThreads(__tstate);
21286 if (PyErr_Occurred()) SWIG_fail;
21287 }
21288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21289 return resultobj;
21290 fail:
21291 return NULL;
21292 }
21293
21294
21295 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21296 PyObject *resultobj;
21297 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21298 bool arg2 ;
21299 PyObject * obj0 = 0 ;
21300 PyObject * obj1 = 0 ;
21301 char *kwnames[] = {
21302 (char *) "self",(char *) "realized", NULL
21303 };
21304
21305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21307 if (SWIG_arg_fail(1)) SWIG_fail;
21308 {
21309 arg2 = (bool)(SWIG_As_bool(obj1));
21310 if (SWIG_arg_fail(2)) SWIG_fail;
21311 }
21312 {
21313 PyThreadState* __tstate = wxPyBeginAllowThreads();
21314 (arg1)->SetPaletteRealized(arg2);
21315
21316 wxPyEndAllowThreads(__tstate);
21317 if (PyErr_Occurred()) SWIG_fail;
21318 }
21319 Py_INCREF(Py_None); resultobj = Py_None;
21320 return resultobj;
21321 fail:
21322 return NULL;
21323 }
21324
21325
21326 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21327 PyObject *resultobj;
21328 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21329 bool result;
21330 PyObject * obj0 = 0 ;
21331 char *kwnames[] = {
21332 (char *) "self", NULL
21333 };
21334
21335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21337 if (SWIG_arg_fail(1)) SWIG_fail;
21338 {
21339 PyThreadState* __tstate = wxPyBeginAllowThreads();
21340 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21341
21342 wxPyEndAllowThreads(__tstate);
21343 if (PyErr_Occurred()) SWIG_fail;
21344 }
21345 {
21346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21347 }
21348 return resultobj;
21349 fail:
21350 return NULL;
21351 }
21352
21353
21354 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21355 PyObject *obj;
21356 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21357 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21358 Py_INCREF(obj);
21359 return Py_BuildValue((char *)"");
21360 }
21361 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21362 PyObject *resultobj;
21363 wxNavigationKeyEvent *result;
21364 char *kwnames[] = {
21365 NULL
21366 };
21367
21368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21369 {
21370 PyThreadState* __tstate = wxPyBeginAllowThreads();
21371 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21372
21373 wxPyEndAllowThreads(__tstate);
21374 if (PyErr_Occurred()) SWIG_fail;
21375 }
21376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21377 return resultobj;
21378 fail:
21379 return NULL;
21380 }
21381
21382
21383 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21384 PyObject *resultobj;
21385 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21386 bool result;
21387 PyObject * obj0 = 0 ;
21388 char *kwnames[] = {
21389 (char *) "self", NULL
21390 };
21391
21392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21394 if (SWIG_arg_fail(1)) SWIG_fail;
21395 {
21396 PyThreadState* __tstate = wxPyBeginAllowThreads();
21397 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21398
21399 wxPyEndAllowThreads(__tstate);
21400 if (PyErr_Occurred()) SWIG_fail;
21401 }
21402 {
21403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21404 }
21405 return resultobj;
21406 fail:
21407 return NULL;
21408 }
21409
21410
21411 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21412 PyObject *resultobj;
21413 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21414 bool arg2 ;
21415 PyObject * obj0 = 0 ;
21416 PyObject * obj1 = 0 ;
21417 char *kwnames[] = {
21418 (char *) "self",(char *) "forward", NULL
21419 };
21420
21421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21423 if (SWIG_arg_fail(1)) SWIG_fail;
21424 {
21425 arg2 = (bool)(SWIG_As_bool(obj1));
21426 if (SWIG_arg_fail(2)) SWIG_fail;
21427 }
21428 {
21429 PyThreadState* __tstate = wxPyBeginAllowThreads();
21430 (arg1)->SetDirection(arg2);
21431
21432 wxPyEndAllowThreads(__tstate);
21433 if (PyErr_Occurred()) SWIG_fail;
21434 }
21435 Py_INCREF(Py_None); resultobj = Py_None;
21436 return resultobj;
21437 fail:
21438 return NULL;
21439 }
21440
21441
21442 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21443 PyObject *resultobj;
21444 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21445 bool result;
21446 PyObject * obj0 = 0 ;
21447 char *kwnames[] = {
21448 (char *) "self", NULL
21449 };
21450
21451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21453 if (SWIG_arg_fail(1)) SWIG_fail;
21454 {
21455 PyThreadState* __tstate = wxPyBeginAllowThreads();
21456 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21457
21458 wxPyEndAllowThreads(__tstate);
21459 if (PyErr_Occurred()) SWIG_fail;
21460 }
21461 {
21462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21463 }
21464 return resultobj;
21465 fail:
21466 return NULL;
21467 }
21468
21469
21470 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21471 PyObject *resultobj;
21472 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21473 bool arg2 ;
21474 PyObject * obj0 = 0 ;
21475 PyObject * obj1 = 0 ;
21476 char *kwnames[] = {
21477 (char *) "self",(char *) "ischange", NULL
21478 };
21479
21480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21482 if (SWIG_arg_fail(1)) SWIG_fail;
21483 {
21484 arg2 = (bool)(SWIG_As_bool(obj1));
21485 if (SWIG_arg_fail(2)) SWIG_fail;
21486 }
21487 {
21488 PyThreadState* __tstate = wxPyBeginAllowThreads();
21489 (arg1)->SetWindowChange(arg2);
21490
21491 wxPyEndAllowThreads(__tstate);
21492 if (PyErr_Occurred()) SWIG_fail;
21493 }
21494 Py_INCREF(Py_None); resultobj = Py_None;
21495 return resultobj;
21496 fail:
21497 return NULL;
21498 }
21499
21500
21501 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21502 PyObject *resultobj;
21503 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21504 bool result;
21505 PyObject * obj0 = 0 ;
21506 char *kwnames[] = {
21507 (char *) "self", NULL
21508 };
21509
21510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21512 if (SWIG_arg_fail(1)) SWIG_fail;
21513 {
21514 PyThreadState* __tstate = wxPyBeginAllowThreads();
21515 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21516
21517 wxPyEndAllowThreads(__tstate);
21518 if (PyErr_Occurred()) SWIG_fail;
21519 }
21520 {
21521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21522 }
21523 return resultobj;
21524 fail:
21525 return NULL;
21526 }
21527
21528
21529 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21530 PyObject *resultobj;
21531 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21532 bool arg2 ;
21533 PyObject * obj0 = 0 ;
21534 PyObject * obj1 = 0 ;
21535 char *kwnames[] = {
21536 (char *) "self",(char *) "bIs", NULL
21537 };
21538
21539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21541 if (SWIG_arg_fail(1)) SWIG_fail;
21542 {
21543 arg2 = (bool)(SWIG_As_bool(obj1));
21544 if (SWIG_arg_fail(2)) SWIG_fail;
21545 }
21546 {
21547 PyThreadState* __tstate = wxPyBeginAllowThreads();
21548 (arg1)->SetFromTab(arg2);
21549
21550 wxPyEndAllowThreads(__tstate);
21551 if (PyErr_Occurred()) SWIG_fail;
21552 }
21553 Py_INCREF(Py_None); resultobj = Py_None;
21554 return resultobj;
21555 fail:
21556 return NULL;
21557 }
21558
21559
21560 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21561 PyObject *resultobj;
21562 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21563 long arg2 ;
21564 PyObject * obj0 = 0 ;
21565 PyObject * obj1 = 0 ;
21566 char *kwnames[] = {
21567 (char *) "self",(char *) "flags", NULL
21568 };
21569
21570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21572 if (SWIG_arg_fail(1)) SWIG_fail;
21573 {
21574 arg2 = (long)(SWIG_As_long(obj1));
21575 if (SWIG_arg_fail(2)) SWIG_fail;
21576 }
21577 {
21578 PyThreadState* __tstate = wxPyBeginAllowThreads();
21579 (arg1)->SetFlags(arg2);
21580
21581 wxPyEndAllowThreads(__tstate);
21582 if (PyErr_Occurred()) SWIG_fail;
21583 }
21584 Py_INCREF(Py_None); resultobj = Py_None;
21585 return resultobj;
21586 fail:
21587 return NULL;
21588 }
21589
21590
21591 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21592 PyObject *resultobj;
21593 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21594 wxWindow *result;
21595 PyObject * obj0 = 0 ;
21596 char *kwnames[] = {
21597 (char *) "self", NULL
21598 };
21599
21600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21602 if (SWIG_arg_fail(1)) SWIG_fail;
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21606
21607 wxPyEndAllowThreads(__tstate);
21608 if (PyErr_Occurred()) SWIG_fail;
21609 }
21610 {
21611 resultobj = wxPyMake_wxObject(result, 0);
21612 }
21613 return resultobj;
21614 fail:
21615 return NULL;
21616 }
21617
21618
21619 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21620 PyObject *resultobj;
21621 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21622 wxWindow *arg2 = (wxWindow *) 0 ;
21623 PyObject * obj0 = 0 ;
21624 PyObject * obj1 = 0 ;
21625 char *kwnames[] = {
21626 (char *) "self",(char *) "win", NULL
21627 };
21628
21629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21631 if (SWIG_arg_fail(1)) SWIG_fail;
21632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21633 if (SWIG_arg_fail(2)) SWIG_fail;
21634 {
21635 PyThreadState* __tstate = wxPyBeginAllowThreads();
21636 (arg1)->SetCurrentFocus(arg2);
21637
21638 wxPyEndAllowThreads(__tstate);
21639 if (PyErr_Occurred()) SWIG_fail;
21640 }
21641 Py_INCREF(Py_None); resultobj = Py_None;
21642 return resultobj;
21643 fail:
21644 return NULL;
21645 }
21646
21647
21648 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21649 PyObject *obj;
21650 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21651 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21652 Py_INCREF(obj);
21653 return Py_BuildValue((char *)"");
21654 }
21655 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21656 PyObject *resultobj;
21657 wxWindow *arg1 = (wxWindow *) NULL ;
21658 wxWindowCreateEvent *result;
21659 PyObject * obj0 = 0 ;
21660 char *kwnames[] = {
21661 (char *) "win", NULL
21662 };
21663
21664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21665 if (obj0) {
21666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21667 if (SWIG_arg_fail(1)) SWIG_fail;
21668 }
21669 {
21670 PyThreadState* __tstate = wxPyBeginAllowThreads();
21671 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21672
21673 wxPyEndAllowThreads(__tstate);
21674 if (PyErr_Occurred()) SWIG_fail;
21675 }
21676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21677 return resultobj;
21678 fail:
21679 return NULL;
21680 }
21681
21682
21683 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21684 PyObject *resultobj;
21685 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21686 wxWindow *result;
21687 PyObject * obj0 = 0 ;
21688 char *kwnames[] = {
21689 (char *) "self", NULL
21690 };
21691
21692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21694 if (SWIG_arg_fail(1)) SWIG_fail;
21695 {
21696 PyThreadState* __tstate = wxPyBeginAllowThreads();
21697 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21698
21699 wxPyEndAllowThreads(__tstate);
21700 if (PyErr_Occurred()) SWIG_fail;
21701 }
21702 {
21703 resultobj = wxPyMake_wxObject(result, 0);
21704 }
21705 return resultobj;
21706 fail:
21707 return NULL;
21708 }
21709
21710
21711 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21712 PyObject *obj;
21713 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21714 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21715 Py_INCREF(obj);
21716 return Py_BuildValue((char *)"");
21717 }
21718 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21719 PyObject *resultobj;
21720 wxWindow *arg1 = (wxWindow *) NULL ;
21721 wxWindowDestroyEvent *result;
21722 PyObject * obj0 = 0 ;
21723 char *kwnames[] = {
21724 (char *) "win", NULL
21725 };
21726
21727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21728 if (obj0) {
21729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21730 if (SWIG_arg_fail(1)) SWIG_fail;
21731 }
21732 {
21733 PyThreadState* __tstate = wxPyBeginAllowThreads();
21734 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21735
21736 wxPyEndAllowThreads(__tstate);
21737 if (PyErr_Occurred()) SWIG_fail;
21738 }
21739 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21740 return resultobj;
21741 fail:
21742 return NULL;
21743 }
21744
21745
21746 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21747 PyObject *resultobj;
21748 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21749 wxWindow *result;
21750 PyObject * obj0 = 0 ;
21751 char *kwnames[] = {
21752 (char *) "self", NULL
21753 };
21754
21755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21757 if (SWIG_arg_fail(1)) SWIG_fail;
21758 {
21759 PyThreadState* __tstate = wxPyBeginAllowThreads();
21760 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21761
21762 wxPyEndAllowThreads(__tstate);
21763 if (PyErr_Occurred()) SWIG_fail;
21764 }
21765 {
21766 resultobj = wxPyMake_wxObject(result, 0);
21767 }
21768 return resultobj;
21769 fail:
21770 return NULL;
21771 }
21772
21773
21774 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21775 PyObject *obj;
21776 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21777 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21778 Py_INCREF(obj);
21779 return Py_BuildValue((char *)"");
21780 }
21781 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21782 PyObject *resultobj;
21783 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21784 int arg2 = (int) 0 ;
21785 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21786 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21787 wxContextMenuEvent *result;
21788 wxPoint temp3 ;
21789 PyObject * obj0 = 0 ;
21790 PyObject * obj1 = 0 ;
21791 PyObject * obj2 = 0 ;
21792 char *kwnames[] = {
21793 (char *) "type",(char *) "winid",(char *) "pt", NULL
21794 };
21795
21796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21797 if (obj0) {
21798 {
21799 arg1 = (wxEventType)(SWIG_As_int(obj0));
21800 if (SWIG_arg_fail(1)) SWIG_fail;
21801 }
21802 }
21803 if (obj1) {
21804 {
21805 arg2 = (int)(SWIG_As_int(obj1));
21806 if (SWIG_arg_fail(2)) SWIG_fail;
21807 }
21808 }
21809 if (obj2) {
21810 {
21811 arg3 = &temp3;
21812 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21813 }
21814 }
21815 {
21816 PyThreadState* __tstate = wxPyBeginAllowThreads();
21817 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21818
21819 wxPyEndAllowThreads(__tstate);
21820 if (PyErr_Occurred()) SWIG_fail;
21821 }
21822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21823 return resultobj;
21824 fail:
21825 return NULL;
21826 }
21827
21828
21829 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21830 PyObject *resultobj;
21831 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21832 wxPoint *result;
21833 PyObject * obj0 = 0 ;
21834 char *kwnames[] = {
21835 (char *) "self", NULL
21836 };
21837
21838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21840 if (SWIG_arg_fail(1)) SWIG_fail;
21841 {
21842 PyThreadState* __tstate = wxPyBeginAllowThreads();
21843 {
21844 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21845 result = (wxPoint *) &_result_ref;
21846 }
21847
21848 wxPyEndAllowThreads(__tstate);
21849 if (PyErr_Occurred()) SWIG_fail;
21850 }
21851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21852 return resultobj;
21853 fail:
21854 return NULL;
21855 }
21856
21857
21858 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21859 PyObject *resultobj;
21860 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21861 wxPoint *arg2 = 0 ;
21862 wxPoint temp2 ;
21863 PyObject * obj0 = 0 ;
21864 PyObject * obj1 = 0 ;
21865 char *kwnames[] = {
21866 (char *) "self",(char *) "pos", NULL
21867 };
21868
21869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21871 if (SWIG_arg_fail(1)) SWIG_fail;
21872 {
21873 arg2 = &temp2;
21874 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21875 }
21876 {
21877 PyThreadState* __tstate = wxPyBeginAllowThreads();
21878 (arg1)->SetPosition((wxPoint const &)*arg2);
21879
21880 wxPyEndAllowThreads(__tstate);
21881 if (PyErr_Occurred()) SWIG_fail;
21882 }
21883 Py_INCREF(Py_None); resultobj = Py_None;
21884 return resultobj;
21885 fail:
21886 return NULL;
21887 }
21888
21889
21890 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21891 PyObject *obj;
21892 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21893 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21894 Py_INCREF(obj);
21895 return Py_BuildValue((char *)"");
21896 }
21897 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21898 PyObject *resultobj;
21899 wxIdleEvent *result;
21900 char *kwnames[] = {
21901 NULL
21902 };
21903
21904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21905 {
21906 PyThreadState* __tstate = wxPyBeginAllowThreads();
21907 result = (wxIdleEvent *)new wxIdleEvent();
21908
21909 wxPyEndAllowThreads(__tstate);
21910 if (PyErr_Occurred()) SWIG_fail;
21911 }
21912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21913 return resultobj;
21914 fail:
21915 return NULL;
21916 }
21917
21918
21919 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21920 PyObject *resultobj;
21921 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21922 bool arg2 = (bool) true ;
21923 PyObject * obj0 = 0 ;
21924 PyObject * obj1 = 0 ;
21925 char *kwnames[] = {
21926 (char *) "self",(char *) "needMore", NULL
21927 };
21928
21929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21931 if (SWIG_arg_fail(1)) SWIG_fail;
21932 if (obj1) {
21933 {
21934 arg2 = (bool)(SWIG_As_bool(obj1));
21935 if (SWIG_arg_fail(2)) SWIG_fail;
21936 }
21937 }
21938 {
21939 PyThreadState* __tstate = wxPyBeginAllowThreads();
21940 (arg1)->RequestMore(arg2);
21941
21942 wxPyEndAllowThreads(__tstate);
21943 if (PyErr_Occurred()) SWIG_fail;
21944 }
21945 Py_INCREF(Py_None); resultobj = Py_None;
21946 return resultobj;
21947 fail:
21948 return NULL;
21949 }
21950
21951
21952 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21953 PyObject *resultobj;
21954 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21955 bool result;
21956 PyObject * obj0 = 0 ;
21957 char *kwnames[] = {
21958 (char *) "self", NULL
21959 };
21960
21961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21963 if (SWIG_arg_fail(1)) SWIG_fail;
21964 {
21965 PyThreadState* __tstate = wxPyBeginAllowThreads();
21966 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21967
21968 wxPyEndAllowThreads(__tstate);
21969 if (PyErr_Occurred()) SWIG_fail;
21970 }
21971 {
21972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21973 }
21974 return resultobj;
21975 fail:
21976 return NULL;
21977 }
21978
21979
21980 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21981 PyObject *resultobj;
21982 wxIdleMode arg1 ;
21983 PyObject * obj0 = 0 ;
21984 char *kwnames[] = {
21985 (char *) "mode", NULL
21986 };
21987
21988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21989 {
21990 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21991 if (SWIG_arg_fail(1)) SWIG_fail;
21992 }
21993 {
21994 PyThreadState* __tstate = wxPyBeginAllowThreads();
21995 wxIdleEvent::SetMode((wxIdleMode )arg1);
21996
21997 wxPyEndAllowThreads(__tstate);
21998 if (PyErr_Occurred()) SWIG_fail;
21999 }
22000 Py_INCREF(Py_None); resultobj = Py_None;
22001 return resultobj;
22002 fail:
22003 return NULL;
22004 }
22005
22006
22007 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22008 PyObject *resultobj;
22009 wxIdleMode result;
22010 char *kwnames[] = {
22011 NULL
22012 };
22013
22014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22015 {
22016 PyThreadState* __tstate = wxPyBeginAllowThreads();
22017 result = (wxIdleMode)wxIdleEvent::GetMode();
22018
22019 wxPyEndAllowThreads(__tstate);
22020 if (PyErr_Occurred()) SWIG_fail;
22021 }
22022 resultobj = SWIG_From_int((result));
22023 return resultobj;
22024 fail:
22025 return NULL;
22026 }
22027
22028
22029 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22030 PyObject *resultobj;
22031 wxWindow *arg1 = (wxWindow *) 0 ;
22032 bool result;
22033 PyObject * obj0 = 0 ;
22034 char *kwnames[] = {
22035 (char *) "win", NULL
22036 };
22037
22038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22040 if (SWIG_arg_fail(1)) SWIG_fail;
22041 {
22042 PyThreadState* __tstate = wxPyBeginAllowThreads();
22043 result = (bool)wxIdleEvent::CanSend(arg1);
22044
22045 wxPyEndAllowThreads(__tstate);
22046 if (PyErr_Occurred()) SWIG_fail;
22047 }
22048 {
22049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22050 }
22051 return resultobj;
22052 fail:
22053 return NULL;
22054 }
22055
22056
22057 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22058 PyObject *obj;
22059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22060 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22061 Py_INCREF(obj);
22062 return Py_BuildValue((char *)"");
22063 }
22064 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22065 PyObject *resultobj;
22066 int arg1 = (int) 0 ;
22067 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22068 wxPyEvent *result;
22069 PyObject * obj0 = 0 ;
22070 PyObject * obj1 = 0 ;
22071 char *kwnames[] = {
22072 (char *) "winid",(char *) "commandType", NULL
22073 };
22074
22075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22076 if (obj0) {
22077 {
22078 arg1 = (int)(SWIG_As_int(obj0));
22079 if (SWIG_arg_fail(1)) SWIG_fail;
22080 }
22081 }
22082 if (obj1) {
22083 {
22084 arg2 = (wxEventType)(SWIG_As_int(obj1));
22085 if (SWIG_arg_fail(2)) SWIG_fail;
22086 }
22087 }
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22091
22092 wxPyEndAllowThreads(__tstate);
22093 if (PyErr_Occurred()) SWIG_fail;
22094 }
22095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22096 return resultobj;
22097 fail:
22098 return NULL;
22099 }
22100
22101
22102 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22103 PyObject *resultobj;
22104 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22105 PyObject * obj0 = 0 ;
22106 char *kwnames[] = {
22107 (char *) "self", NULL
22108 };
22109
22110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22112 if (SWIG_arg_fail(1)) SWIG_fail;
22113 {
22114 PyThreadState* __tstate = wxPyBeginAllowThreads();
22115 delete arg1;
22116
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 Py_INCREF(Py_None); resultobj = Py_None;
22121 return resultobj;
22122 fail:
22123 return NULL;
22124 }
22125
22126
22127 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22128 PyObject *resultobj;
22129 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22130 PyObject *arg2 = (PyObject *) 0 ;
22131 PyObject * obj0 = 0 ;
22132 PyObject * obj1 = 0 ;
22133 char *kwnames[] = {
22134 (char *) "self",(char *) "self", NULL
22135 };
22136
22137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22139 if (SWIG_arg_fail(1)) SWIG_fail;
22140 arg2 = obj1;
22141 {
22142 PyThreadState* __tstate = wxPyBeginAllowThreads();
22143 (arg1)->SetSelf(arg2);
22144
22145 wxPyEndAllowThreads(__tstate);
22146 if (PyErr_Occurred()) SWIG_fail;
22147 }
22148 Py_INCREF(Py_None); resultobj = Py_None;
22149 return resultobj;
22150 fail:
22151 return NULL;
22152 }
22153
22154
22155 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22156 PyObject *resultobj;
22157 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22158 PyObject *result;
22159 PyObject * obj0 = 0 ;
22160 char *kwnames[] = {
22161 (char *) "self", NULL
22162 };
22163
22164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22166 if (SWIG_arg_fail(1)) SWIG_fail;
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 result = (PyObject *)(arg1)->GetSelf();
22170
22171 wxPyEndAllowThreads(__tstate);
22172 if (PyErr_Occurred()) SWIG_fail;
22173 }
22174 resultobj = result;
22175 return resultobj;
22176 fail:
22177 return NULL;
22178 }
22179
22180
22181 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22182 PyObject *obj;
22183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22184 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22185 Py_INCREF(obj);
22186 return Py_BuildValue((char *)"");
22187 }
22188 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22189 PyObject *resultobj;
22190 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22191 int arg2 = (int) 0 ;
22192 wxPyCommandEvent *result;
22193 PyObject * obj0 = 0 ;
22194 PyObject * obj1 = 0 ;
22195 char *kwnames[] = {
22196 (char *) "commandType",(char *) "id", NULL
22197 };
22198
22199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22200 if (obj0) {
22201 {
22202 arg1 = (wxEventType)(SWIG_As_int(obj0));
22203 if (SWIG_arg_fail(1)) SWIG_fail;
22204 }
22205 }
22206 if (obj1) {
22207 {
22208 arg2 = (int)(SWIG_As_int(obj1));
22209 if (SWIG_arg_fail(2)) SWIG_fail;
22210 }
22211 }
22212 {
22213 PyThreadState* __tstate = wxPyBeginAllowThreads();
22214 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22215
22216 wxPyEndAllowThreads(__tstate);
22217 if (PyErr_Occurred()) SWIG_fail;
22218 }
22219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22220 return resultobj;
22221 fail:
22222 return NULL;
22223 }
22224
22225
22226 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22227 PyObject *resultobj;
22228 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22229 PyObject * obj0 = 0 ;
22230 char *kwnames[] = {
22231 (char *) "self", NULL
22232 };
22233
22234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22236 if (SWIG_arg_fail(1)) SWIG_fail;
22237 {
22238 PyThreadState* __tstate = wxPyBeginAllowThreads();
22239 delete arg1;
22240
22241 wxPyEndAllowThreads(__tstate);
22242 if (PyErr_Occurred()) SWIG_fail;
22243 }
22244 Py_INCREF(Py_None); resultobj = Py_None;
22245 return resultobj;
22246 fail:
22247 return NULL;
22248 }
22249
22250
22251 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22252 PyObject *resultobj;
22253 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22254 PyObject *arg2 = (PyObject *) 0 ;
22255 PyObject * obj0 = 0 ;
22256 PyObject * obj1 = 0 ;
22257 char *kwnames[] = {
22258 (char *) "self",(char *) "self", NULL
22259 };
22260
22261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22263 if (SWIG_arg_fail(1)) SWIG_fail;
22264 arg2 = obj1;
22265 {
22266 PyThreadState* __tstate = wxPyBeginAllowThreads();
22267 (arg1)->SetSelf(arg2);
22268
22269 wxPyEndAllowThreads(__tstate);
22270 if (PyErr_Occurred()) SWIG_fail;
22271 }
22272 Py_INCREF(Py_None); resultobj = Py_None;
22273 return resultobj;
22274 fail:
22275 return NULL;
22276 }
22277
22278
22279 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22280 PyObject *resultobj;
22281 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22282 PyObject *result;
22283 PyObject * obj0 = 0 ;
22284 char *kwnames[] = {
22285 (char *) "self", NULL
22286 };
22287
22288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22290 if (SWIG_arg_fail(1)) SWIG_fail;
22291 {
22292 PyThreadState* __tstate = wxPyBeginAllowThreads();
22293 result = (PyObject *)(arg1)->GetSelf();
22294
22295 wxPyEndAllowThreads(__tstate);
22296 if (PyErr_Occurred()) SWIG_fail;
22297 }
22298 resultobj = result;
22299 return resultobj;
22300 fail:
22301 return NULL;
22302 }
22303
22304
22305 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22306 PyObject *obj;
22307 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22308 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22309 Py_INCREF(obj);
22310 return Py_BuildValue((char *)"");
22311 }
22312 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22313 PyObject *resultobj;
22314 wxWindow *arg1 = (wxWindow *) 0 ;
22315 wxDateTime *arg2 = 0 ;
22316 wxEventType arg3 ;
22317 wxDateEvent *result;
22318 PyObject * obj0 = 0 ;
22319 PyObject * obj1 = 0 ;
22320 PyObject * obj2 = 0 ;
22321 char *kwnames[] = {
22322 (char *) "win",(char *) "dt",(char *) "type", NULL
22323 };
22324
22325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22327 if (SWIG_arg_fail(1)) SWIG_fail;
22328 {
22329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22330 if (SWIG_arg_fail(2)) SWIG_fail;
22331 if (arg2 == NULL) {
22332 SWIG_null_ref("wxDateTime");
22333 }
22334 if (SWIG_arg_fail(2)) SWIG_fail;
22335 }
22336 {
22337 arg3 = (wxEventType)(SWIG_As_int(obj2));
22338 if (SWIG_arg_fail(3)) SWIG_fail;
22339 }
22340 {
22341 PyThreadState* __tstate = wxPyBeginAllowThreads();
22342 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22343
22344 wxPyEndAllowThreads(__tstate);
22345 if (PyErr_Occurred()) SWIG_fail;
22346 }
22347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22348 return resultobj;
22349 fail:
22350 return NULL;
22351 }
22352
22353
22354 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22355 PyObject *resultobj;
22356 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22357 wxDateTime *result;
22358 PyObject * obj0 = 0 ;
22359 char *kwnames[] = {
22360 (char *) "self", NULL
22361 };
22362
22363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22365 if (SWIG_arg_fail(1)) SWIG_fail;
22366 {
22367 PyThreadState* __tstate = wxPyBeginAllowThreads();
22368 {
22369 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22370 result = (wxDateTime *) &_result_ref;
22371 }
22372
22373 wxPyEndAllowThreads(__tstate);
22374 if (PyErr_Occurred()) SWIG_fail;
22375 }
22376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22377 return resultobj;
22378 fail:
22379 return NULL;
22380 }
22381
22382
22383 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22384 PyObject *resultobj;
22385 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22386 wxDateTime *arg2 = 0 ;
22387 PyObject * obj0 = 0 ;
22388 PyObject * obj1 = 0 ;
22389 char *kwnames[] = {
22390 (char *) "self",(char *) "date", NULL
22391 };
22392
22393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22395 if (SWIG_arg_fail(1)) SWIG_fail;
22396 {
22397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22398 if (SWIG_arg_fail(2)) SWIG_fail;
22399 if (arg2 == NULL) {
22400 SWIG_null_ref("wxDateTime");
22401 }
22402 if (SWIG_arg_fail(2)) SWIG_fail;
22403 }
22404 {
22405 PyThreadState* __tstate = wxPyBeginAllowThreads();
22406 (arg1)->SetDate((wxDateTime const &)*arg2);
22407
22408 wxPyEndAllowThreads(__tstate);
22409 if (PyErr_Occurred()) SWIG_fail;
22410 }
22411 Py_INCREF(Py_None); resultobj = Py_None;
22412 return resultobj;
22413 fail:
22414 return NULL;
22415 }
22416
22417
22418 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22419 PyObject *obj;
22420 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22421 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22422 Py_INCREF(obj);
22423 return Py_BuildValue((char *)"");
22424 }
22425 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22426 PyObject *resultobj;
22427 wxPyApp *result;
22428 char *kwnames[] = {
22429 NULL
22430 };
22431
22432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22433 {
22434 PyThreadState* __tstate = wxPyBeginAllowThreads();
22435 result = (wxPyApp *)new_wxPyApp();
22436
22437 wxPyEndAllowThreads(__tstate);
22438 if (PyErr_Occurred()) SWIG_fail;
22439 }
22440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22441 return resultobj;
22442 fail:
22443 return NULL;
22444 }
22445
22446
22447 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22448 PyObject *resultobj;
22449 wxPyApp *arg1 = (wxPyApp *) 0 ;
22450 PyObject * obj0 = 0 ;
22451 char *kwnames[] = {
22452 (char *) "self", NULL
22453 };
22454
22455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22457 if (SWIG_arg_fail(1)) SWIG_fail;
22458 {
22459 PyThreadState* __tstate = wxPyBeginAllowThreads();
22460 delete arg1;
22461
22462 wxPyEndAllowThreads(__tstate);
22463 if (PyErr_Occurred()) SWIG_fail;
22464 }
22465 Py_INCREF(Py_None); resultobj = Py_None;
22466 return resultobj;
22467 fail:
22468 return NULL;
22469 }
22470
22471
22472 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22473 PyObject *resultobj;
22474 wxPyApp *arg1 = (wxPyApp *) 0 ;
22475 PyObject *arg2 = (PyObject *) 0 ;
22476 PyObject *arg3 = (PyObject *) 0 ;
22477 PyObject * obj0 = 0 ;
22478 PyObject * obj1 = 0 ;
22479 PyObject * obj2 = 0 ;
22480 char *kwnames[] = {
22481 (char *) "self",(char *) "self",(char *) "_class", NULL
22482 };
22483
22484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22486 if (SWIG_arg_fail(1)) SWIG_fail;
22487 arg2 = obj1;
22488 arg3 = obj2;
22489 {
22490 PyThreadState* __tstate = wxPyBeginAllowThreads();
22491 (arg1)->_setCallbackInfo(arg2,arg3);
22492
22493 wxPyEndAllowThreads(__tstate);
22494 if (PyErr_Occurred()) SWIG_fail;
22495 }
22496 Py_INCREF(Py_None); resultobj = Py_None;
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22504 PyObject *resultobj;
22505 wxPyApp *arg1 = (wxPyApp *) 0 ;
22506 wxString result;
22507 PyObject * obj0 = 0 ;
22508 char *kwnames[] = {
22509 (char *) "self", NULL
22510 };
22511
22512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22514 if (SWIG_arg_fail(1)) SWIG_fail;
22515 {
22516 PyThreadState* __tstate = wxPyBeginAllowThreads();
22517 result = ((wxPyApp const *)arg1)->GetAppName();
22518
22519 wxPyEndAllowThreads(__tstate);
22520 if (PyErr_Occurred()) SWIG_fail;
22521 }
22522 {
22523 #if wxUSE_UNICODE
22524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22525 #else
22526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22527 #endif
22528 }
22529 return resultobj;
22530 fail:
22531 return NULL;
22532 }
22533
22534
22535 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22536 PyObject *resultobj;
22537 wxPyApp *arg1 = (wxPyApp *) 0 ;
22538 wxString *arg2 = 0 ;
22539 bool temp2 = false ;
22540 PyObject * obj0 = 0 ;
22541 PyObject * obj1 = 0 ;
22542 char *kwnames[] = {
22543 (char *) "self",(char *) "name", NULL
22544 };
22545
22546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22548 if (SWIG_arg_fail(1)) SWIG_fail;
22549 {
22550 arg2 = wxString_in_helper(obj1);
22551 if (arg2 == NULL) SWIG_fail;
22552 temp2 = true;
22553 }
22554 {
22555 PyThreadState* __tstate = wxPyBeginAllowThreads();
22556 (arg1)->SetAppName((wxString const &)*arg2);
22557
22558 wxPyEndAllowThreads(__tstate);
22559 if (PyErr_Occurred()) SWIG_fail;
22560 }
22561 Py_INCREF(Py_None); resultobj = Py_None;
22562 {
22563 if (temp2)
22564 delete arg2;
22565 }
22566 return resultobj;
22567 fail:
22568 {
22569 if (temp2)
22570 delete arg2;
22571 }
22572 return NULL;
22573 }
22574
22575
22576 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22577 PyObject *resultobj;
22578 wxPyApp *arg1 = (wxPyApp *) 0 ;
22579 wxString result;
22580 PyObject * obj0 = 0 ;
22581 char *kwnames[] = {
22582 (char *) "self", NULL
22583 };
22584
22585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22587 if (SWIG_arg_fail(1)) SWIG_fail;
22588 {
22589 PyThreadState* __tstate = wxPyBeginAllowThreads();
22590 result = ((wxPyApp const *)arg1)->GetClassName();
22591
22592 wxPyEndAllowThreads(__tstate);
22593 if (PyErr_Occurred()) SWIG_fail;
22594 }
22595 {
22596 #if wxUSE_UNICODE
22597 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22598 #else
22599 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22600 #endif
22601 }
22602 return resultobj;
22603 fail:
22604 return NULL;
22605 }
22606
22607
22608 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22609 PyObject *resultobj;
22610 wxPyApp *arg1 = (wxPyApp *) 0 ;
22611 wxString *arg2 = 0 ;
22612 bool temp2 = false ;
22613 PyObject * obj0 = 0 ;
22614 PyObject * obj1 = 0 ;
22615 char *kwnames[] = {
22616 (char *) "self",(char *) "name", NULL
22617 };
22618
22619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22621 if (SWIG_arg_fail(1)) SWIG_fail;
22622 {
22623 arg2 = wxString_in_helper(obj1);
22624 if (arg2 == NULL) SWIG_fail;
22625 temp2 = true;
22626 }
22627 {
22628 PyThreadState* __tstate = wxPyBeginAllowThreads();
22629 (arg1)->SetClassName((wxString const &)*arg2);
22630
22631 wxPyEndAllowThreads(__tstate);
22632 if (PyErr_Occurred()) SWIG_fail;
22633 }
22634 Py_INCREF(Py_None); resultobj = Py_None;
22635 {
22636 if (temp2)
22637 delete arg2;
22638 }
22639 return resultobj;
22640 fail:
22641 {
22642 if (temp2)
22643 delete arg2;
22644 }
22645 return NULL;
22646 }
22647
22648
22649 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22650 PyObject *resultobj;
22651 wxPyApp *arg1 = (wxPyApp *) 0 ;
22652 wxString *result;
22653 PyObject * obj0 = 0 ;
22654 char *kwnames[] = {
22655 (char *) "self", NULL
22656 };
22657
22658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22660 if (SWIG_arg_fail(1)) SWIG_fail;
22661 {
22662 PyThreadState* __tstate = wxPyBeginAllowThreads();
22663 {
22664 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22665 result = (wxString *) &_result_ref;
22666 }
22667
22668 wxPyEndAllowThreads(__tstate);
22669 if (PyErr_Occurred()) SWIG_fail;
22670 }
22671 {
22672 #if wxUSE_UNICODE
22673 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22674 #else
22675 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22676 #endif
22677 }
22678 return resultobj;
22679 fail:
22680 return NULL;
22681 }
22682
22683
22684 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22685 PyObject *resultobj;
22686 wxPyApp *arg1 = (wxPyApp *) 0 ;
22687 wxString *arg2 = 0 ;
22688 bool temp2 = false ;
22689 PyObject * obj0 = 0 ;
22690 PyObject * obj1 = 0 ;
22691 char *kwnames[] = {
22692 (char *) "self",(char *) "name", NULL
22693 };
22694
22695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22697 if (SWIG_arg_fail(1)) SWIG_fail;
22698 {
22699 arg2 = wxString_in_helper(obj1);
22700 if (arg2 == NULL) SWIG_fail;
22701 temp2 = true;
22702 }
22703 {
22704 PyThreadState* __tstate = wxPyBeginAllowThreads();
22705 (arg1)->SetVendorName((wxString const &)*arg2);
22706
22707 wxPyEndAllowThreads(__tstate);
22708 if (PyErr_Occurred()) SWIG_fail;
22709 }
22710 Py_INCREF(Py_None); resultobj = Py_None;
22711 {
22712 if (temp2)
22713 delete arg2;
22714 }
22715 return resultobj;
22716 fail:
22717 {
22718 if (temp2)
22719 delete arg2;
22720 }
22721 return NULL;
22722 }
22723
22724
22725 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22726 PyObject *resultobj;
22727 wxPyApp *arg1 = (wxPyApp *) 0 ;
22728 wxAppTraits *result;
22729 PyObject * obj0 = 0 ;
22730 char *kwnames[] = {
22731 (char *) "self", NULL
22732 };
22733
22734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22736 if (SWIG_arg_fail(1)) SWIG_fail;
22737 {
22738 PyThreadState* __tstate = wxPyBeginAllowThreads();
22739 result = (wxAppTraits *)(arg1)->GetTraits();
22740
22741 wxPyEndAllowThreads(__tstate);
22742 if (PyErr_Occurred()) SWIG_fail;
22743 }
22744 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22745 return resultobj;
22746 fail:
22747 return NULL;
22748 }
22749
22750
22751 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22752 PyObject *resultobj;
22753 wxPyApp *arg1 = (wxPyApp *) 0 ;
22754 PyObject * obj0 = 0 ;
22755 char *kwnames[] = {
22756 (char *) "self", NULL
22757 };
22758
22759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22761 if (SWIG_arg_fail(1)) SWIG_fail;
22762 {
22763 PyThreadState* __tstate = wxPyBeginAllowThreads();
22764 (arg1)->ProcessPendingEvents();
22765
22766 wxPyEndAllowThreads(__tstate);
22767 if (PyErr_Occurred()) SWIG_fail;
22768 }
22769 Py_INCREF(Py_None); resultobj = Py_None;
22770 return resultobj;
22771 fail:
22772 return NULL;
22773 }
22774
22775
22776 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22777 PyObject *resultobj;
22778 wxPyApp *arg1 = (wxPyApp *) 0 ;
22779 bool arg2 = (bool) false ;
22780 bool result;
22781 PyObject * obj0 = 0 ;
22782 PyObject * obj1 = 0 ;
22783 char *kwnames[] = {
22784 (char *) "self",(char *) "onlyIfNeeded", NULL
22785 };
22786
22787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22789 if (SWIG_arg_fail(1)) SWIG_fail;
22790 if (obj1) {
22791 {
22792 arg2 = (bool)(SWIG_As_bool(obj1));
22793 if (SWIG_arg_fail(2)) SWIG_fail;
22794 }
22795 }
22796 {
22797 PyThreadState* __tstate = wxPyBeginAllowThreads();
22798 result = (bool)(arg1)->Yield(arg2);
22799
22800 wxPyEndAllowThreads(__tstate);
22801 if (PyErr_Occurred()) SWIG_fail;
22802 }
22803 {
22804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22805 }
22806 return resultobj;
22807 fail:
22808 return NULL;
22809 }
22810
22811
22812 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22813 PyObject *resultobj;
22814 wxPyApp *arg1 = (wxPyApp *) 0 ;
22815 PyObject * obj0 = 0 ;
22816 char *kwnames[] = {
22817 (char *) "self", NULL
22818 };
22819
22820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22822 if (SWIG_arg_fail(1)) SWIG_fail;
22823 {
22824 PyThreadState* __tstate = wxPyBeginAllowThreads();
22825 (arg1)->WakeUpIdle();
22826
22827 wxPyEndAllowThreads(__tstate);
22828 if (PyErr_Occurred()) SWIG_fail;
22829 }
22830 Py_INCREF(Py_None); resultobj = Py_None;
22831 return resultobj;
22832 fail:
22833 return NULL;
22834 }
22835
22836
22837 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22838 PyObject *resultobj;
22839 bool result;
22840 char *kwnames[] = {
22841 NULL
22842 };
22843
22844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22845 {
22846 PyThreadState* __tstate = wxPyBeginAllowThreads();
22847 result = (bool)wxPyApp::IsMainLoopRunning();
22848
22849 wxPyEndAllowThreads(__tstate);
22850 if (PyErr_Occurred()) SWIG_fail;
22851 }
22852 {
22853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22854 }
22855 return resultobj;
22856 fail:
22857 return NULL;
22858 }
22859
22860
22861 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22862 PyObject *resultobj;
22863 wxPyApp *arg1 = (wxPyApp *) 0 ;
22864 int result;
22865 PyObject * obj0 = 0 ;
22866 char *kwnames[] = {
22867 (char *) "self", NULL
22868 };
22869
22870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22872 if (SWIG_arg_fail(1)) SWIG_fail;
22873 {
22874 PyThreadState* __tstate = wxPyBeginAllowThreads();
22875 result = (int)(arg1)->MainLoop();
22876
22877 wxPyEndAllowThreads(__tstate);
22878 if (PyErr_Occurred()) SWIG_fail;
22879 }
22880 {
22881 resultobj = SWIG_From_int((int)(result));
22882 }
22883 return resultobj;
22884 fail:
22885 return NULL;
22886 }
22887
22888
22889 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22890 PyObject *resultobj;
22891 wxPyApp *arg1 = (wxPyApp *) 0 ;
22892 PyObject * obj0 = 0 ;
22893 char *kwnames[] = {
22894 (char *) "self", NULL
22895 };
22896
22897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22899 if (SWIG_arg_fail(1)) SWIG_fail;
22900 {
22901 PyThreadState* __tstate = wxPyBeginAllowThreads();
22902 (arg1)->Exit();
22903
22904 wxPyEndAllowThreads(__tstate);
22905 if (PyErr_Occurred()) SWIG_fail;
22906 }
22907 Py_INCREF(Py_None); resultobj = Py_None;
22908 return resultobj;
22909 fail:
22910 return NULL;
22911 }
22912
22913
22914 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22915 PyObject *resultobj;
22916 wxPyApp *arg1 = (wxPyApp *) 0 ;
22917 PyObject * obj0 = 0 ;
22918 char *kwnames[] = {
22919 (char *) "self", NULL
22920 };
22921
22922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22924 if (SWIG_arg_fail(1)) SWIG_fail;
22925 {
22926 PyThreadState* __tstate = wxPyBeginAllowThreads();
22927 (arg1)->ExitMainLoop();
22928
22929 wxPyEndAllowThreads(__tstate);
22930 if (PyErr_Occurred()) SWIG_fail;
22931 }
22932 Py_INCREF(Py_None); resultobj = Py_None;
22933 return resultobj;
22934 fail:
22935 return NULL;
22936 }
22937
22938
22939 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22940 PyObject *resultobj;
22941 wxPyApp *arg1 = (wxPyApp *) 0 ;
22942 bool result;
22943 PyObject * obj0 = 0 ;
22944 char *kwnames[] = {
22945 (char *) "self", NULL
22946 };
22947
22948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22950 if (SWIG_arg_fail(1)) SWIG_fail;
22951 {
22952 PyThreadState* __tstate = wxPyBeginAllowThreads();
22953 result = (bool)(arg1)->Pending();
22954
22955 wxPyEndAllowThreads(__tstate);
22956 if (PyErr_Occurred()) SWIG_fail;
22957 }
22958 {
22959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22960 }
22961 return resultobj;
22962 fail:
22963 return NULL;
22964 }
22965
22966
22967 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22968 PyObject *resultobj;
22969 wxPyApp *arg1 = (wxPyApp *) 0 ;
22970 bool result;
22971 PyObject * obj0 = 0 ;
22972 char *kwnames[] = {
22973 (char *) "self", NULL
22974 };
22975
22976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22978 if (SWIG_arg_fail(1)) SWIG_fail;
22979 {
22980 PyThreadState* __tstate = wxPyBeginAllowThreads();
22981 result = (bool)(arg1)->Dispatch();
22982
22983 wxPyEndAllowThreads(__tstate);
22984 if (PyErr_Occurred()) SWIG_fail;
22985 }
22986 {
22987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22988 }
22989 return resultobj;
22990 fail:
22991 return NULL;
22992 }
22993
22994
22995 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22996 PyObject *resultobj;
22997 wxPyApp *arg1 = (wxPyApp *) 0 ;
22998 bool result;
22999 PyObject * obj0 = 0 ;
23000 char *kwnames[] = {
23001 (char *) "self", NULL
23002 };
23003
23004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23006 if (SWIG_arg_fail(1)) SWIG_fail;
23007 {
23008 PyThreadState* __tstate = wxPyBeginAllowThreads();
23009 result = (bool)(arg1)->ProcessIdle();
23010
23011 wxPyEndAllowThreads(__tstate);
23012 if (PyErr_Occurred()) SWIG_fail;
23013 }
23014 {
23015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23016 }
23017 return resultobj;
23018 fail:
23019 return NULL;
23020 }
23021
23022
23023 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23024 PyObject *resultobj;
23025 wxPyApp *arg1 = (wxPyApp *) 0 ;
23026 wxWindow *arg2 = (wxWindow *) 0 ;
23027 wxIdleEvent *arg3 = 0 ;
23028 bool result;
23029 PyObject * obj0 = 0 ;
23030 PyObject * obj1 = 0 ;
23031 PyObject * obj2 = 0 ;
23032 char *kwnames[] = {
23033 (char *) "self",(char *) "win",(char *) "event", NULL
23034 };
23035
23036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23038 if (SWIG_arg_fail(1)) SWIG_fail;
23039 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23040 if (SWIG_arg_fail(2)) SWIG_fail;
23041 {
23042 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23043 if (SWIG_arg_fail(3)) SWIG_fail;
23044 if (arg3 == NULL) {
23045 SWIG_null_ref("wxIdleEvent");
23046 }
23047 if (SWIG_arg_fail(3)) SWIG_fail;
23048 }
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23052
23053 wxPyEndAllowThreads(__tstate);
23054 if (PyErr_Occurred()) SWIG_fail;
23055 }
23056 {
23057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23058 }
23059 return resultobj;
23060 fail:
23061 return NULL;
23062 }
23063
23064
23065 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23066 PyObject *resultobj;
23067 wxPyApp *arg1 = (wxPyApp *) 0 ;
23068 bool result;
23069 PyObject * obj0 = 0 ;
23070 char *kwnames[] = {
23071 (char *) "self", NULL
23072 };
23073
23074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23076 if (SWIG_arg_fail(1)) SWIG_fail;
23077 {
23078 PyThreadState* __tstate = wxPyBeginAllowThreads();
23079 result = (bool)((wxPyApp const *)arg1)->IsActive();
23080
23081 wxPyEndAllowThreads(__tstate);
23082 if (PyErr_Occurred()) SWIG_fail;
23083 }
23084 {
23085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23086 }
23087 return resultobj;
23088 fail:
23089 return NULL;
23090 }
23091
23092
23093 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23094 PyObject *resultobj;
23095 wxPyApp *arg1 = (wxPyApp *) 0 ;
23096 wxWindow *arg2 = (wxWindow *) 0 ;
23097 PyObject * obj0 = 0 ;
23098 PyObject * obj1 = 0 ;
23099 char *kwnames[] = {
23100 (char *) "self",(char *) "win", NULL
23101 };
23102
23103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23105 if (SWIG_arg_fail(1)) SWIG_fail;
23106 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23107 if (SWIG_arg_fail(2)) SWIG_fail;
23108 {
23109 PyThreadState* __tstate = wxPyBeginAllowThreads();
23110 (arg1)->SetTopWindow(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_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23123 PyObject *resultobj;
23124 wxPyApp *arg1 = (wxPyApp *) 0 ;
23125 wxWindow *result;
23126 PyObject * obj0 = 0 ;
23127 char *kwnames[] = {
23128 (char *) "self", NULL
23129 };
23130
23131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",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 = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23137
23138 wxPyEndAllowThreads(__tstate);
23139 if (PyErr_Occurred()) SWIG_fail;
23140 }
23141 {
23142 resultobj = wxPyMake_wxObject(result, 0);
23143 }
23144 return resultobj;
23145 fail:
23146 return NULL;
23147 }
23148
23149
23150 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23151 PyObject *resultobj;
23152 wxPyApp *arg1 = (wxPyApp *) 0 ;
23153 bool arg2 ;
23154 PyObject * obj0 = 0 ;
23155 PyObject * obj1 = 0 ;
23156 char *kwnames[] = {
23157 (char *) "self",(char *) "flag", NULL
23158 };
23159
23160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23162 if (SWIG_arg_fail(1)) SWIG_fail;
23163 {
23164 arg2 = (bool)(SWIG_As_bool(obj1));
23165 if (SWIG_arg_fail(2)) SWIG_fail;
23166 }
23167 {
23168 PyThreadState* __tstate = wxPyBeginAllowThreads();
23169 (arg1)->SetExitOnFrameDelete(arg2);
23170
23171 wxPyEndAllowThreads(__tstate);
23172 if (PyErr_Occurred()) SWIG_fail;
23173 }
23174 Py_INCREF(Py_None); resultobj = Py_None;
23175 return resultobj;
23176 fail:
23177 return NULL;
23178 }
23179
23180
23181 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23182 PyObject *resultobj;
23183 wxPyApp *arg1 = (wxPyApp *) 0 ;
23184 bool result;
23185 PyObject * obj0 = 0 ;
23186 char *kwnames[] = {
23187 (char *) "self", NULL
23188 };
23189
23190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23192 if (SWIG_arg_fail(1)) SWIG_fail;
23193 {
23194 PyThreadState* __tstate = wxPyBeginAllowThreads();
23195 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23196
23197 wxPyEndAllowThreads(__tstate);
23198 if (PyErr_Occurred()) SWIG_fail;
23199 }
23200 {
23201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23202 }
23203 return resultobj;
23204 fail:
23205 return NULL;
23206 }
23207
23208
23209 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23210 PyObject *resultobj;
23211 wxPyApp *arg1 = (wxPyApp *) 0 ;
23212 bool arg2 ;
23213 PyObject * obj0 = 0 ;
23214 PyObject * obj1 = 0 ;
23215 char *kwnames[] = {
23216 (char *) "self",(char *) "flag", NULL
23217 };
23218
23219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23221 if (SWIG_arg_fail(1)) SWIG_fail;
23222 {
23223 arg2 = (bool)(SWIG_As_bool(obj1));
23224 if (SWIG_arg_fail(2)) SWIG_fail;
23225 }
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 (arg1)->SetUseBestVisual(arg2);
23229
23230 wxPyEndAllowThreads(__tstate);
23231 if (PyErr_Occurred()) SWIG_fail;
23232 }
23233 Py_INCREF(Py_None); resultobj = Py_None;
23234 return resultobj;
23235 fail:
23236 return NULL;
23237 }
23238
23239
23240 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23241 PyObject *resultobj;
23242 wxPyApp *arg1 = (wxPyApp *) 0 ;
23243 bool result;
23244 PyObject * obj0 = 0 ;
23245 char *kwnames[] = {
23246 (char *) "self", NULL
23247 };
23248
23249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23251 if (SWIG_arg_fail(1)) SWIG_fail;
23252 {
23253 PyThreadState* __tstate = wxPyBeginAllowThreads();
23254 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23255
23256 wxPyEndAllowThreads(__tstate);
23257 if (PyErr_Occurred()) SWIG_fail;
23258 }
23259 {
23260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23261 }
23262 return resultobj;
23263 fail:
23264 return NULL;
23265 }
23266
23267
23268 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23269 PyObject *resultobj;
23270 wxPyApp *arg1 = (wxPyApp *) 0 ;
23271 int arg2 ;
23272 PyObject * obj0 = 0 ;
23273 PyObject * obj1 = 0 ;
23274 char *kwnames[] = {
23275 (char *) "self",(char *) "mode", NULL
23276 };
23277
23278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23280 if (SWIG_arg_fail(1)) SWIG_fail;
23281 {
23282 arg2 = (int)(SWIG_As_int(obj1));
23283 if (SWIG_arg_fail(2)) SWIG_fail;
23284 }
23285 {
23286 PyThreadState* __tstate = wxPyBeginAllowThreads();
23287 (arg1)->SetPrintMode(arg2);
23288
23289 wxPyEndAllowThreads(__tstate);
23290 if (PyErr_Occurred()) SWIG_fail;
23291 }
23292 Py_INCREF(Py_None); resultobj = Py_None;
23293 return resultobj;
23294 fail:
23295 return NULL;
23296 }
23297
23298
23299 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23300 PyObject *resultobj;
23301 wxPyApp *arg1 = (wxPyApp *) 0 ;
23302 int result;
23303 PyObject * obj0 = 0 ;
23304 char *kwnames[] = {
23305 (char *) "self", NULL
23306 };
23307
23308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23310 if (SWIG_arg_fail(1)) SWIG_fail;
23311 {
23312 PyThreadState* __tstate = wxPyBeginAllowThreads();
23313 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23314
23315 wxPyEndAllowThreads(__tstate);
23316 if (PyErr_Occurred()) SWIG_fail;
23317 }
23318 {
23319 resultobj = SWIG_From_int((int)(result));
23320 }
23321 return resultobj;
23322 fail:
23323 return NULL;
23324 }
23325
23326
23327 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23328 PyObject *resultobj;
23329 wxPyApp *arg1 = (wxPyApp *) 0 ;
23330 int arg2 ;
23331 PyObject * obj0 = 0 ;
23332 PyObject * obj1 = 0 ;
23333 char *kwnames[] = {
23334 (char *) "self",(char *) "mode", NULL
23335 };
23336
23337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23339 if (SWIG_arg_fail(1)) SWIG_fail;
23340 {
23341 arg2 = (int)(SWIG_As_int(obj1));
23342 if (SWIG_arg_fail(2)) SWIG_fail;
23343 }
23344 {
23345 PyThreadState* __tstate = wxPyBeginAllowThreads();
23346 (arg1)->SetAssertMode(arg2);
23347
23348 wxPyEndAllowThreads(__tstate);
23349 if (PyErr_Occurred()) SWIG_fail;
23350 }
23351 Py_INCREF(Py_None); resultobj = Py_None;
23352 return resultobj;
23353 fail:
23354 return NULL;
23355 }
23356
23357
23358 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23359 PyObject *resultobj;
23360 wxPyApp *arg1 = (wxPyApp *) 0 ;
23361 int result;
23362 PyObject * obj0 = 0 ;
23363 char *kwnames[] = {
23364 (char *) "self", NULL
23365 };
23366
23367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23369 if (SWIG_arg_fail(1)) SWIG_fail;
23370 {
23371 PyThreadState* __tstate = wxPyBeginAllowThreads();
23372 result = (int)(arg1)->GetAssertMode();
23373
23374 wxPyEndAllowThreads(__tstate);
23375 if (PyErr_Occurred()) SWIG_fail;
23376 }
23377 {
23378 resultobj = SWIG_From_int((int)(result));
23379 }
23380 return resultobj;
23381 fail:
23382 return NULL;
23383 }
23384
23385
23386 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23387 PyObject *resultobj;
23388 bool result;
23389 char *kwnames[] = {
23390 NULL
23391 };
23392
23393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23394 {
23395 PyThreadState* __tstate = wxPyBeginAllowThreads();
23396 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23397
23398 wxPyEndAllowThreads(__tstate);
23399 if (PyErr_Occurred()) SWIG_fail;
23400 }
23401 {
23402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23403 }
23404 return resultobj;
23405 fail:
23406 return NULL;
23407 }
23408
23409
23410 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23411 PyObject *resultobj;
23412 long result;
23413 char *kwnames[] = {
23414 NULL
23415 };
23416
23417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23418 {
23419 PyThreadState* __tstate = wxPyBeginAllowThreads();
23420 result = (long)wxPyApp::GetMacAboutMenuItemId();
23421
23422 wxPyEndAllowThreads(__tstate);
23423 if (PyErr_Occurred()) SWIG_fail;
23424 }
23425 {
23426 resultobj = SWIG_From_long((long)(result));
23427 }
23428 return resultobj;
23429 fail:
23430 return NULL;
23431 }
23432
23433
23434 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23435 PyObject *resultobj;
23436 long result;
23437 char *kwnames[] = {
23438 NULL
23439 };
23440
23441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23442 {
23443 PyThreadState* __tstate = wxPyBeginAllowThreads();
23444 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23445
23446 wxPyEndAllowThreads(__tstate);
23447 if (PyErr_Occurred()) SWIG_fail;
23448 }
23449 {
23450 resultobj = SWIG_From_long((long)(result));
23451 }
23452 return resultobj;
23453 fail:
23454 return NULL;
23455 }
23456
23457
23458 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23459 PyObject *resultobj;
23460 long result;
23461 char *kwnames[] = {
23462 NULL
23463 };
23464
23465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23466 {
23467 PyThreadState* __tstate = wxPyBeginAllowThreads();
23468 result = (long)wxPyApp::GetMacExitMenuItemId();
23469
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 {
23474 resultobj = SWIG_From_long((long)(result));
23475 }
23476 return resultobj;
23477 fail:
23478 return NULL;
23479 }
23480
23481
23482 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23483 PyObject *resultobj;
23484 wxString result;
23485 char *kwnames[] = {
23486 NULL
23487 };
23488
23489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23490 {
23491 PyThreadState* __tstate = wxPyBeginAllowThreads();
23492 result = wxPyApp::GetMacHelpMenuTitleName();
23493
23494 wxPyEndAllowThreads(__tstate);
23495 if (PyErr_Occurred()) SWIG_fail;
23496 }
23497 {
23498 #if wxUSE_UNICODE
23499 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23500 #else
23501 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23502 #endif
23503 }
23504 return resultobj;
23505 fail:
23506 return NULL;
23507 }
23508
23509
23510 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23511 PyObject *resultobj;
23512 bool arg1 ;
23513 PyObject * obj0 = 0 ;
23514 char *kwnames[] = {
23515 (char *) "val", NULL
23516 };
23517
23518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23519 {
23520 arg1 = (bool)(SWIG_As_bool(obj0));
23521 if (SWIG_arg_fail(1)) SWIG_fail;
23522 }
23523 {
23524 PyThreadState* __tstate = wxPyBeginAllowThreads();
23525 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23526
23527 wxPyEndAllowThreads(__tstate);
23528 if (PyErr_Occurred()) SWIG_fail;
23529 }
23530 Py_INCREF(Py_None); resultobj = Py_None;
23531 return resultobj;
23532 fail:
23533 return NULL;
23534 }
23535
23536
23537 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23538 PyObject *resultobj;
23539 long arg1 ;
23540 PyObject * obj0 = 0 ;
23541 char *kwnames[] = {
23542 (char *) "val", NULL
23543 };
23544
23545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23546 {
23547 arg1 = (long)(SWIG_As_long(obj0));
23548 if (SWIG_arg_fail(1)) SWIG_fail;
23549 }
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 wxPyApp::SetMacAboutMenuItemId(arg1);
23553
23554 wxPyEndAllowThreads(__tstate);
23555 if (PyErr_Occurred()) SWIG_fail;
23556 }
23557 Py_INCREF(Py_None); resultobj = Py_None;
23558 return resultobj;
23559 fail:
23560 return NULL;
23561 }
23562
23563
23564 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23565 PyObject *resultobj;
23566 long arg1 ;
23567 PyObject * obj0 = 0 ;
23568 char *kwnames[] = {
23569 (char *) "val", NULL
23570 };
23571
23572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23573 {
23574 arg1 = (long)(SWIG_As_long(obj0));
23575 if (SWIG_arg_fail(1)) SWIG_fail;
23576 }
23577 {
23578 PyThreadState* __tstate = wxPyBeginAllowThreads();
23579 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23580
23581 wxPyEndAllowThreads(__tstate);
23582 if (PyErr_Occurred()) SWIG_fail;
23583 }
23584 Py_INCREF(Py_None); resultobj = Py_None;
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23592 PyObject *resultobj;
23593 long arg1 ;
23594 PyObject * obj0 = 0 ;
23595 char *kwnames[] = {
23596 (char *) "val", NULL
23597 };
23598
23599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23600 {
23601 arg1 = (long)(SWIG_As_long(obj0));
23602 if (SWIG_arg_fail(1)) SWIG_fail;
23603 }
23604 {
23605 PyThreadState* __tstate = wxPyBeginAllowThreads();
23606 wxPyApp::SetMacExitMenuItemId(arg1);
23607
23608 wxPyEndAllowThreads(__tstate);
23609 if (PyErr_Occurred()) SWIG_fail;
23610 }
23611 Py_INCREF(Py_None); resultobj = Py_None;
23612 return resultobj;
23613 fail:
23614 return NULL;
23615 }
23616
23617
23618 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23619 PyObject *resultobj;
23620 wxString *arg1 = 0 ;
23621 bool temp1 = false ;
23622 PyObject * obj0 = 0 ;
23623 char *kwnames[] = {
23624 (char *) "val", NULL
23625 };
23626
23627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23628 {
23629 arg1 = wxString_in_helper(obj0);
23630 if (arg1 == NULL) SWIG_fail;
23631 temp1 = true;
23632 }
23633 {
23634 PyThreadState* __tstate = wxPyBeginAllowThreads();
23635 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23636
23637 wxPyEndAllowThreads(__tstate);
23638 if (PyErr_Occurred()) SWIG_fail;
23639 }
23640 Py_INCREF(Py_None); resultobj = Py_None;
23641 {
23642 if (temp1)
23643 delete arg1;
23644 }
23645 return resultobj;
23646 fail:
23647 {
23648 if (temp1)
23649 delete arg1;
23650 }
23651 return NULL;
23652 }
23653
23654
23655 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23656 PyObject *resultobj;
23657 wxPyApp *arg1 = (wxPyApp *) 0 ;
23658 PyObject * obj0 = 0 ;
23659 char *kwnames[] = {
23660 (char *) "self", NULL
23661 };
23662
23663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23665 if (SWIG_arg_fail(1)) SWIG_fail;
23666 {
23667 PyThreadState* __tstate = wxPyBeginAllowThreads();
23668 (arg1)->_BootstrapApp();
23669
23670 wxPyEndAllowThreads(__tstate);
23671 if (PyErr_Occurred()) SWIG_fail;
23672 }
23673 Py_INCREF(Py_None); resultobj = Py_None;
23674 return resultobj;
23675 fail:
23676 return NULL;
23677 }
23678
23679
23680 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23681 PyObject *resultobj;
23682 int result;
23683 char *kwnames[] = {
23684 NULL
23685 };
23686
23687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23688 {
23689 PyThreadState* __tstate = wxPyBeginAllowThreads();
23690 result = (int)PyApp_GetComCtl32Version();
23691
23692 wxPyEndAllowThreads(__tstate);
23693 if (PyErr_Occurred()) SWIG_fail;
23694 }
23695 {
23696 resultobj = SWIG_From_int((int)(result));
23697 }
23698 return resultobj;
23699 fail:
23700 return NULL;
23701 }
23702
23703
23704 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23705 PyObject *obj;
23706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23707 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23708 Py_INCREF(obj);
23709 return Py_BuildValue((char *)"");
23710 }
23711 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23712 PyObject *resultobj;
23713 char *kwnames[] = {
23714 NULL
23715 };
23716
23717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23718 {
23719 PyThreadState* __tstate = wxPyBeginAllowThreads();
23720 wxExit();
23721
23722 wxPyEndAllowThreads(__tstate);
23723 if (PyErr_Occurred()) SWIG_fail;
23724 }
23725 Py_INCREF(Py_None); resultobj = Py_None;
23726 return resultobj;
23727 fail:
23728 return NULL;
23729 }
23730
23731
23732 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23733 PyObject *resultobj;
23734 bool result;
23735 char *kwnames[] = {
23736 NULL
23737 };
23738
23739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23740 {
23741 PyThreadState* __tstate = wxPyBeginAllowThreads();
23742 result = (bool)wxYield();
23743
23744 wxPyEndAllowThreads(__tstate);
23745 if (PyErr_Occurred()) SWIG_fail;
23746 }
23747 {
23748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23749 }
23750 return resultobj;
23751 fail:
23752 return NULL;
23753 }
23754
23755
23756 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23757 PyObject *resultobj;
23758 bool result;
23759 char *kwnames[] = {
23760 NULL
23761 };
23762
23763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23764 {
23765 PyThreadState* __tstate = wxPyBeginAllowThreads();
23766 result = (bool)wxYieldIfNeeded();
23767
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 {
23772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23773 }
23774 return resultobj;
23775 fail:
23776 return NULL;
23777 }
23778
23779
23780 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23781 PyObject *resultobj;
23782 wxWindow *arg1 = (wxWindow *) NULL ;
23783 bool arg2 = (bool) false ;
23784 bool result;
23785 PyObject * obj0 = 0 ;
23786 PyObject * obj1 = 0 ;
23787 char *kwnames[] = {
23788 (char *) "win",(char *) "onlyIfNeeded", NULL
23789 };
23790
23791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23792 if (obj0) {
23793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23794 if (SWIG_arg_fail(1)) SWIG_fail;
23795 }
23796 if (obj1) {
23797 {
23798 arg2 = (bool)(SWIG_As_bool(obj1));
23799 if (SWIG_arg_fail(2)) SWIG_fail;
23800 }
23801 }
23802 {
23803 PyThreadState* __tstate = wxPyBeginAllowThreads();
23804 result = (bool)wxSafeYield(arg1,arg2);
23805
23806 wxPyEndAllowThreads(__tstate);
23807 if (PyErr_Occurred()) SWIG_fail;
23808 }
23809 {
23810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23811 }
23812 return resultobj;
23813 fail:
23814 return NULL;
23815 }
23816
23817
23818 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23819 PyObject *resultobj;
23820 char *kwnames[] = {
23821 NULL
23822 };
23823
23824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23825 {
23826 PyThreadState* __tstate = wxPyBeginAllowThreads();
23827 wxWakeUpIdle();
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_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23840 PyObject *resultobj;
23841 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23842 wxEvent *arg2 = 0 ;
23843 PyObject * obj0 = 0 ;
23844 PyObject * obj1 = 0 ;
23845 char *kwnames[] = {
23846 (char *) "dest",(char *) "event", NULL
23847 };
23848
23849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23851 if (SWIG_arg_fail(1)) SWIG_fail;
23852 {
23853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23854 if (SWIG_arg_fail(2)) SWIG_fail;
23855 if (arg2 == NULL) {
23856 SWIG_null_ref("wxEvent");
23857 }
23858 if (SWIG_arg_fail(2)) SWIG_fail;
23859 }
23860 {
23861 PyThreadState* __tstate = wxPyBeginAllowThreads();
23862 wxPostEvent(arg1,*arg2);
23863
23864 wxPyEndAllowThreads(__tstate);
23865 if (PyErr_Occurred()) SWIG_fail;
23866 }
23867 Py_INCREF(Py_None); resultobj = Py_None;
23868 return resultobj;
23869 fail:
23870 return NULL;
23871 }
23872
23873
23874 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23875 PyObject *resultobj;
23876 char *kwnames[] = {
23877 NULL
23878 };
23879
23880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23881 {
23882 PyThreadState* __tstate = wxPyBeginAllowThreads();
23883 wxApp_CleanUp();
23884
23885 wxPyEndAllowThreads(__tstate);
23886 if (PyErr_Occurred()) SWIG_fail;
23887 }
23888 Py_INCREF(Py_None); resultobj = Py_None;
23889 return resultobj;
23890 fail:
23891 return NULL;
23892 }
23893
23894
23895 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23896 PyObject *resultobj;
23897 wxPyApp *result;
23898 char *kwnames[] = {
23899 NULL
23900 };
23901
23902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23903 {
23904 PyThreadState* __tstate = wxPyBeginAllowThreads();
23905 result = (wxPyApp *)wxPyGetApp();
23906
23907 wxPyEndAllowThreads(__tstate);
23908 if (PyErr_Occurred()) SWIG_fail;
23909 }
23910 {
23911 resultobj = wxPyMake_wxObject(result, 0);
23912 }
23913 return resultobj;
23914 fail:
23915 return NULL;
23916 }
23917
23918
23919 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23920 PyObject *resultobj;
23921 char *arg1 = (char *) 0 ;
23922 PyObject * obj0 = 0 ;
23923 char *kwnames[] = {
23924 (char *) "encoding", NULL
23925 };
23926
23927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23928 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23929 SWIG_arg_fail(1);SWIG_fail;
23930 }
23931 {
23932 PyThreadState* __tstate = wxPyBeginAllowThreads();
23933 wxSetDefaultPyEncoding((char const *)arg1);
23934
23935 wxPyEndAllowThreads(__tstate);
23936 if (PyErr_Occurred()) SWIG_fail;
23937 }
23938 Py_INCREF(Py_None); resultobj = Py_None;
23939 return resultobj;
23940 fail:
23941 return NULL;
23942 }
23943
23944
23945 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23946 PyObject *resultobj;
23947 char *result;
23948 char *kwnames[] = {
23949 NULL
23950 };
23951
23952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23953 {
23954 PyThreadState* __tstate = wxPyBeginAllowThreads();
23955 result = (char *)wxGetDefaultPyEncoding();
23956
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 resultobj = SWIG_FromCharPtr(result);
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj;
23969 wxEventLoop *result;
23970 char *kwnames[] = {
23971 NULL
23972 };
23973
23974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23975 {
23976 PyThreadState* __tstate = wxPyBeginAllowThreads();
23977 result = (wxEventLoop *)new wxEventLoop();
23978
23979 wxPyEndAllowThreads(__tstate);
23980 if (PyErr_Occurred()) SWIG_fail;
23981 }
23982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23983 return resultobj;
23984 fail:
23985 return NULL;
23986 }
23987
23988
23989 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23990 PyObject *resultobj;
23991 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23992 PyObject * obj0 = 0 ;
23993 char *kwnames[] = {
23994 (char *) "self", NULL
23995 };
23996
23997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23999 if (SWIG_arg_fail(1)) SWIG_fail;
24000 {
24001 PyThreadState* __tstate = wxPyBeginAllowThreads();
24002 delete arg1;
24003
24004 wxPyEndAllowThreads(__tstate);
24005 if (PyErr_Occurred()) SWIG_fail;
24006 }
24007 Py_INCREF(Py_None); resultobj = Py_None;
24008 return resultobj;
24009 fail:
24010 return NULL;
24011 }
24012
24013
24014 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24015 PyObject *resultobj;
24016 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24017 int result;
24018 PyObject * obj0 = 0 ;
24019 char *kwnames[] = {
24020 (char *) "self", NULL
24021 };
24022
24023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24025 if (SWIG_arg_fail(1)) SWIG_fail;
24026 {
24027 PyThreadState* __tstate = wxPyBeginAllowThreads();
24028 result = (int)(arg1)->Run();
24029
24030 wxPyEndAllowThreads(__tstate);
24031 if (PyErr_Occurred()) SWIG_fail;
24032 }
24033 {
24034 resultobj = SWIG_From_int((int)(result));
24035 }
24036 return resultobj;
24037 fail:
24038 return NULL;
24039 }
24040
24041
24042 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24043 PyObject *resultobj;
24044 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24045 int arg2 = (int) 0 ;
24046 PyObject * obj0 = 0 ;
24047 PyObject * obj1 = 0 ;
24048 char *kwnames[] = {
24049 (char *) "self",(char *) "rc", NULL
24050 };
24051
24052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24054 if (SWIG_arg_fail(1)) SWIG_fail;
24055 if (obj1) {
24056 {
24057 arg2 = (int)(SWIG_As_int(obj1));
24058 if (SWIG_arg_fail(2)) SWIG_fail;
24059 }
24060 }
24061 {
24062 PyThreadState* __tstate = wxPyBeginAllowThreads();
24063 (arg1)->Exit(arg2);
24064
24065 wxPyEndAllowThreads(__tstate);
24066 if (PyErr_Occurred()) SWIG_fail;
24067 }
24068 Py_INCREF(Py_None); resultobj = Py_None;
24069 return resultobj;
24070 fail:
24071 return NULL;
24072 }
24073
24074
24075 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24076 PyObject *resultobj;
24077 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24078 bool result;
24079 PyObject * obj0 = 0 ;
24080 char *kwnames[] = {
24081 (char *) "self", NULL
24082 };
24083
24084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24086 if (SWIG_arg_fail(1)) SWIG_fail;
24087 {
24088 PyThreadState* __tstate = wxPyBeginAllowThreads();
24089 result = (bool)((wxEventLoop const *)arg1)->Pending();
24090
24091 wxPyEndAllowThreads(__tstate);
24092 if (PyErr_Occurred()) SWIG_fail;
24093 }
24094 {
24095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24096 }
24097 return resultobj;
24098 fail:
24099 return NULL;
24100 }
24101
24102
24103 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24104 PyObject *resultobj;
24105 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24106 bool result;
24107 PyObject * obj0 = 0 ;
24108 char *kwnames[] = {
24109 (char *) "self", NULL
24110 };
24111
24112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24114 if (SWIG_arg_fail(1)) SWIG_fail;
24115 {
24116 PyThreadState* __tstate = wxPyBeginAllowThreads();
24117 result = (bool)(arg1)->Dispatch();
24118
24119 wxPyEndAllowThreads(__tstate);
24120 if (PyErr_Occurred()) SWIG_fail;
24121 }
24122 {
24123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24124 }
24125 return resultobj;
24126 fail:
24127 return NULL;
24128 }
24129
24130
24131 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24132 PyObject *resultobj;
24133 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24134 bool result;
24135 PyObject * obj0 = 0 ;
24136 char *kwnames[] = {
24137 (char *) "self", NULL
24138 };
24139
24140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24142 if (SWIG_arg_fail(1)) SWIG_fail;
24143 {
24144 PyThreadState* __tstate = wxPyBeginAllowThreads();
24145 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24146
24147 wxPyEndAllowThreads(__tstate);
24148 if (PyErr_Occurred()) SWIG_fail;
24149 }
24150 {
24151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24152 }
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24160 PyObject *resultobj;
24161 wxEventLoop *result;
24162 char *kwnames[] = {
24163 NULL
24164 };
24165
24166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24167 {
24168 PyThreadState* __tstate = wxPyBeginAllowThreads();
24169 result = (wxEventLoop *)wxEventLoop::GetActive();
24170
24171 wxPyEndAllowThreads(__tstate);
24172 if (PyErr_Occurred()) SWIG_fail;
24173 }
24174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24175 return resultobj;
24176 fail:
24177 return NULL;
24178 }
24179
24180
24181 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24182 PyObject *resultobj;
24183 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24184 PyObject * obj0 = 0 ;
24185 char *kwnames[] = {
24186 (char *) "loop", NULL
24187 };
24188
24189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24191 if (SWIG_arg_fail(1)) SWIG_fail;
24192 {
24193 PyThreadState* __tstate = wxPyBeginAllowThreads();
24194 wxEventLoop::SetActive(arg1);
24195
24196 wxPyEndAllowThreads(__tstate);
24197 if (PyErr_Occurred()) SWIG_fail;
24198 }
24199 Py_INCREF(Py_None); resultobj = Py_None;
24200 return resultobj;
24201 fail:
24202 return NULL;
24203 }
24204
24205
24206 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24207 PyObject *obj;
24208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24209 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24210 Py_INCREF(obj);
24211 return Py_BuildValue((char *)"");
24212 }
24213 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24214 PyObject *resultobj;
24215 int arg1 = (int) 0 ;
24216 int arg2 = (int) 0 ;
24217 int arg3 = (int) 0 ;
24218 wxAcceleratorEntry *result;
24219 PyObject * obj0 = 0 ;
24220 PyObject * obj1 = 0 ;
24221 PyObject * obj2 = 0 ;
24222 char *kwnames[] = {
24223 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24224 };
24225
24226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24227 if (obj0) {
24228 {
24229 arg1 = (int)(SWIG_As_int(obj0));
24230 if (SWIG_arg_fail(1)) SWIG_fail;
24231 }
24232 }
24233 if (obj1) {
24234 {
24235 arg2 = (int)(SWIG_As_int(obj1));
24236 if (SWIG_arg_fail(2)) SWIG_fail;
24237 }
24238 }
24239 if (obj2) {
24240 {
24241 arg3 = (int)(SWIG_As_int(obj2));
24242 if (SWIG_arg_fail(3)) SWIG_fail;
24243 }
24244 }
24245 {
24246 PyThreadState* __tstate = wxPyBeginAllowThreads();
24247 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24248
24249 wxPyEndAllowThreads(__tstate);
24250 if (PyErr_Occurred()) SWIG_fail;
24251 }
24252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24253 return resultobj;
24254 fail:
24255 return NULL;
24256 }
24257
24258
24259 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24260 PyObject *resultobj;
24261 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24262 PyObject * obj0 = 0 ;
24263 char *kwnames[] = {
24264 (char *) "self", NULL
24265 };
24266
24267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24269 if (SWIG_arg_fail(1)) SWIG_fail;
24270 {
24271 PyThreadState* __tstate = wxPyBeginAllowThreads();
24272 delete arg1;
24273
24274 wxPyEndAllowThreads(__tstate);
24275 if (PyErr_Occurred()) SWIG_fail;
24276 }
24277 Py_INCREF(Py_None); resultobj = Py_None;
24278 return resultobj;
24279 fail:
24280 return NULL;
24281 }
24282
24283
24284 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24285 PyObject *resultobj;
24286 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24287 int arg2 ;
24288 int arg3 ;
24289 int arg4 ;
24290 PyObject * obj0 = 0 ;
24291 PyObject * obj1 = 0 ;
24292 PyObject * obj2 = 0 ;
24293 PyObject * obj3 = 0 ;
24294 char *kwnames[] = {
24295 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24296 };
24297
24298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24300 if (SWIG_arg_fail(1)) SWIG_fail;
24301 {
24302 arg2 = (int)(SWIG_As_int(obj1));
24303 if (SWIG_arg_fail(2)) SWIG_fail;
24304 }
24305 {
24306 arg3 = (int)(SWIG_As_int(obj2));
24307 if (SWIG_arg_fail(3)) SWIG_fail;
24308 }
24309 {
24310 arg4 = (int)(SWIG_As_int(obj3));
24311 if (SWIG_arg_fail(4)) SWIG_fail;
24312 }
24313 {
24314 PyThreadState* __tstate = wxPyBeginAllowThreads();
24315 (arg1)->Set(arg2,arg3,arg4);
24316
24317 wxPyEndAllowThreads(__tstate);
24318 if (PyErr_Occurred()) SWIG_fail;
24319 }
24320 Py_INCREF(Py_None); resultobj = Py_None;
24321 return resultobj;
24322 fail:
24323 return NULL;
24324 }
24325
24326
24327 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24328 PyObject *resultobj;
24329 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24330 int result;
24331 PyObject * obj0 = 0 ;
24332 char *kwnames[] = {
24333 (char *) "self", NULL
24334 };
24335
24336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24338 if (SWIG_arg_fail(1)) SWIG_fail;
24339 {
24340 PyThreadState* __tstate = wxPyBeginAllowThreads();
24341 result = (int)(arg1)->GetFlags();
24342
24343 wxPyEndAllowThreads(__tstate);
24344 if (PyErr_Occurred()) SWIG_fail;
24345 }
24346 {
24347 resultobj = SWIG_From_int((int)(result));
24348 }
24349 return resultobj;
24350 fail:
24351 return NULL;
24352 }
24353
24354
24355 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24356 PyObject *resultobj;
24357 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24358 int result;
24359 PyObject * obj0 = 0 ;
24360 char *kwnames[] = {
24361 (char *) "self", NULL
24362 };
24363
24364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24366 if (SWIG_arg_fail(1)) SWIG_fail;
24367 {
24368 PyThreadState* __tstate = wxPyBeginAllowThreads();
24369 result = (int)(arg1)->GetKeyCode();
24370
24371 wxPyEndAllowThreads(__tstate);
24372 if (PyErr_Occurred()) SWIG_fail;
24373 }
24374 {
24375 resultobj = SWIG_From_int((int)(result));
24376 }
24377 return resultobj;
24378 fail:
24379 return NULL;
24380 }
24381
24382
24383 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24384 PyObject *resultobj;
24385 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24386 int result;
24387 PyObject * obj0 = 0 ;
24388 char *kwnames[] = {
24389 (char *) "self", NULL
24390 };
24391
24392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24394 if (SWIG_arg_fail(1)) SWIG_fail;
24395 {
24396 PyThreadState* __tstate = wxPyBeginAllowThreads();
24397 result = (int)(arg1)->GetCommand();
24398
24399 wxPyEndAllowThreads(__tstate);
24400 if (PyErr_Occurred()) SWIG_fail;
24401 }
24402 {
24403 resultobj = SWIG_From_int((int)(result));
24404 }
24405 return resultobj;
24406 fail:
24407 return NULL;
24408 }
24409
24410
24411 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24412 PyObject *obj;
24413 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24414 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24415 Py_INCREF(obj);
24416 return Py_BuildValue((char *)"");
24417 }
24418 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24419 PyObject *resultobj;
24420 int arg1 ;
24421 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24422 wxAcceleratorTable *result;
24423 PyObject * obj0 = 0 ;
24424 char *kwnames[] = {
24425 (char *) "n", NULL
24426 };
24427
24428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24429 {
24430 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24431 if (arg2) arg1 = PyList_Size(obj0);
24432 else arg1 = 0;
24433 }
24434 {
24435 PyThreadState* __tstate = wxPyBeginAllowThreads();
24436 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24437
24438 wxPyEndAllowThreads(__tstate);
24439 if (PyErr_Occurred()) SWIG_fail;
24440 }
24441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24442 {
24443 delete [] arg2;
24444 }
24445 return resultobj;
24446 fail:
24447 {
24448 delete [] arg2;
24449 }
24450 return NULL;
24451 }
24452
24453
24454 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24455 PyObject *resultobj;
24456 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24457 PyObject * obj0 = 0 ;
24458 char *kwnames[] = {
24459 (char *) "self", NULL
24460 };
24461
24462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24464 if (SWIG_arg_fail(1)) SWIG_fail;
24465 {
24466 PyThreadState* __tstate = wxPyBeginAllowThreads();
24467 delete arg1;
24468
24469 wxPyEndAllowThreads(__tstate);
24470 if (PyErr_Occurred()) SWIG_fail;
24471 }
24472 Py_INCREF(Py_None); resultobj = Py_None;
24473 return resultobj;
24474 fail:
24475 return NULL;
24476 }
24477
24478
24479 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24480 PyObject *resultobj;
24481 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24482 bool result;
24483 PyObject * obj0 = 0 ;
24484 char *kwnames[] = {
24485 (char *) "self", NULL
24486 };
24487
24488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24490 if (SWIG_arg_fail(1)) SWIG_fail;
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24494
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 {
24499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24500 }
24501 return resultobj;
24502 fail:
24503 return NULL;
24504 }
24505
24506
24507 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24508 PyObject *obj;
24509 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24510 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24511 Py_INCREF(obj);
24512 return Py_BuildValue((char *)"");
24513 }
24514 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24515 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24516 return 1;
24517 }
24518
24519
24520 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24521 PyObject *pyobj;
24522
24523 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24524 return pyobj;
24525 }
24526
24527
24528 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24529 PyObject *resultobj;
24530 wxString *arg1 = 0 ;
24531 wxAcceleratorEntry *result;
24532 bool temp1 = false ;
24533 PyObject * obj0 = 0 ;
24534 char *kwnames[] = {
24535 (char *) "label", NULL
24536 };
24537
24538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24539 {
24540 arg1 = wxString_in_helper(obj0);
24541 if (arg1 == NULL) SWIG_fail;
24542 temp1 = true;
24543 }
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24547
24548 wxPyEndAllowThreads(__tstate);
24549 if (PyErr_Occurred()) SWIG_fail;
24550 }
24551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24552 {
24553 if (temp1)
24554 delete arg1;
24555 }
24556 return resultobj;
24557 fail:
24558 {
24559 if (temp1)
24560 delete arg1;
24561 }
24562 return NULL;
24563 }
24564
24565
24566 static int _wrap_PanelNameStr_set(PyObject *) {
24567 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24568 return 1;
24569 }
24570
24571
24572 static PyObject *_wrap_PanelNameStr_get(void) {
24573 PyObject *pyobj;
24574
24575 {
24576 #if wxUSE_UNICODE
24577 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24578 #else
24579 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24580 #endif
24581 }
24582 return pyobj;
24583 }
24584
24585
24586 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24587 PyObject *resultobj;
24588 wxVisualAttributes *result;
24589 char *kwnames[] = {
24590 NULL
24591 };
24592
24593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24594 {
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 result = (wxVisualAttributes *)new_wxVisualAttributes();
24597
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24602 return resultobj;
24603 fail:
24604 return NULL;
24605 }
24606
24607
24608 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24609 PyObject *resultobj;
24610 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24611 PyObject * obj0 = 0 ;
24612 char *kwnames[] = {
24613 (char *) "self", NULL
24614 };
24615
24616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24618 if (SWIG_arg_fail(1)) SWIG_fail;
24619 {
24620 PyThreadState* __tstate = wxPyBeginAllowThreads();
24621 delete_wxVisualAttributes(arg1);
24622
24623 wxPyEndAllowThreads(__tstate);
24624 if (PyErr_Occurred()) SWIG_fail;
24625 }
24626 Py_INCREF(Py_None); resultobj = Py_None;
24627 return resultobj;
24628 fail:
24629 return NULL;
24630 }
24631
24632
24633 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24634 PyObject *resultobj;
24635 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24636 wxFont *arg2 = (wxFont *) 0 ;
24637 PyObject * obj0 = 0 ;
24638 PyObject * obj1 = 0 ;
24639 char *kwnames[] = {
24640 (char *) "self",(char *) "font", NULL
24641 };
24642
24643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24645 if (SWIG_arg_fail(1)) SWIG_fail;
24646 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24647 if (SWIG_arg_fail(2)) SWIG_fail;
24648 if (arg1) (arg1)->font = *arg2;
24649
24650 Py_INCREF(Py_None); resultobj = Py_None;
24651 return resultobj;
24652 fail:
24653 return NULL;
24654 }
24655
24656
24657 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24658 PyObject *resultobj;
24659 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24660 wxFont *result;
24661 PyObject * obj0 = 0 ;
24662 char *kwnames[] = {
24663 (char *) "self", NULL
24664 };
24665
24666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24668 if (SWIG_arg_fail(1)) SWIG_fail;
24669 result = (wxFont *)& ((arg1)->font);
24670
24671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24672 return resultobj;
24673 fail:
24674 return NULL;
24675 }
24676
24677
24678 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24679 PyObject *resultobj;
24680 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24681 wxColour *arg2 = (wxColour *) 0 ;
24682 PyObject * obj0 = 0 ;
24683 PyObject * obj1 = 0 ;
24684 char *kwnames[] = {
24685 (char *) "self",(char *) "colFg", NULL
24686 };
24687
24688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24690 if (SWIG_arg_fail(1)) SWIG_fail;
24691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24692 if (SWIG_arg_fail(2)) SWIG_fail;
24693 if (arg1) (arg1)->colFg = *arg2;
24694
24695 Py_INCREF(Py_None); resultobj = Py_None;
24696 return resultobj;
24697 fail:
24698 return NULL;
24699 }
24700
24701
24702 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24703 PyObject *resultobj;
24704 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24705 wxColour *result;
24706 PyObject * obj0 = 0 ;
24707 char *kwnames[] = {
24708 (char *) "self", NULL
24709 };
24710
24711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24713 if (SWIG_arg_fail(1)) SWIG_fail;
24714 result = (wxColour *)& ((arg1)->colFg);
24715
24716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24717 return resultobj;
24718 fail:
24719 return NULL;
24720 }
24721
24722
24723 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24724 PyObject *resultobj;
24725 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24726 wxColour *arg2 = (wxColour *) 0 ;
24727 PyObject * obj0 = 0 ;
24728 PyObject * obj1 = 0 ;
24729 char *kwnames[] = {
24730 (char *) "self",(char *) "colBg", NULL
24731 };
24732
24733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24735 if (SWIG_arg_fail(1)) SWIG_fail;
24736 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24737 if (SWIG_arg_fail(2)) SWIG_fail;
24738 if (arg1) (arg1)->colBg = *arg2;
24739
24740 Py_INCREF(Py_None); resultobj = Py_None;
24741 return resultobj;
24742 fail:
24743 return NULL;
24744 }
24745
24746
24747 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24748 PyObject *resultobj;
24749 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24750 wxColour *result;
24751 PyObject * obj0 = 0 ;
24752 char *kwnames[] = {
24753 (char *) "self", NULL
24754 };
24755
24756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24758 if (SWIG_arg_fail(1)) SWIG_fail;
24759 result = (wxColour *)& ((arg1)->colBg);
24760
24761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24762 return resultobj;
24763 fail:
24764 return NULL;
24765 }
24766
24767
24768 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24769 PyObject *obj;
24770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24771 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24772 Py_INCREF(obj);
24773 return Py_BuildValue((char *)"");
24774 }
24775 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24776 PyObject *resultobj;
24777 wxWindow *arg1 = (wxWindow *) 0 ;
24778 int arg2 = (int) (int)-1 ;
24779 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24780 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24781 wxSize const &arg4_defvalue = wxDefaultSize ;
24782 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24783 long arg5 = (long) 0 ;
24784 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24785 wxString *arg6 = (wxString *) &arg6_defvalue ;
24786 wxWindow *result;
24787 wxPoint temp3 ;
24788 wxSize temp4 ;
24789 bool temp6 = false ;
24790 PyObject * obj0 = 0 ;
24791 PyObject * obj1 = 0 ;
24792 PyObject * obj2 = 0 ;
24793 PyObject * obj3 = 0 ;
24794 PyObject * obj4 = 0 ;
24795 PyObject * obj5 = 0 ;
24796 char *kwnames[] = {
24797 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24798 };
24799
24800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24802 if (SWIG_arg_fail(1)) SWIG_fail;
24803 if (obj1) {
24804 {
24805 arg2 = (int const)(SWIG_As_int(obj1));
24806 if (SWIG_arg_fail(2)) SWIG_fail;
24807 }
24808 }
24809 if (obj2) {
24810 {
24811 arg3 = &temp3;
24812 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24813 }
24814 }
24815 if (obj3) {
24816 {
24817 arg4 = &temp4;
24818 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24819 }
24820 }
24821 if (obj4) {
24822 {
24823 arg5 = (long)(SWIG_As_long(obj4));
24824 if (SWIG_arg_fail(5)) SWIG_fail;
24825 }
24826 }
24827 if (obj5) {
24828 {
24829 arg6 = wxString_in_helper(obj5);
24830 if (arg6 == NULL) SWIG_fail;
24831 temp6 = true;
24832 }
24833 }
24834 {
24835 if (!wxPyCheckForApp()) SWIG_fail;
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24838
24839 wxPyEndAllowThreads(__tstate);
24840 if (PyErr_Occurred()) SWIG_fail;
24841 }
24842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24843 {
24844 if (temp6)
24845 delete arg6;
24846 }
24847 return resultobj;
24848 fail:
24849 {
24850 if (temp6)
24851 delete arg6;
24852 }
24853 return NULL;
24854 }
24855
24856
24857 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24858 PyObject *resultobj;
24859 wxWindow *result;
24860 char *kwnames[] = {
24861 NULL
24862 };
24863
24864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24865 {
24866 if (!wxPyCheckForApp()) SWIG_fail;
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 result = (wxWindow *)new wxWindow();
24869
24870 wxPyEndAllowThreads(__tstate);
24871 if (PyErr_Occurred()) SWIG_fail;
24872 }
24873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24881 PyObject *resultobj;
24882 wxWindow *arg1 = (wxWindow *) 0 ;
24883 wxWindow *arg2 = (wxWindow *) 0 ;
24884 int arg3 = (int) (int)-1 ;
24885 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24886 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24887 wxSize const &arg5_defvalue = wxDefaultSize ;
24888 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24889 long arg6 = (long) 0 ;
24890 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24891 wxString *arg7 = (wxString *) &arg7_defvalue ;
24892 bool result;
24893 wxPoint temp4 ;
24894 wxSize temp5 ;
24895 bool temp7 = false ;
24896 PyObject * obj0 = 0 ;
24897 PyObject * obj1 = 0 ;
24898 PyObject * obj2 = 0 ;
24899 PyObject * obj3 = 0 ;
24900 PyObject * obj4 = 0 ;
24901 PyObject * obj5 = 0 ;
24902 PyObject * obj6 = 0 ;
24903 char *kwnames[] = {
24904 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24905 };
24906
24907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24909 if (SWIG_arg_fail(1)) SWIG_fail;
24910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24911 if (SWIG_arg_fail(2)) SWIG_fail;
24912 if (obj2) {
24913 {
24914 arg3 = (int const)(SWIG_As_int(obj2));
24915 if (SWIG_arg_fail(3)) SWIG_fail;
24916 }
24917 }
24918 if (obj3) {
24919 {
24920 arg4 = &temp4;
24921 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24922 }
24923 }
24924 if (obj4) {
24925 {
24926 arg5 = &temp5;
24927 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24928 }
24929 }
24930 if (obj5) {
24931 {
24932 arg6 = (long)(SWIG_As_long(obj5));
24933 if (SWIG_arg_fail(6)) SWIG_fail;
24934 }
24935 }
24936 if (obj6) {
24937 {
24938 arg7 = wxString_in_helper(obj6);
24939 if (arg7 == NULL) SWIG_fail;
24940 temp7 = true;
24941 }
24942 }
24943 {
24944 PyThreadState* __tstate = wxPyBeginAllowThreads();
24945 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24946
24947 wxPyEndAllowThreads(__tstate);
24948 if (PyErr_Occurred()) SWIG_fail;
24949 }
24950 {
24951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24952 }
24953 {
24954 if (temp7)
24955 delete arg7;
24956 }
24957 return resultobj;
24958 fail:
24959 {
24960 if (temp7)
24961 delete arg7;
24962 }
24963 return NULL;
24964 }
24965
24966
24967 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24968 PyObject *resultobj;
24969 wxWindow *arg1 = (wxWindow *) 0 ;
24970 bool arg2 = (bool) false ;
24971 bool result;
24972 PyObject * obj0 = 0 ;
24973 PyObject * obj1 = 0 ;
24974 char *kwnames[] = {
24975 (char *) "self",(char *) "force", NULL
24976 };
24977
24978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24980 if (SWIG_arg_fail(1)) SWIG_fail;
24981 if (obj1) {
24982 {
24983 arg2 = (bool)(SWIG_As_bool(obj1));
24984 if (SWIG_arg_fail(2)) SWIG_fail;
24985 }
24986 }
24987 {
24988 PyThreadState* __tstate = wxPyBeginAllowThreads();
24989 result = (bool)(arg1)->Close(arg2);
24990
24991 wxPyEndAllowThreads(__tstate);
24992 if (PyErr_Occurred()) SWIG_fail;
24993 }
24994 {
24995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24996 }
24997 return resultobj;
24998 fail:
24999 return NULL;
25000 }
25001
25002
25003 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25004 PyObject *resultobj;
25005 wxWindow *arg1 = (wxWindow *) 0 ;
25006 bool result;
25007 PyObject * obj0 = 0 ;
25008 char *kwnames[] = {
25009 (char *) "self", NULL
25010 };
25011
25012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25014 if (SWIG_arg_fail(1)) SWIG_fail;
25015 {
25016 PyThreadState* __tstate = wxPyBeginAllowThreads();
25017 result = (bool)(arg1)->Destroy();
25018
25019 wxPyEndAllowThreads(__tstate);
25020 if (PyErr_Occurred()) SWIG_fail;
25021 }
25022 {
25023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25024 }
25025 return resultobj;
25026 fail:
25027 return NULL;
25028 }
25029
25030
25031 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25032 PyObject *resultobj;
25033 wxWindow *arg1 = (wxWindow *) 0 ;
25034 bool result;
25035 PyObject * obj0 = 0 ;
25036 char *kwnames[] = {
25037 (char *) "self", NULL
25038 };
25039
25040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25042 if (SWIG_arg_fail(1)) SWIG_fail;
25043 {
25044 PyThreadState* __tstate = wxPyBeginAllowThreads();
25045 result = (bool)(arg1)->DestroyChildren();
25046
25047 wxPyEndAllowThreads(__tstate);
25048 if (PyErr_Occurred()) SWIG_fail;
25049 }
25050 {
25051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25052 }
25053 return resultobj;
25054 fail:
25055 return NULL;
25056 }
25057
25058
25059 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25060 PyObject *resultobj;
25061 wxWindow *arg1 = (wxWindow *) 0 ;
25062 bool result;
25063 PyObject * obj0 = 0 ;
25064 char *kwnames[] = {
25065 (char *) "self", NULL
25066 };
25067
25068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25070 if (SWIG_arg_fail(1)) SWIG_fail;
25071 {
25072 PyThreadState* __tstate = wxPyBeginAllowThreads();
25073 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25074
25075 wxPyEndAllowThreads(__tstate);
25076 if (PyErr_Occurred()) SWIG_fail;
25077 }
25078 {
25079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25080 }
25081 return resultobj;
25082 fail:
25083 return NULL;
25084 }
25085
25086
25087 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25088 PyObject *resultobj;
25089 wxWindow *arg1 = (wxWindow *) 0 ;
25090 wxString *arg2 = 0 ;
25091 bool temp2 = false ;
25092 PyObject * obj0 = 0 ;
25093 PyObject * obj1 = 0 ;
25094 char *kwnames[] = {
25095 (char *) "self",(char *) "title", NULL
25096 };
25097
25098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25100 if (SWIG_arg_fail(1)) SWIG_fail;
25101 {
25102 arg2 = wxString_in_helper(obj1);
25103 if (arg2 == NULL) SWIG_fail;
25104 temp2 = true;
25105 }
25106 {
25107 PyThreadState* __tstate = wxPyBeginAllowThreads();
25108 (arg1)->SetTitle((wxString const &)*arg2);
25109
25110 wxPyEndAllowThreads(__tstate);
25111 if (PyErr_Occurred()) SWIG_fail;
25112 }
25113 Py_INCREF(Py_None); resultobj = Py_None;
25114 {
25115 if (temp2)
25116 delete arg2;
25117 }
25118 return resultobj;
25119 fail:
25120 {
25121 if (temp2)
25122 delete arg2;
25123 }
25124 return NULL;
25125 }
25126
25127
25128 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25129 PyObject *resultobj;
25130 wxWindow *arg1 = (wxWindow *) 0 ;
25131 wxString result;
25132 PyObject * obj0 = 0 ;
25133 char *kwnames[] = {
25134 (char *) "self", NULL
25135 };
25136
25137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
25142 result = ((wxWindow const *)arg1)->GetTitle();
25143
25144 wxPyEndAllowThreads(__tstate);
25145 if (PyErr_Occurred()) SWIG_fail;
25146 }
25147 {
25148 #if wxUSE_UNICODE
25149 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25150 #else
25151 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25152 #endif
25153 }
25154 return resultobj;
25155 fail:
25156 return NULL;
25157 }
25158
25159
25160 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25161 PyObject *resultobj;
25162 wxWindow *arg1 = (wxWindow *) 0 ;
25163 wxString *arg2 = 0 ;
25164 bool temp2 = false ;
25165 PyObject * obj0 = 0 ;
25166 PyObject * obj1 = 0 ;
25167 char *kwnames[] = {
25168 (char *) "self",(char *) "label", NULL
25169 };
25170
25171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25173 if (SWIG_arg_fail(1)) SWIG_fail;
25174 {
25175 arg2 = wxString_in_helper(obj1);
25176 if (arg2 == NULL) SWIG_fail;
25177 temp2 = true;
25178 }
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 (arg1)->SetLabel((wxString const &)*arg2);
25182
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 Py_INCREF(Py_None); resultobj = Py_None;
25187 {
25188 if (temp2)
25189 delete arg2;
25190 }
25191 return resultobj;
25192 fail:
25193 {
25194 if (temp2)
25195 delete arg2;
25196 }
25197 return NULL;
25198 }
25199
25200
25201 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25202 PyObject *resultobj;
25203 wxWindow *arg1 = (wxWindow *) 0 ;
25204 wxString result;
25205 PyObject * obj0 = 0 ;
25206 char *kwnames[] = {
25207 (char *) "self", NULL
25208 };
25209
25210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25212 if (SWIG_arg_fail(1)) SWIG_fail;
25213 {
25214 PyThreadState* __tstate = wxPyBeginAllowThreads();
25215 result = ((wxWindow const *)arg1)->GetLabel();
25216
25217 wxPyEndAllowThreads(__tstate);
25218 if (PyErr_Occurred()) SWIG_fail;
25219 }
25220 {
25221 #if wxUSE_UNICODE
25222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25223 #else
25224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25225 #endif
25226 }
25227 return resultobj;
25228 fail:
25229 return NULL;
25230 }
25231
25232
25233 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25234 PyObject *resultobj;
25235 wxWindow *arg1 = (wxWindow *) 0 ;
25236 wxString *arg2 = 0 ;
25237 bool temp2 = false ;
25238 PyObject * obj0 = 0 ;
25239 PyObject * obj1 = 0 ;
25240 char *kwnames[] = {
25241 (char *) "self",(char *) "name", NULL
25242 };
25243
25244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25246 if (SWIG_arg_fail(1)) SWIG_fail;
25247 {
25248 arg2 = wxString_in_helper(obj1);
25249 if (arg2 == NULL) SWIG_fail;
25250 temp2 = true;
25251 }
25252 {
25253 PyThreadState* __tstate = wxPyBeginAllowThreads();
25254 (arg1)->SetName((wxString const &)*arg2);
25255
25256 wxPyEndAllowThreads(__tstate);
25257 if (PyErr_Occurred()) SWIG_fail;
25258 }
25259 Py_INCREF(Py_None); resultobj = Py_None;
25260 {
25261 if (temp2)
25262 delete arg2;
25263 }
25264 return resultobj;
25265 fail:
25266 {
25267 if (temp2)
25268 delete arg2;
25269 }
25270 return NULL;
25271 }
25272
25273
25274 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25275 PyObject *resultobj;
25276 wxWindow *arg1 = (wxWindow *) 0 ;
25277 wxString result;
25278 PyObject * obj0 = 0 ;
25279 char *kwnames[] = {
25280 (char *) "self", NULL
25281 };
25282
25283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25285 if (SWIG_arg_fail(1)) SWIG_fail;
25286 {
25287 PyThreadState* __tstate = wxPyBeginAllowThreads();
25288 result = ((wxWindow const *)arg1)->GetName();
25289
25290 wxPyEndAllowThreads(__tstate);
25291 if (PyErr_Occurred()) SWIG_fail;
25292 }
25293 {
25294 #if wxUSE_UNICODE
25295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25296 #else
25297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25298 #endif
25299 }
25300 return resultobj;
25301 fail:
25302 return NULL;
25303 }
25304
25305
25306 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25307 PyObject *resultobj;
25308 wxWindow *arg1 = (wxWindow *) 0 ;
25309 wxWindowVariant arg2 ;
25310 PyObject * obj0 = 0 ;
25311 PyObject * obj1 = 0 ;
25312 char *kwnames[] = {
25313 (char *) "self",(char *) "variant", NULL
25314 };
25315
25316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25318 if (SWIG_arg_fail(1)) SWIG_fail;
25319 {
25320 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25321 if (SWIG_arg_fail(2)) SWIG_fail;
25322 }
25323 {
25324 PyThreadState* __tstate = wxPyBeginAllowThreads();
25325 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25326
25327 wxPyEndAllowThreads(__tstate);
25328 if (PyErr_Occurred()) SWIG_fail;
25329 }
25330 Py_INCREF(Py_None); resultobj = Py_None;
25331 return resultobj;
25332 fail:
25333 return NULL;
25334 }
25335
25336
25337 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25338 PyObject *resultobj;
25339 wxWindow *arg1 = (wxWindow *) 0 ;
25340 wxWindowVariant result;
25341 PyObject * obj0 = 0 ;
25342 char *kwnames[] = {
25343 (char *) "self", NULL
25344 };
25345
25346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25348 if (SWIG_arg_fail(1)) SWIG_fail;
25349 {
25350 PyThreadState* __tstate = wxPyBeginAllowThreads();
25351 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25352
25353 wxPyEndAllowThreads(__tstate);
25354 if (PyErr_Occurred()) SWIG_fail;
25355 }
25356 resultobj = SWIG_From_int((result));
25357 return resultobj;
25358 fail:
25359 return NULL;
25360 }
25361
25362
25363 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25364 PyObject *resultobj;
25365 wxWindow *arg1 = (wxWindow *) 0 ;
25366 int arg2 ;
25367 PyObject * obj0 = 0 ;
25368 PyObject * obj1 = 0 ;
25369 char *kwnames[] = {
25370 (char *) "self",(char *) "winid", NULL
25371 };
25372
25373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25375 if (SWIG_arg_fail(1)) SWIG_fail;
25376 {
25377 arg2 = (int)(SWIG_As_int(obj1));
25378 if (SWIG_arg_fail(2)) SWIG_fail;
25379 }
25380 {
25381 PyThreadState* __tstate = wxPyBeginAllowThreads();
25382 (arg1)->SetId(arg2);
25383
25384 wxPyEndAllowThreads(__tstate);
25385 if (PyErr_Occurred()) SWIG_fail;
25386 }
25387 Py_INCREF(Py_None); resultobj = Py_None;
25388 return resultobj;
25389 fail:
25390 return NULL;
25391 }
25392
25393
25394 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25395 PyObject *resultobj;
25396 wxWindow *arg1 = (wxWindow *) 0 ;
25397 int result;
25398 PyObject * obj0 = 0 ;
25399 char *kwnames[] = {
25400 (char *) "self", NULL
25401 };
25402
25403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25405 if (SWIG_arg_fail(1)) SWIG_fail;
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 result = (int)((wxWindow const *)arg1)->GetId();
25409
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 {
25414 resultobj = SWIG_From_int((int)(result));
25415 }
25416 return resultobj;
25417 fail:
25418 return NULL;
25419 }
25420
25421
25422 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25423 PyObject *resultobj;
25424 int result;
25425 char *kwnames[] = {
25426 NULL
25427 };
25428
25429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25430 {
25431 PyThreadState* __tstate = wxPyBeginAllowThreads();
25432 result = (int)wxWindow::NewControlId();
25433
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 {
25438 resultobj = SWIG_From_int((int)(result));
25439 }
25440 return resultobj;
25441 fail:
25442 return NULL;
25443 }
25444
25445
25446 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25447 PyObject *resultobj;
25448 int arg1 ;
25449 int result;
25450 PyObject * obj0 = 0 ;
25451 char *kwnames[] = {
25452 (char *) "winid", NULL
25453 };
25454
25455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25456 {
25457 arg1 = (int)(SWIG_As_int(obj0));
25458 if (SWIG_arg_fail(1)) SWIG_fail;
25459 }
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 result = (int)wxWindow::NextControlId(arg1);
25463
25464 wxPyEndAllowThreads(__tstate);
25465 if (PyErr_Occurred()) SWIG_fail;
25466 }
25467 {
25468 resultobj = SWIG_From_int((int)(result));
25469 }
25470 return resultobj;
25471 fail:
25472 return NULL;
25473 }
25474
25475
25476 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25477 PyObject *resultobj;
25478 int arg1 ;
25479 int result;
25480 PyObject * obj0 = 0 ;
25481 char *kwnames[] = {
25482 (char *) "winid", NULL
25483 };
25484
25485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25486 {
25487 arg1 = (int)(SWIG_As_int(obj0));
25488 if (SWIG_arg_fail(1)) SWIG_fail;
25489 }
25490 {
25491 PyThreadState* __tstate = wxPyBeginAllowThreads();
25492 result = (int)wxWindow::PrevControlId(arg1);
25493
25494 wxPyEndAllowThreads(__tstate);
25495 if (PyErr_Occurred()) SWIG_fail;
25496 }
25497 {
25498 resultobj = SWIG_From_int((int)(result));
25499 }
25500 return resultobj;
25501 fail:
25502 return NULL;
25503 }
25504
25505
25506 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25507 PyObject *resultobj;
25508 wxWindow *arg1 = (wxWindow *) 0 ;
25509 wxSize *arg2 = 0 ;
25510 wxSize temp2 ;
25511 PyObject * obj0 = 0 ;
25512 PyObject * obj1 = 0 ;
25513 char *kwnames[] = {
25514 (char *) "self",(char *) "size", NULL
25515 };
25516
25517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25519 if (SWIG_arg_fail(1)) SWIG_fail;
25520 {
25521 arg2 = &temp2;
25522 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25523 }
25524 {
25525 PyThreadState* __tstate = wxPyBeginAllowThreads();
25526 (arg1)->SetSize((wxSize const &)*arg2);
25527
25528 wxPyEndAllowThreads(__tstate);
25529 if (PyErr_Occurred()) SWIG_fail;
25530 }
25531 Py_INCREF(Py_None); resultobj = Py_None;
25532 return resultobj;
25533 fail:
25534 return NULL;
25535 }
25536
25537
25538 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25539 PyObject *resultobj;
25540 wxWindow *arg1 = (wxWindow *) 0 ;
25541 int arg2 ;
25542 int arg3 ;
25543 int arg4 ;
25544 int arg5 ;
25545 int arg6 = (int) wxSIZE_AUTO ;
25546 PyObject * obj0 = 0 ;
25547 PyObject * obj1 = 0 ;
25548 PyObject * obj2 = 0 ;
25549 PyObject * obj3 = 0 ;
25550 PyObject * obj4 = 0 ;
25551 PyObject * obj5 = 0 ;
25552 char *kwnames[] = {
25553 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25554 };
25555
25556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25558 if (SWIG_arg_fail(1)) SWIG_fail;
25559 {
25560 arg2 = (int)(SWIG_As_int(obj1));
25561 if (SWIG_arg_fail(2)) SWIG_fail;
25562 }
25563 {
25564 arg3 = (int)(SWIG_As_int(obj2));
25565 if (SWIG_arg_fail(3)) SWIG_fail;
25566 }
25567 {
25568 arg4 = (int)(SWIG_As_int(obj3));
25569 if (SWIG_arg_fail(4)) SWIG_fail;
25570 }
25571 {
25572 arg5 = (int)(SWIG_As_int(obj4));
25573 if (SWIG_arg_fail(5)) SWIG_fail;
25574 }
25575 if (obj5) {
25576 {
25577 arg6 = (int)(SWIG_As_int(obj5));
25578 if (SWIG_arg_fail(6)) SWIG_fail;
25579 }
25580 }
25581 {
25582 PyThreadState* __tstate = wxPyBeginAllowThreads();
25583 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25584
25585 wxPyEndAllowThreads(__tstate);
25586 if (PyErr_Occurred()) SWIG_fail;
25587 }
25588 Py_INCREF(Py_None); resultobj = Py_None;
25589 return resultobj;
25590 fail:
25591 return NULL;
25592 }
25593
25594
25595 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25596 PyObject *resultobj;
25597 wxWindow *arg1 = (wxWindow *) 0 ;
25598 wxRect *arg2 = 0 ;
25599 int arg3 = (int) wxSIZE_AUTO ;
25600 wxRect temp2 ;
25601 PyObject * obj0 = 0 ;
25602 PyObject * obj1 = 0 ;
25603 PyObject * obj2 = 0 ;
25604 char *kwnames[] = {
25605 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25606 };
25607
25608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25610 if (SWIG_arg_fail(1)) SWIG_fail;
25611 {
25612 arg2 = &temp2;
25613 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25614 }
25615 if (obj2) {
25616 {
25617 arg3 = (int)(SWIG_As_int(obj2));
25618 if (SWIG_arg_fail(3)) SWIG_fail;
25619 }
25620 }
25621 {
25622 PyThreadState* __tstate = wxPyBeginAllowThreads();
25623 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25624
25625 wxPyEndAllowThreads(__tstate);
25626 if (PyErr_Occurred()) SWIG_fail;
25627 }
25628 Py_INCREF(Py_None); resultobj = Py_None;
25629 return resultobj;
25630 fail:
25631 return NULL;
25632 }
25633
25634
25635 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25636 PyObject *resultobj;
25637 wxWindow *arg1 = (wxWindow *) 0 ;
25638 int arg2 ;
25639 int arg3 ;
25640 PyObject * obj0 = 0 ;
25641 PyObject * obj1 = 0 ;
25642 PyObject * obj2 = 0 ;
25643 char *kwnames[] = {
25644 (char *) "self",(char *) "width",(char *) "height", NULL
25645 };
25646
25647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25649 if (SWIG_arg_fail(1)) SWIG_fail;
25650 {
25651 arg2 = (int)(SWIG_As_int(obj1));
25652 if (SWIG_arg_fail(2)) SWIG_fail;
25653 }
25654 {
25655 arg3 = (int)(SWIG_As_int(obj2));
25656 if (SWIG_arg_fail(3)) SWIG_fail;
25657 }
25658 {
25659 PyThreadState* __tstate = wxPyBeginAllowThreads();
25660 (arg1)->SetSize(arg2,arg3);
25661
25662 wxPyEndAllowThreads(__tstate);
25663 if (PyErr_Occurred()) SWIG_fail;
25664 }
25665 Py_INCREF(Py_None); resultobj = Py_None;
25666 return resultobj;
25667 fail:
25668 return NULL;
25669 }
25670
25671
25672 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25673 PyObject *resultobj;
25674 wxWindow *arg1 = (wxWindow *) 0 ;
25675 wxPoint *arg2 = 0 ;
25676 int arg3 = (int) wxSIZE_USE_EXISTING ;
25677 wxPoint temp2 ;
25678 PyObject * obj0 = 0 ;
25679 PyObject * obj1 = 0 ;
25680 PyObject * obj2 = 0 ;
25681 char *kwnames[] = {
25682 (char *) "self",(char *) "pt",(char *) "flags", NULL
25683 };
25684
25685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25687 if (SWIG_arg_fail(1)) SWIG_fail;
25688 {
25689 arg2 = &temp2;
25690 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25691 }
25692 if (obj2) {
25693 {
25694 arg3 = (int)(SWIG_As_int(obj2));
25695 if (SWIG_arg_fail(3)) SWIG_fail;
25696 }
25697 }
25698 {
25699 PyThreadState* __tstate = wxPyBeginAllowThreads();
25700 (arg1)->Move((wxPoint const &)*arg2,arg3);
25701
25702 wxPyEndAllowThreads(__tstate);
25703 if (PyErr_Occurred()) SWIG_fail;
25704 }
25705 Py_INCREF(Py_None); resultobj = Py_None;
25706 return resultobj;
25707 fail:
25708 return NULL;
25709 }
25710
25711
25712 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25713 PyObject *resultobj;
25714 wxWindow *arg1 = (wxWindow *) 0 ;
25715 int arg2 ;
25716 int arg3 ;
25717 int arg4 = (int) wxSIZE_USE_EXISTING ;
25718 PyObject * obj0 = 0 ;
25719 PyObject * obj1 = 0 ;
25720 PyObject * obj2 = 0 ;
25721 PyObject * obj3 = 0 ;
25722 char *kwnames[] = {
25723 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25724 };
25725
25726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25728 if (SWIG_arg_fail(1)) SWIG_fail;
25729 {
25730 arg2 = (int)(SWIG_As_int(obj1));
25731 if (SWIG_arg_fail(2)) SWIG_fail;
25732 }
25733 {
25734 arg3 = (int)(SWIG_As_int(obj2));
25735 if (SWIG_arg_fail(3)) SWIG_fail;
25736 }
25737 if (obj3) {
25738 {
25739 arg4 = (int)(SWIG_As_int(obj3));
25740 if (SWIG_arg_fail(4)) SWIG_fail;
25741 }
25742 }
25743 {
25744 PyThreadState* __tstate = wxPyBeginAllowThreads();
25745 (arg1)->Move(arg2,arg3,arg4);
25746
25747 wxPyEndAllowThreads(__tstate);
25748 if (PyErr_Occurred()) SWIG_fail;
25749 }
25750 Py_INCREF(Py_None); resultobj = Py_None;
25751 return resultobj;
25752 fail:
25753 return NULL;
25754 }
25755
25756
25757 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25758 PyObject *resultobj;
25759 wxWindow *arg1 = (wxWindow *) 0 ;
25760 wxSize const &arg2_defvalue = wxDefaultSize ;
25761 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25762 wxSize temp2 ;
25763 PyObject * obj0 = 0 ;
25764 PyObject * obj1 = 0 ;
25765 char *kwnames[] = {
25766 (char *) "self",(char *) "size", NULL
25767 };
25768
25769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25771 if (SWIG_arg_fail(1)) SWIG_fail;
25772 if (obj1) {
25773 {
25774 arg2 = &temp2;
25775 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25776 }
25777 }
25778 {
25779 PyThreadState* __tstate = wxPyBeginAllowThreads();
25780 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25781
25782 wxPyEndAllowThreads(__tstate);
25783 if (PyErr_Occurred()) SWIG_fail;
25784 }
25785 Py_INCREF(Py_None); resultobj = Py_None;
25786 return resultobj;
25787 fail:
25788 return NULL;
25789 }
25790
25791
25792 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25793 PyObject *resultobj;
25794 wxWindow *arg1 = (wxWindow *) 0 ;
25795 PyObject * obj0 = 0 ;
25796 char *kwnames[] = {
25797 (char *) "self", NULL
25798 };
25799
25800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25802 if (SWIG_arg_fail(1)) SWIG_fail;
25803 {
25804 PyThreadState* __tstate = wxPyBeginAllowThreads();
25805 (arg1)->Raise();
25806
25807 wxPyEndAllowThreads(__tstate);
25808 if (PyErr_Occurred()) SWIG_fail;
25809 }
25810 Py_INCREF(Py_None); resultobj = Py_None;
25811 return resultobj;
25812 fail:
25813 return NULL;
25814 }
25815
25816
25817 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25818 PyObject *resultobj;
25819 wxWindow *arg1 = (wxWindow *) 0 ;
25820 PyObject * obj0 = 0 ;
25821 char *kwnames[] = {
25822 (char *) "self", NULL
25823 };
25824
25825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25827 if (SWIG_arg_fail(1)) SWIG_fail;
25828 {
25829 PyThreadState* __tstate = wxPyBeginAllowThreads();
25830 (arg1)->Lower();
25831
25832 wxPyEndAllowThreads(__tstate);
25833 if (PyErr_Occurred()) SWIG_fail;
25834 }
25835 Py_INCREF(Py_None); resultobj = Py_None;
25836 return resultobj;
25837 fail:
25838 return NULL;
25839 }
25840
25841
25842 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25843 PyObject *resultobj;
25844 wxWindow *arg1 = (wxWindow *) 0 ;
25845 wxSize *arg2 = 0 ;
25846 wxSize temp2 ;
25847 PyObject * obj0 = 0 ;
25848 PyObject * obj1 = 0 ;
25849 char *kwnames[] = {
25850 (char *) "self",(char *) "size", NULL
25851 };
25852
25853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25855 if (SWIG_arg_fail(1)) SWIG_fail;
25856 {
25857 arg2 = &temp2;
25858 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25859 }
25860 {
25861 PyThreadState* __tstate = wxPyBeginAllowThreads();
25862 (arg1)->SetClientSize((wxSize const &)*arg2);
25863
25864 wxPyEndAllowThreads(__tstate);
25865 if (PyErr_Occurred()) SWIG_fail;
25866 }
25867 Py_INCREF(Py_None); resultobj = Py_None;
25868 return resultobj;
25869 fail:
25870 return NULL;
25871 }
25872
25873
25874 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25875 PyObject *resultobj;
25876 wxWindow *arg1 = (wxWindow *) 0 ;
25877 int arg2 ;
25878 int arg3 ;
25879 PyObject * obj0 = 0 ;
25880 PyObject * obj1 = 0 ;
25881 PyObject * obj2 = 0 ;
25882 char *kwnames[] = {
25883 (char *) "self",(char *) "width",(char *) "height", NULL
25884 };
25885
25886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25888 if (SWIG_arg_fail(1)) SWIG_fail;
25889 {
25890 arg2 = (int)(SWIG_As_int(obj1));
25891 if (SWIG_arg_fail(2)) SWIG_fail;
25892 }
25893 {
25894 arg3 = (int)(SWIG_As_int(obj2));
25895 if (SWIG_arg_fail(3)) SWIG_fail;
25896 }
25897 {
25898 PyThreadState* __tstate = wxPyBeginAllowThreads();
25899 (arg1)->SetClientSize(arg2,arg3);
25900
25901 wxPyEndAllowThreads(__tstate);
25902 if (PyErr_Occurred()) SWIG_fail;
25903 }
25904 Py_INCREF(Py_None); resultobj = Py_None;
25905 return resultobj;
25906 fail:
25907 return NULL;
25908 }
25909
25910
25911 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25912 PyObject *resultobj;
25913 wxWindow *arg1 = (wxWindow *) 0 ;
25914 wxRect *arg2 = 0 ;
25915 wxRect temp2 ;
25916 PyObject * obj0 = 0 ;
25917 PyObject * obj1 = 0 ;
25918 char *kwnames[] = {
25919 (char *) "self",(char *) "rect", NULL
25920 };
25921
25922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25924 if (SWIG_arg_fail(1)) SWIG_fail;
25925 {
25926 arg2 = &temp2;
25927 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25928 }
25929 {
25930 PyThreadState* __tstate = wxPyBeginAllowThreads();
25931 (arg1)->SetClientSize((wxRect const &)*arg2);
25932
25933 wxPyEndAllowThreads(__tstate);
25934 if (PyErr_Occurred()) SWIG_fail;
25935 }
25936 Py_INCREF(Py_None); resultobj = Py_None;
25937 return resultobj;
25938 fail:
25939 return NULL;
25940 }
25941
25942
25943 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25944 PyObject *resultobj;
25945 wxWindow *arg1 = (wxWindow *) 0 ;
25946 wxPoint result;
25947 PyObject * obj0 = 0 ;
25948 char *kwnames[] = {
25949 (char *) "self", NULL
25950 };
25951
25952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25954 if (SWIG_arg_fail(1)) SWIG_fail;
25955 {
25956 PyThreadState* __tstate = wxPyBeginAllowThreads();
25957 result = (arg1)->GetPosition();
25958
25959 wxPyEndAllowThreads(__tstate);
25960 if (PyErr_Occurred()) SWIG_fail;
25961 }
25962 {
25963 wxPoint * resultptr;
25964 resultptr = new wxPoint((wxPoint &)(result));
25965 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25966 }
25967 return resultobj;
25968 fail:
25969 return NULL;
25970 }
25971
25972
25973 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25974 PyObject *resultobj;
25975 wxWindow *arg1 = (wxWindow *) 0 ;
25976 int *arg2 = (int *) 0 ;
25977 int *arg3 = (int *) 0 ;
25978 int temp2 ;
25979 int res2 = 0 ;
25980 int temp3 ;
25981 int res3 = 0 ;
25982 PyObject * obj0 = 0 ;
25983 char *kwnames[] = {
25984 (char *) "self", NULL
25985 };
25986
25987 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25988 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25991 if (SWIG_arg_fail(1)) SWIG_fail;
25992 {
25993 PyThreadState* __tstate = wxPyBeginAllowThreads();
25994 (arg1)->GetPosition(arg2,arg3);
25995
25996 wxPyEndAllowThreads(__tstate);
25997 if (PyErr_Occurred()) SWIG_fail;
25998 }
25999 Py_INCREF(Py_None); resultobj = Py_None;
26000 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26001 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26002 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26003 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26004 return resultobj;
26005 fail:
26006 return NULL;
26007 }
26008
26009
26010 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26011 PyObject *resultobj;
26012 wxWindow *arg1 = (wxWindow *) 0 ;
26013 wxSize result;
26014 PyObject * obj0 = 0 ;
26015 char *kwnames[] = {
26016 (char *) "self", NULL
26017 };
26018
26019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26021 if (SWIG_arg_fail(1)) SWIG_fail;
26022 {
26023 PyThreadState* __tstate = wxPyBeginAllowThreads();
26024 result = ((wxWindow const *)arg1)->GetSize();
26025
26026 wxPyEndAllowThreads(__tstate);
26027 if (PyErr_Occurred()) SWIG_fail;
26028 }
26029 {
26030 wxSize * resultptr;
26031 resultptr = new wxSize((wxSize &)(result));
26032 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26033 }
26034 return resultobj;
26035 fail:
26036 return NULL;
26037 }
26038
26039
26040 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26041 PyObject *resultobj;
26042 wxWindow *arg1 = (wxWindow *) 0 ;
26043 int *arg2 = (int *) 0 ;
26044 int *arg3 = (int *) 0 ;
26045 int temp2 ;
26046 int res2 = 0 ;
26047 int temp3 ;
26048 int res3 = 0 ;
26049 PyObject * obj0 = 0 ;
26050 char *kwnames[] = {
26051 (char *) "self", NULL
26052 };
26053
26054 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26055 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26058 if (SWIG_arg_fail(1)) SWIG_fail;
26059 {
26060 PyThreadState* __tstate = wxPyBeginAllowThreads();
26061 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26062
26063 wxPyEndAllowThreads(__tstate);
26064 if (PyErr_Occurred()) SWIG_fail;
26065 }
26066 Py_INCREF(Py_None); resultobj = Py_None;
26067 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26068 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26069 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26070 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26071 return resultobj;
26072 fail:
26073 return NULL;
26074 }
26075
26076
26077 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26078 PyObject *resultobj;
26079 wxWindow *arg1 = (wxWindow *) 0 ;
26080 wxRect result;
26081 PyObject * obj0 = 0 ;
26082 char *kwnames[] = {
26083 (char *) "self", NULL
26084 };
26085
26086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26088 if (SWIG_arg_fail(1)) SWIG_fail;
26089 {
26090 PyThreadState* __tstate = wxPyBeginAllowThreads();
26091 result = ((wxWindow const *)arg1)->GetRect();
26092
26093 wxPyEndAllowThreads(__tstate);
26094 if (PyErr_Occurred()) SWIG_fail;
26095 }
26096 {
26097 wxRect * resultptr;
26098 resultptr = new wxRect((wxRect &)(result));
26099 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26100 }
26101 return resultobj;
26102 fail:
26103 return NULL;
26104 }
26105
26106
26107 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26108 PyObject *resultobj;
26109 wxWindow *arg1 = (wxWindow *) 0 ;
26110 wxSize result;
26111 PyObject * obj0 = 0 ;
26112 char *kwnames[] = {
26113 (char *) "self", NULL
26114 };
26115
26116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26118 if (SWIG_arg_fail(1)) SWIG_fail;
26119 {
26120 PyThreadState* __tstate = wxPyBeginAllowThreads();
26121 result = ((wxWindow const *)arg1)->GetClientSize();
26122
26123 wxPyEndAllowThreads(__tstate);
26124 if (PyErr_Occurred()) SWIG_fail;
26125 }
26126 {
26127 wxSize * resultptr;
26128 resultptr = new wxSize((wxSize &)(result));
26129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26130 }
26131 return resultobj;
26132 fail:
26133 return NULL;
26134 }
26135
26136
26137 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26138 PyObject *resultobj;
26139 wxWindow *arg1 = (wxWindow *) 0 ;
26140 int *arg2 = (int *) 0 ;
26141 int *arg3 = (int *) 0 ;
26142 int temp2 ;
26143 int res2 = 0 ;
26144 int temp3 ;
26145 int res3 = 0 ;
26146 PyObject * obj0 = 0 ;
26147 char *kwnames[] = {
26148 (char *) "self", NULL
26149 };
26150
26151 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26152 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26155 if (SWIG_arg_fail(1)) SWIG_fail;
26156 {
26157 PyThreadState* __tstate = wxPyBeginAllowThreads();
26158 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26159
26160 wxPyEndAllowThreads(__tstate);
26161 if (PyErr_Occurred()) SWIG_fail;
26162 }
26163 Py_INCREF(Py_None); resultobj = Py_None;
26164 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26165 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26166 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26167 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26175 PyObject *resultobj;
26176 wxWindow *arg1 = (wxWindow *) 0 ;
26177 wxPoint result;
26178 PyObject * obj0 = 0 ;
26179 char *kwnames[] = {
26180 (char *) "self", NULL
26181 };
26182
26183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26185 if (SWIG_arg_fail(1)) SWIG_fail;
26186 {
26187 PyThreadState* __tstate = wxPyBeginAllowThreads();
26188 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26189
26190 wxPyEndAllowThreads(__tstate);
26191 if (PyErr_Occurred()) SWIG_fail;
26192 }
26193 {
26194 wxPoint * resultptr;
26195 resultptr = new wxPoint((wxPoint &)(result));
26196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26197 }
26198 return resultobj;
26199 fail:
26200 return NULL;
26201 }
26202
26203
26204 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26205 PyObject *resultobj;
26206 wxWindow *arg1 = (wxWindow *) 0 ;
26207 wxRect result;
26208 PyObject * obj0 = 0 ;
26209 char *kwnames[] = {
26210 (char *) "self", NULL
26211 };
26212
26213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26215 if (SWIG_arg_fail(1)) SWIG_fail;
26216 {
26217 PyThreadState* __tstate = wxPyBeginAllowThreads();
26218 result = ((wxWindow const *)arg1)->GetClientRect();
26219
26220 wxPyEndAllowThreads(__tstate);
26221 if (PyErr_Occurred()) SWIG_fail;
26222 }
26223 {
26224 wxRect * resultptr;
26225 resultptr = new wxRect((wxRect &)(result));
26226 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26227 }
26228 return resultobj;
26229 fail:
26230 return NULL;
26231 }
26232
26233
26234 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26235 PyObject *resultobj;
26236 wxWindow *arg1 = (wxWindow *) 0 ;
26237 wxSize result;
26238 PyObject * obj0 = 0 ;
26239 char *kwnames[] = {
26240 (char *) "self", NULL
26241 };
26242
26243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26245 if (SWIG_arg_fail(1)) SWIG_fail;
26246 {
26247 PyThreadState* __tstate = wxPyBeginAllowThreads();
26248 result = ((wxWindow const *)arg1)->GetBestSize();
26249
26250 wxPyEndAllowThreads(__tstate);
26251 if (PyErr_Occurred()) SWIG_fail;
26252 }
26253 {
26254 wxSize * resultptr;
26255 resultptr = new wxSize((wxSize &)(result));
26256 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26257 }
26258 return resultobj;
26259 fail:
26260 return NULL;
26261 }
26262
26263
26264 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26265 PyObject *resultobj;
26266 wxWindow *arg1 = (wxWindow *) 0 ;
26267 int *arg2 = (int *) 0 ;
26268 int *arg3 = (int *) 0 ;
26269 int temp2 ;
26270 int res2 = 0 ;
26271 int temp3 ;
26272 int res3 = 0 ;
26273 PyObject * obj0 = 0 ;
26274 char *kwnames[] = {
26275 (char *) "self", NULL
26276 };
26277
26278 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26279 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26282 if (SWIG_arg_fail(1)) SWIG_fail;
26283 {
26284 PyThreadState* __tstate = wxPyBeginAllowThreads();
26285 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26286
26287 wxPyEndAllowThreads(__tstate);
26288 if (PyErr_Occurred()) SWIG_fail;
26289 }
26290 Py_INCREF(Py_None); resultobj = Py_None;
26291 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26292 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26293 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26294 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26295 return resultobj;
26296 fail:
26297 return NULL;
26298 }
26299
26300
26301 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26302 PyObject *resultobj;
26303 wxWindow *arg1 = (wxWindow *) 0 ;
26304 PyObject * obj0 = 0 ;
26305 char *kwnames[] = {
26306 (char *) "self", NULL
26307 };
26308
26309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26311 if (SWIG_arg_fail(1)) SWIG_fail;
26312 {
26313 PyThreadState* __tstate = wxPyBeginAllowThreads();
26314 (arg1)->InvalidateBestSize();
26315
26316 wxPyEndAllowThreads(__tstate);
26317 if (PyErr_Occurred()) SWIG_fail;
26318 }
26319 Py_INCREF(Py_None); resultobj = Py_None;
26320 return resultobj;
26321 fail:
26322 return NULL;
26323 }
26324
26325
26326 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26327 PyObject *resultobj;
26328 wxWindow *arg1 = (wxWindow *) 0 ;
26329 wxSize result;
26330 PyObject * obj0 = 0 ;
26331 char *kwnames[] = {
26332 (char *) "self", NULL
26333 };
26334
26335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26337 if (SWIG_arg_fail(1)) SWIG_fail;
26338 {
26339 PyThreadState* __tstate = wxPyBeginAllowThreads();
26340 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26341
26342 wxPyEndAllowThreads(__tstate);
26343 if (PyErr_Occurred()) SWIG_fail;
26344 }
26345 {
26346 wxSize * resultptr;
26347 resultptr = new wxSize((wxSize &)(result));
26348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26349 }
26350 return resultobj;
26351 fail:
26352 return NULL;
26353 }
26354
26355
26356 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26357 PyObject *resultobj;
26358 wxWindow *arg1 = (wxWindow *) 0 ;
26359 wxSize result;
26360 PyObject * obj0 = 0 ;
26361 char *kwnames[] = {
26362 (char *) "self", NULL
26363 };
26364
26365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26367 if (SWIG_arg_fail(1)) SWIG_fail;
26368 {
26369 PyThreadState* __tstate = wxPyBeginAllowThreads();
26370 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26371
26372 wxPyEndAllowThreads(__tstate);
26373 if (PyErr_Occurred()) SWIG_fail;
26374 }
26375 {
26376 wxSize * resultptr;
26377 resultptr = new wxSize((wxSize &)(result));
26378 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26379 }
26380 return resultobj;
26381 fail:
26382 return NULL;
26383 }
26384
26385
26386 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26387 PyObject *resultobj;
26388 wxWindow *arg1 = (wxWindow *) 0 ;
26389 int arg2 = (int) wxBOTH ;
26390 PyObject * obj0 = 0 ;
26391 PyObject * obj1 = 0 ;
26392 char *kwnames[] = {
26393 (char *) "self",(char *) "direction", NULL
26394 };
26395
26396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26398 if (SWIG_arg_fail(1)) SWIG_fail;
26399 if (obj1) {
26400 {
26401 arg2 = (int)(SWIG_As_int(obj1));
26402 if (SWIG_arg_fail(2)) SWIG_fail;
26403 }
26404 }
26405 {
26406 PyThreadState* __tstate = wxPyBeginAllowThreads();
26407 (arg1)->Center(arg2);
26408
26409 wxPyEndAllowThreads(__tstate);
26410 if (PyErr_Occurred()) SWIG_fail;
26411 }
26412 Py_INCREF(Py_None); resultobj = Py_None;
26413 return resultobj;
26414 fail:
26415 return NULL;
26416 }
26417
26418
26419 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26420 PyObject *resultobj;
26421 wxWindow *arg1 = (wxWindow *) 0 ;
26422 int arg2 = (int) wxBOTH ;
26423 PyObject * obj0 = 0 ;
26424 PyObject * obj1 = 0 ;
26425 char *kwnames[] = {
26426 (char *) "self",(char *) "dir", NULL
26427 };
26428
26429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26431 if (SWIG_arg_fail(1)) SWIG_fail;
26432 if (obj1) {
26433 {
26434 arg2 = (int)(SWIG_As_int(obj1));
26435 if (SWIG_arg_fail(2)) SWIG_fail;
26436 }
26437 }
26438 {
26439 PyThreadState* __tstate = wxPyBeginAllowThreads();
26440 (arg1)->CenterOnScreen(arg2);
26441
26442 wxPyEndAllowThreads(__tstate);
26443 if (PyErr_Occurred()) SWIG_fail;
26444 }
26445 Py_INCREF(Py_None); resultobj = Py_None;
26446 return resultobj;
26447 fail:
26448 return NULL;
26449 }
26450
26451
26452 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26453 PyObject *resultobj;
26454 wxWindow *arg1 = (wxWindow *) 0 ;
26455 int arg2 = (int) wxBOTH ;
26456 PyObject * obj0 = 0 ;
26457 PyObject * obj1 = 0 ;
26458 char *kwnames[] = {
26459 (char *) "self",(char *) "dir", NULL
26460 };
26461
26462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26464 if (SWIG_arg_fail(1)) SWIG_fail;
26465 if (obj1) {
26466 {
26467 arg2 = (int)(SWIG_As_int(obj1));
26468 if (SWIG_arg_fail(2)) SWIG_fail;
26469 }
26470 }
26471 {
26472 PyThreadState* __tstate = wxPyBeginAllowThreads();
26473 (arg1)->CenterOnParent(arg2);
26474
26475 wxPyEndAllowThreads(__tstate);
26476 if (PyErr_Occurred()) SWIG_fail;
26477 }
26478 Py_INCREF(Py_None); resultobj = Py_None;
26479 return resultobj;
26480 fail:
26481 return NULL;
26482 }
26483
26484
26485 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26486 PyObject *resultobj;
26487 wxWindow *arg1 = (wxWindow *) 0 ;
26488 PyObject * obj0 = 0 ;
26489 char *kwnames[] = {
26490 (char *) "self", NULL
26491 };
26492
26493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26495 if (SWIG_arg_fail(1)) SWIG_fail;
26496 {
26497 PyThreadState* __tstate = wxPyBeginAllowThreads();
26498 (arg1)->Fit();
26499
26500 wxPyEndAllowThreads(__tstate);
26501 if (PyErr_Occurred()) SWIG_fail;
26502 }
26503 Py_INCREF(Py_None); resultobj = Py_None;
26504 return resultobj;
26505 fail:
26506 return NULL;
26507 }
26508
26509
26510 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26511 PyObject *resultobj;
26512 wxWindow *arg1 = (wxWindow *) 0 ;
26513 PyObject * obj0 = 0 ;
26514 char *kwnames[] = {
26515 (char *) "self", NULL
26516 };
26517
26518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26520 if (SWIG_arg_fail(1)) SWIG_fail;
26521 {
26522 PyThreadState* __tstate = wxPyBeginAllowThreads();
26523 (arg1)->FitInside();
26524
26525 wxPyEndAllowThreads(__tstate);
26526 if (PyErr_Occurred()) SWIG_fail;
26527 }
26528 Py_INCREF(Py_None); resultobj = Py_None;
26529 return resultobj;
26530 fail:
26531 return NULL;
26532 }
26533
26534
26535 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26536 PyObject *resultobj;
26537 wxWindow *arg1 = (wxWindow *) 0 ;
26538 int arg2 ;
26539 int arg3 ;
26540 int arg4 = (int) -1 ;
26541 int arg5 = (int) -1 ;
26542 int arg6 = (int) -1 ;
26543 int arg7 = (int) -1 ;
26544 PyObject * obj0 = 0 ;
26545 PyObject * obj1 = 0 ;
26546 PyObject * obj2 = 0 ;
26547 PyObject * obj3 = 0 ;
26548 PyObject * obj4 = 0 ;
26549 PyObject * obj5 = 0 ;
26550 PyObject * obj6 = 0 ;
26551 char *kwnames[] = {
26552 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26553 };
26554
26555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26557 if (SWIG_arg_fail(1)) SWIG_fail;
26558 {
26559 arg2 = (int)(SWIG_As_int(obj1));
26560 if (SWIG_arg_fail(2)) SWIG_fail;
26561 }
26562 {
26563 arg3 = (int)(SWIG_As_int(obj2));
26564 if (SWIG_arg_fail(3)) SWIG_fail;
26565 }
26566 if (obj3) {
26567 {
26568 arg4 = (int)(SWIG_As_int(obj3));
26569 if (SWIG_arg_fail(4)) SWIG_fail;
26570 }
26571 }
26572 if (obj4) {
26573 {
26574 arg5 = (int)(SWIG_As_int(obj4));
26575 if (SWIG_arg_fail(5)) SWIG_fail;
26576 }
26577 }
26578 if (obj5) {
26579 {
26580 arg6 = (int)(SWIG_As_int(obj5));
26581 if (SWIG_arg_fail(6)) SWIG_fail;
26582 }
26583 }
26584 if (obj6) {
26585 {
26586 arg7 = (int)(SWIG_As_int(obj6));
26587 if (SWIG_arg_fail(7)) SWIG_fail;
26588 }
26589 }
26590 {
26591 PyThreadState* __tstate = wxPyBeginAllowThreads();
26592 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26593
26594 wxPyEndAllowThreads(__tstate);
26595 if (PyErr_Occurred()) SWIG_fail;
26596 }
26597 Py_INCREF(Py_None); resultobj = Py_None;
26598 return resultobj;
26599 fail:
26600 return NULL;
26601 }
26602
26603
26604 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26605 PyObject *resultobj;
26606 wxWindow *arg1 = (wxWindow *) 0 ;
26607 wxSize *arg2 = 0 ;
26608 wxSize const &arg3_defvalue = wxDefaultSize ;
26609 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26610 wxSize const &arg4_defvalue = wxDefaultSize ;
26611 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26612 wxSize temp2 ;
26613 wxSize temp3 ;
26614 wxSize temp4 ;
26615 PyObject * obj0 = 0 ;
26616 PyObject * obj1 = 0 ;
26617 PyObject * obj2 = 0 ;
26618 PyObject * obj3 = 0 ;
26619 char *kwnames[] = {
26620 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26621 };
26622
26623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26625 if (SWIG_arg_fail(1)) SWIG_fail;
26626 {
26627 arg2 = &temp2;
26628 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26629 }
26630 if (obj2) {
26631 {
26632 arg3 = &temp3;
26633 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26634 }
26635 }
26636 if (obj3) {
26637 {
26638 arg4 = &temp4;
26639 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26640 }
26641 }
26642 {
26643 PyThreadState* __tstate = wxPyBeginAllowThreads();
26644 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26645
26646 wxPyEndAllowThreads(__tstate);
26647 if (PyErr_Occurred()) SWIG_fail;
26648 }
26649 Py_INCREF(Py_None); resultobj = Py_None;
26650 return resultobj;
26651 fail:
26652 return NULL;
26653 }
26654
26655
26656 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26657 PyObject *resultobj;
26658 wxWindow *arg1 = (wxWindow *) 0 ;
26659 int arg2 ;
26660 int arg3 ;
26661 int arg4 = (int) -1 ;
26662 int arg5 = (int) -1 ;
26663 PyObject * obj0 = 0 ;
26664 PyObject * obj1 = 0 ;
26665 PyObject * obj2 = 0 ;
26666 PyObject * obj3 = 0 ;
26667 PyObject * obj4 = 0 ;
26668 char *kwnames[] = {
26669 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26670 };
26671
26672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26674 if (SWIG_arg_fail(1)) SWIG_fail;
26675 {
26676 arg2 = (int)(SWIG_As_int(obj1));
26677 if (SWIG_arg_fail(2)) SWIG_fail;
26678 }
26679 {
26680 arg3 = (int)(SWIG_As_int(obj2));
26681 if (SWIG_arg_fail(3)) SWIG_fail;
26682 }
26683 if (obj3) {
26684 {
26685 arg4 = (int)(SWIG_As_int(obj3));
26686 if (SWIG_arg_fail(4)) SWIG_fail;
26687 }
26688 }
26689 if (obj4) {
26690 {
26691 arg5 = (int)(SWIG_As_int(obj4));
26692 if (SWIG_arg_fail(5)) SWIG_fail;
26693 }
26694 }
26695 {
26696 PyThreadState* __tstate = wxPyBeginAllowThreads();
26697 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26698
26699 wxPyEndAllowThreads(__tstate);
26700 if (PyErr_Occurred()) SWIG_fail;
26701 }
26702 Py_INCREF(Py_None); resultobj = Py_None;
26703 return resultobj;
26704 fail:
26705 return NULL;
26706 }
26707
26708
26709 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26710 PyObject *resultobj;
26711 wxWindow *arg1 = (wxWindow *) 0 ;
26712 wxSize *arg2 = 0 ;
26713 wxSize const &arg3_defvalue = wxDefaultSize ;
26714 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26715 wxSize temp2 ;
26716 wxSize temp3 ;
26717 PyObject * obj0 = 0 ;
26718 PyObject * obj1 = 0 ;
26719 PyObject * obj2 = 0 ;
26720 char *kwnames[] = {
26721 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26722 };
26723
26724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26726 if (SWIG_arg_fail(1)) SWIG_fail;
26727 {
26728 arg2 = &temp2;
26729 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26730 }
26731 if (obj2) {
26732 {
26733 arg3 = &temp3;
26734 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26735 }
26736 }
26737 {
26738 PyThreadState* __tstate = wxPyBeginAllowThreads();
26739 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26740
26741 wxPyEndAllowThreads(__tstate);
26742 if (PyErr_Occurred()) SWIG_fail;
26743 }
26744 Py_INCREF(Py_None); resultobj = Py_None;
26745 return resultobj;
26746 fail:
26747 return NULL;
26748 }
26749
26750
26751 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26752 PyObject *resultobj;
26753 wxWindow *arg1 = (wxWindow *) 0 ;
26754 wxSize result;
26755 PyObject * obj0 = 0 ;
26756 char *kwnames[] = {
26757 (char *) "self", NULL
26758 };
26759
26760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26762 if (SWIG_arg_fail(1)) SWIG_fail;
26763 {
26764 PyThreadState* __tstate = wxPyBeginAllowThreads();
26765 result = ((wxWindow const *)arg1)->GetMaxSize();
26766
26767 wxPyEndAllowThreads(__tstate);
26768 if (PyErr_Occurred()) SWIG_fail;
26769 }
26770 {
26771 wxSize * resultptr;
26772 resultptr = new wxSize((wxSize &)(result));
26773 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26774 }
26775 return resultobj;
26776 fail:
26777 return NULL;
26778 }
26779
26780
26781 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26782 PyObject *resultobj;
26783 wxWindow *arg1 = (wxWindow *) 0 ;
26784 wxSize result;
26785 PyObject * obj0 = 0 ;
26786 char *kwnames[] = {
26787 (char *) "self", NULL
26788 };
26789
26790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26792 if (SWIG_arg_fail(1)) SWIG_fail;
26793 {
26794 PyThreadState* __tstate = wxPyBeginAllowThreads();
26795 result = ((wxWindow const *)arg1)->GetMinSize();
26796
26797 wxPyEndAllowThreads(__tstate);
26798 if (PyErr_Occurred()) SWIG_fail;
26799 }
26800 {
26801 wxSize * resultptr;
26802 resultptr = new wxSize((wxSize &)(result));
26803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26804 }
26805 return resultobj;
26806 fail:
26807 return NULL;
26808 }
26809
26810
26811 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26812 PyObject *resultobj;
26813 wxWindow *arg1 = (wxWindow *) 0 ;
26814 wxSize *arg2 = 0 ;
26815 wxSize temp2 ;
26816 PyObject * obj0 = 0 ;
26817 PyObject * obj1 = 0 ;
26818 char *kwnames[] = {
26819 (char *) "self",(char *) "minSize", NULL
26820 };
26821
26822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26824 if (SWIG_arg_fail(1)) SWIG_fail;
26825 {
26826 arg2 = &temp2;
26827 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26828 }
26829 {
26830 PyThreadState* __tstate = wxPyBeginAllowThreads();
26831 (arg1)->SetMinSize((wxSize const &)*arg2);
26832
26833 wxPyEndAllowThreads(__tstate);
26834 if (PyErr_Occurred()) SWIG_fail;
26835 }
26836 Py_INCREF(Py_None); resultobj = Py_None;
26837 return resultobj;
26838 fail:
26839 return NULL;
26840 }
26841
26842
26843 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26844 PyObject *resultobj;
26845 wxWindow *arg1 = (wxWindow *) 0 ;
26846 wxSize *arg2 = 0 ;
26847 wxSize temp2 ;
26848 PyObject * obj0 = 0 ;
26849 PyObject * obj1 = 0 ;
26850 char *kwnames[] = {
26851 (char *) "self",(char *) "maxSize", NULL
26852 };
26853
26854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26856 if (SWIG_arg_fail(1)) SWIG_fail;
26857 {
26858 arg2 = &temp2;
26859 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26860 }
26861 {
26862 PyThreadState* __tstate = wxPyBeginAllowThreads();
26863 (arg1)->SetMaxSize((wxSize const &)*arg2);
26864
26865 wxPyEndAllowThreads(__tstate);
26866 if (PyErr_Occurred()) SWIG_fail;
26867 }
26868 Py_INCREF(Py_None); resultobj = Py_None;
26869 return resultobj;
26870 fail:
26871 return NULL;
26872 }
26873
26874
26875 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26876 PyObject *resultobj;
26877 wxWindow *arg1 = (wxWindow *) 0 ;
26878 int result;
26879 PyObject * obj0 = 0 ;
26880 char *kwnames[] = {
26881 (char *) "self", NULL
26882 };
26883
26884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26886 if (SWIG_arg_fail(1)) SWIG_fail;
26887 {
26888 PyThreadState* __tstate = wxPyBeginAllowThreads();
26889 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26890
26891 wxPyEndAllowThreads(__tstate);
26892 if (PyErr_Occurred()) SWIG_fail;
26893 }
26894 {
26895 resultobj = SWIG_From_int((int)(result));
26896 }
26897 return resultobj;
26898 fail:
26899 return NULL;
26900 }
26901
26902
26903 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26904 PyObject *resultobj;
26905 wxWindow *arg1 = (wxWindow *) 0 ;
26906 int result;
26907 PyObject * obj0 = 0 ;
26908 char *kwnames[] = {
26909 (char *) "self", NULL
26910 };
26911
26912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26914 if (SWIG_arg_fail(1)) SWIG_fail;
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26918
26919 wxPyEndAllowThreads(__tstate);
26920 if (PyErr_Occurred()) SWIG_fail;
26921 }
26922 {
26923 resultobj = SWIG_From_int((int)(result));
26924 }
26925 return resultobj;
26926 fail:
26927 return NULL;
26928 }
26929
26930
26931 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26932 PyObject *resultobj;
26933 wxWindow *arg1 = (wxWindow *) 0 ;
26934 int result;
26935 PyObject * obj0 = 0 ;
26936 char *kwnames[] = {
26937 (char *) "self", NULL
26938 };
26939
26940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26942 if (SWIG_arg_fail(1)) SWIG_fail;
26943 {
26944 PyThreadState* __tstate = wxPyBeginAllowThreads();
26945 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26946
26947 wxPyEndAllowThreads(__tstate);
26948 if (PyErr_Occurred()) SWIG_fail;
26949 }
26950 {
26951 resultobj = SWIG_From_int((int)(result));
26952 }
26953 return resultobj;
26954 fail:
26955 return NULL;
26956 }
26957
26958
26959 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26960 PyObject *resultobj;
26961 wxWindow *arg1 = (wxWindow *) 0 ;
26962 int result;
26963 PyObject * obj0 = 0 ;
26964 char *kwnames[] = {
26965 (char *) "self", NULL
26966 };
26967
26968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26970 if (SWIG_arg_fail(1)) SWIG_fail;
26971 {
26972 PyThreadState* __tstate = wxPyBeginAllowThreads();
26973 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26974
26975 wxPyEndAllowThreads(__tstate);
26976 if (PyErr_Occurred()) SWIG_fail;
26977 }
26978 {
26979 resultobj = SWIG_From_int((int)(result));
26980 }
26981 return resultobj;
26982 fail:
26983 return NULL;
26984 }
26985
26986
26987 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26988 PyObject *resultobj;
26989 wxWindow *arg1 = (wxWindow *) 0 ;
26990 wxSize *arg2 = 0 ;
26991 wxSize temp2 ;
26992 PyObject * obj0 = 0 ;
26993 PyObject * obj1 = 0 ;
26994 char *kwnames[] = {
26995 (char *) "self",(char *) "size", NULL
26996 };
26997
26998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27000 if (SWIG_arg_fail(1)) SWIG_fail;
27001 {
27002 arg2 = &temp2;
27003 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27004 }
27005 {
27006 PyThreadState* __tstate = wxPyBeginAllowThreads();
27007 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27008
27009 wxPyEndAllowThreads(__tstate);
27010 if (PyErr_Occurred()) SWIG_fail;
27011 }
27012 Py_INCREF(Py_None); resultobj = Py_None;
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27020 PyObject *resultobj;
27021 wxWindow *arg1 = (wxWindow *) 0 ;
27022 int arg2 ;
27023 int arg3 ;
27024 PyObject * obj0 = 0 ;
27025 PyObject * obj1 = 0 ;
27026 PyObject * obj2 = 0 ;
27027 char *kwnames[] = {
27028 (char *) "self",(char *) "w",(char *) "h", NULL
27029 };
27030
27031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27033 if (SWIG_arg_fail(1)) SWIG_fail;
27034 {
27035 arg2 = (int)(SWIG_As_int(obj1));
27036 if (SWIG_arg_fail(2)) SWIG_fail;
27037 }
27038 {
27039 arg3 = (int)(SWIG_As_int(obj2));
27040 if (SWIG_arg_fail(3)) SWIG_fail;
27041 }
27042 {
27043 PyThreadState* __tstate = wxPyBeginAllowThreads();
27044 (arg1)->SetVirtualSize(arg2,arg3);
27045
27046 wxPyEndAllowThreads(__tstate);
27047 if (PyErr_Occurred()) SWIG_fail;
27048 }
27049 Py_INCREF(Py_None); resultobj = Py_None;
27050 return resultobj;
27051 fail:
27052 return NULL;
27053 }
27054
27055
27056 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27057 PyObject *resultobj;
27058 wxWindow *arg1 = (wxWindow *) 0 ;
27059 wxSize result;
27060 PyObject * obj0 = 0 ;
27061 char *kwnames[] = {
27062 (char *) "self", NULL
27063 };
27064
27065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27067 if (SWIG_arg_fail(1)) SWIG_fail;
27068 {
27069 PyThreadState* __tstate = wxPyBeginAllowThreads();
27070 result = ((wxWindow const *)arg1)->GetVirtualSize();
27071
27072 wxPyEndAllowThreads(__tstate);
27073 if (PyErr_Occurred()) SWIG_fail;
27074 }
27075 {
27076 wxSize * resultptr;
27077 resultptr = new wxSize((wxSize &)(result));
27078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27079 }
27080 return resultobj;
27081 fail:
27082 return NULL;
27083 }
27084
27085
27086 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27087 PyObject *resultobj;
27088 wxWindow *arg1 = (wxWindow *) 0 ;
27089 int *arg2 = (int *) 0 ;
27090 int *arg3 = (int *) 0 ;
27091 int temp2 ;
27092 int res2 = 0 ;
27093 int temp3 ;
27094 int res3 = 0 ;
27095 PyObject * obj0 = 0 ;
27096 char *kwnames[] = {
27097 (char *) "self", NULL
27098 };
27099
27100 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27101 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27104 if (SWIG_arg_fail(1)) SWIG_fail;
27105 {
27106 PyThreadState* __tstate = wxPyBeginAllowThreads();
27107 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27108
27109 wxPyEndAllowThreads(__tstate);
27110 if (PyErr_Occurred()) SWIG_fail;
27111 }
27112 Py_INCREF(Py_None); resultobj = Py_None;
27113 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27114 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27115 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27116 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27117 return resultobj;
27118 fail:
27119 return NULL;
27120 }
27121
27122
27123 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27124 PyObject *resultobj;
27125 wxWindow *arg1 = (wxWindow *) 0 ;
27126 wxSize result;
27127 PyObject * obj0 = 0 ;
27128 char *kwnames[] = {
27129 (char *) "self", NULL
27130 };
27131
27132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27134 if (SWIG_arg_fail(1)) SWIG_fail;
27135 {
27136 PyThreadState* __tstate = wxPyBeginAllowThreads();
27137 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27138
27139 wxPyEndAllowThreads(__tstate);
27140 if (PyErr_Occurred()) SWIG_fail;
27141 }
27142 {
27143 wxSize * resultptr;
27144 resultptr = new wxSize((wxSize &)(result));
27145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27146 }
27147 return resultobj;
27148 fail:
27149 return NULL;
27150 }
27151
27152
27153 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27154 PyObject *resultobj;
27155 wxWindow *arg1 = (wxWindow *) 0 ;
27156 bool arg2 = (bool) true ;
27157 bool result;
27158 PyObject * obj0 = 0 ;
27159 PyObject * obj1 = 0 ;
27160 char *kwnames[] = {
27161 (char *) "self",(char *) "show", NULL
27162 };
27163
27164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27166 if (SWIG_arg_fail(1)) SWIG_fail;
27167 if (obj1) {
27168 {
27169 arg2 = (bool)(SWIG_As_bool(obj1));
27170 if (SWIG_arg_fail(2)) SWIG_fail;
27171 }
27172 }
27173 {
27174 PyThreadState* __tstate = wxPyBeginAllowThreads();
27175 result = (bool)(arg1)->Show(arg2);
27176
27177 wxPyEndAllowThreads(__tstate);
27178 if (PyErr_Occurred()) SWIG_fail;
27179 }
27180 {
27181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27182 }
27183 return resultobj;
27184 fail:
27185 return NULL;
27186 }
27187
27188
27189 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27190 PyObject *resultobj;
27191 wxWindow *arg1 = (wxWindow *) 0 ;
27192 bool result;
27193 PyObject * obj0 = 0 ;
27194 char *kwnames[] = {
27195 (char *) "self", NULL
27196 };
27197
27198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27200 if (SWIG_arg_fail(1)) SWIG_fail;
27201 {
27202 PyThreadState* __tstate = wxPyBeginAllowThreads();
27203 result = (bool)(arg1)->Hide();
27204
27205 wxPyEndAllowThreads(__tstate);
27206 if (PyErr_Occurred()) SWIG_fail;
27207 }
27208 {
27209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27210 }
27211 return resultobj;
27212 fail:
27213 return NULL;
27214 }
27215
27216
27217 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27218 PyObject *resultobj;
27219 wxWindow *arg1 = (wxWindow *) 0 ;
27220 bool arg2 = (bool) true ;
27221 bool result;
27222 PyObject * obj0 = 0 ;
27223 PyObject * obj1 = 0 ;
27224 char *kwnames[] = {
27225 (char *) "self",(char *) "enable", NULL
27226 };
27227
27228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27230 if (SWIG_arg_fail(1)) SWIG_fail;
27231 if (obj1) {
27232 {
27233 arg2 = (bool)(SWIG_As_bool(obj1));
27234 if (SWIG_arg_fail(2)) SWIG_fail;
27235 }
27236 }
27237 {
27238 PyThreadState* __tstate = wxPyBeginAllowThreads();
27239 result = (bool)(arg1)->Enable(arg2);
27240
27241 wxPyEndAllowThreads(__tstate);
27242 if (PyErr_Occurred()) SWIG_fail;
27243 }
27244 {
27245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27246 }
27247 return resultobj;
27248 fail:
27249 return NULL;
27250 }
27251
27252
27253 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27254 PyObject *resultobj;
27255 wxWindow *arg1 = (wxWindow *) 0 ;
27256 bool result;
27257 PyObject * obj0 = 0 ;
27258 char *kwnames[] = {
27259 (char *) "self", NULL
27260 };
27261
27262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",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 = (bool)(arg1)->Disable();
27268
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 {
27273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27274 }
27275 return resultobj;
27276 fail:
27277 return NULL;
27278 }
27279
27280
27281 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27282 PyObject *resultobj;
27283 wxWindow *arg1 = (wxWindow *) 0 ;
27284 bool result;
27285 PyObject * obj0 = 0 ;
27286 char *kwnames[] = {
27287 (char *) "self", NULL
27288 };
27289
27290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27292 if (SWIG_arg_fail(1)) SWIG_fail;
27293 {
27294 PyThreadState* __tstate = wxPyBeginAllowThreads();
27295 result = (bool)((wxWindow const *)arg1)->IsShown();
27296
27297 wxPyEndAllowThreads(__tstate);
27298 if (PyErr_Occurred()) SWIG_fail;
27299 }
27300 {
27301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27302 }
27303 return resultobj;
27304 fail:
27305 return NULL;
27306 }
27307
27308
27309 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27310 PyObject *resultobj;
27311 wxWindow *arg1 = (wxWindow *) 0 ;
27312 bool result;
27313 PyObject * obj0 = 0 ;
27314 char *kwnames[] = {
27315 (char *) "self", NULL
27316 };
27317
27318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27320 if (SWIG_arg_fail(1)) SWIG_fail;
27321 {
27322 PyThreadState* __tstate = wxPyBeginAllowThreads();
27323 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27324
27325 wxPyEndAllowThreads(__tstate);
27326 if (PyErr_Occurred()) SWIG_fail;
27327 }
27328 {
27329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27330 }
27331 return resultobj;
27332 fail:
27333 return NULL;
27334 }
27335
27336
27337 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27338 PyObject *resultobj;
27339 wxWindow *arg1 = (wxWindow *) 0 ;
27340 long arg2 ;
27341 PyObject * obj0 = 0 ;
27342 PyObject * obj1 = 0 ;
27343 char *kwnames[] = {
27344 (char *) "self",(char *) "style", NULL
27345 };
27346
27347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27349 if (SWIG_arg_fail(1)) SWIG_fail;
27350 {
27351 arg2 = (long)(SWIG_As_long(obj1));
27352 if (SWIG_arg_fail(2)) SWIG_fail;
27353 }
27354 {
27355 PyThreadState* __tstate = wxPyBeginAllowThreads();
27356 (arg1)->SetWindowStyleFlag(arg2);
27357
27358 wxPyEndAllowThreads(__tstate);
27359 if (PyErr_Occurred()) SWIG_fail;
27360 }
27361 Py_INCREF(Py_None); resultobj = Py_None;
27362 return resultobj;
27363 fail:
27364 return NULL;
27365 }
27366
27367
27368 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27369 PyObject *resultobj;
27370 wxWindow *arg1 = (wxWindow *) 0 ;
27371 long result;
27372 PyObject * obj0 = 0 ;
27373 char *kwnames[] = {
27374 (char *) "self", NULL
27375 };
27376
27377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27379 if (SWIG_arg_fail(1)) SWIG_fail;
27380 {
27381 PyThreadState* __tstate = wxPyBeginAllowThreads();
27382 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27383
27384 wxPyEndAllowThreads(__tstate);
27385 if (PyErr_Occurred()) SWIG_fail;
27386 }
27387 {
27388 resultobj = SWIG_From_long((long)(result));
27389 }
27390 return resultobj;
27391 fail:
27392 return NULL;
27393 }
27394
27395
27396 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27397 PyObject *resultobj;
27398 wxWindow *arg1 = (wxWindow *) 0 ;
27399 int arg2 ;
27400 bool result;
27401 PyObject * obj0 = 0 ;
27402 PyObject * obj1 = 0 ;
27403 char *kwnames[] = {
27404 (char *) "self",(char *) "flag", NULL
27405 };
27406
27407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27409 if (SWIG_arg_fail(1)) SWIG_fail;
27410 {
27411 arg2 = (int)(SWIG_As_int(obj1));
27412 if (SWIG_arg_fail(2)) SWIG_fail;
27413 }
27414 {
27415 PyThreadState* __tstate = wxPyBeginAllowThreads();
27416 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27417
27418 wxPyEndAllowThreads(__tstate);
27419 if (PyErr_Occurred()) SWIG_fail;
27420 }
27421 {
27422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27423 }
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj;
27432 wxWindow *arg1 = (wxWindow *) 0 ;
27433 bool result;
27434 PyObject * obj0 = 0 ;
27435 char *kwnames[] = {
27436 (char *) "self", NULL
27437 };
27438
27439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27441 if (SWIG_arg_fail(1)) SWIG_fail;
27442 {
27443 PyThreadState* __tstate = wxPyBeginAllowThreads();
27444 result = (bool)((wxWindow const *)arg1)->IsRetained();
27445
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 {
27450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27451 }
27452 return resultobj;
27453 fail:
27454 return NULL;
27455 }
27456
27457
27458 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27459 PyObject *resultobj;
27460 wxWindow *arg1 = (wxWindow *) 0 ;
27461 long arg2 ;
27462 PyObject * obj0 = 0 ;
27463 PyObject * obj1 = 0 ;
27464 char *kwnames[] = {
27465 (char *) "self",(char *) "exStyle", NULL
27466 };
27467
27468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27470 if (SWIG_arg_fail(1)) SWIG_fail;
27471 {
27472 arg2 = (long)(SWIG_As_long(obj1));
27473 if (SWIG_arg_fail(2)) SWIG_fail;
27474 }
27475 {
27476 PyThreadState* __tstate = wxPyBeginAllowThreads();
27477 (arg1)->SetExtraStyle(arg2);
27478
27479 wxPyEndAllowThreads(__tstate);
27480 if (PyErr_Occurred()) SWIG_fail;
27481 }
27482 Py_INCREF(Py_None); resultobj = Py_None;
27483 return resultobj;
27484 fail:
27485 return NULL;
27486 }
27487
27488
27489 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27490 PyObject *resultobj;
27491 wxWindow *arg1 = (wxWindow *) 0 ;
27492 long result;
27493 PyObject * obj0 = 0 ;
27494 char *kwnames[] = {
27495 (char *) "self", NULL
27496 };
27497
27498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27500 if (SWIG_arg_fail(1)) SWIG_fail;
27501 {
27502 PyThreadState* __tstate = wxPyBeginAllowThreads();
27503 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27504
27505 wxPyEndAllowThreads(__tstate);
27506 if (PyErr_Occurred()) SWIG_fail;
27507 }
27508 {
27509 resultobj = SWIG_From_long((long)(result));
27510 }
27511 return resultobj;
27512 fail:
27513 return NULL;
27514 }
27515
27516
27517 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27518 PyObject *resultobj;
27519 wxWindow *arg1 = (wxWindow *) 0 ;
27520 bool arg2 = (bool) true ;
27521 PyObject * obj0 = 0 ;
27522 PyObject * obj1 = 0 ;
27523 char *kwnames[] = {
27524 (char *) "self",(char *) "modal", NULL
27525 };
27526
27527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27529 if (SWIG_arg_fail(1)) SWIG_fail;
27530 if (obj1) {
27531 {
27532 arg2 = (bool)(SWIG_As_bool(obj1));
27533 if (SWIG_arg_fail(2)) SWIG_fail;
27534 }
27535 }
27536 {
27537 PyThreadState* __tstate = wxPyBeginAllowThreads();
27538 (arg1)->MakeModal(arg2);
27539
27540 wxPyEndAllowThreads(__tstate);
27541 if (PyErr_Occurred()) SWIG_fail;
27542 }
27543 Py_INCREF(Py_None); resultobj = Py_None;
27544 return resultobj;
27545 fail:
27546 return NULL;
27547 }
27548
27549
27550 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27551 PyObject *resultobj;
27552 wxWindow *arg1 = (wxWindow *) 0 ;
27553 bool arg2 ;
27554 PyObject * obj0 = 0 ;
27555 PyObject * obj1 = 0 ;
27556 char *kwnames[] = {
27557 (char *) "self",(char *) "enableTheme", NULL
27558 };
27559
27560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27562 if (SWIG_arg_fail(1)) SWIG_fail;
27563 {
27564 arg2 = (bool)(SWIG_As_bool(obj1));
27565 if (SWIG_arg_fail(2)) SWIG_fail;
27566 }
27567 {
27568 PyThreadState* __tstate = wxPyBeginAllowThreads();
27569 (arg1)->SetThemeEnabled(arg2);
27570
27571 wxPyEndAllowThreads(__tstate);
27572 if (PyErr_Occurred()) SWIG_fail;
27573 }
27574 Py_INCREF(Py_None); resultobj = Py_None;
27575 return resultobj;
27576 fail:
27577 return NULL;
27578 }
27579
27580
27581 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27582 PyObject *resultobj;
27583 wxWindow *arg1 = (wxWindow *) 0 ;
27584 bool result;
27585 PyObject * obj0 = 0 ;
27586 char *kwnames[] = {
27587 (char *) "self", NULL
27588 };
27589
27590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27592 if (SWIG_arg_fail(1)) SWIG_fail;
27593 {
27594 PyThreadState* __tstate = wxPyBeginAllowThreads();
27595 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27596
27597 wxPyEndAllowThreads(__tstate);
27598 if (PyErr_Occurred()) SWIG_fail;
27599 }
27600 {
27601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27602 }
27603 return resultobj;
27604 fail:
27605 return NULL;
27606 }
27607
27608
27609 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27610 PyObject *resultobj;
27611 wxWindow *arg1 = (wxWindow *) 0 ;
27612 PyObject * obj0 = 0 ;
27613 char *kwnames[] = {
27614 (char *) "self", NULL
27615 };
27616
27617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27619 if (SWIG_arg_fail(1)) SWIG_fail;
27620 {
27621 PyThreadState* __tstate = wxPyBeginAllowThreads();
27622 (arg1)->SetFocus();
27623
27624 wxPyEndAllowThreads(__tstate);
27625 if (PyErr_Occurred()) SWIG_fail;
27626 }
27627 Py_INCREF(Py_None); resultobj = Py_None;
27628 return resultobj;
27629 fail:
27630 return NULL;
27631 }
27632
27633
27634 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27635 PyObject *resultobj;
27636 wxWindow *arg1 = (wxWindow *) 0 ;
27637 PyObject * obj0 = 0 ;
27638 char *kwnames[] = {
27639 (char *) "self", NULL
27640 };
27641
27642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27644 if (SWIG_arg_fail(1)) SWIG_fail;
27645 {
27646 PyThreadState* __tstate = wxPyBeginAllowThreads();
27647 (arg1)->SetFocusFromKbd();
27648
27649 wxPyEndAllowThreads(__tstate);
27650 if (PyErr_Occurred()) SWIG_fail;
27651 }
27652 Py_INCREF(Py_None); resultobj = Py_None;
27653 return resultobj;
27654 fail:
27655 return NULL;
27656 }
27657
27658
27659 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27660 PyObject *resultobj;
27661 wxWindow *result;
27662 char *kwnames[] = {
27663 NULL
27664 };
27665
27666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27667 {
27668 if (!wxPyCheckForApp()) SWIG_fail;
27669 PyThreadState* __tstate = wxPyBeginAllowThreads();
27670 result = (wxWindow *)wxWindow::FindFocus();
27671
27672 wxPyEndAllowThreads(__tstate);
27673 if (PyErr_Occurred()) SWIG_fail;
27674 }
27675 {
27676 resultobj = wxPyMake_wxObject(result, 0);
27677 }
27678 return resultobj;
27679 fail:
27680 return NULL;
27681 }
27682
27683
27684 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27685 PyObject *resultobj;
27686 wxWindow *arg1 = (wxWindow *) 0 ;
27687 bool result;
27688 PyObject * obj0 = 0 ;
27689 char *kwnames[] = {
27690 (char *) "self", NULL
27691 };
27692
27693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27695 if (SWIG_arg_fail(1)) SWIG_fail;
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27699
27700 wxPyEndAllowThreads(__tstate);
27701 if (PyErr_Occurred()) SWIG_fail;
27702 }
27703 {
27704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27705 }
27706 return resultobj;
27707 fail:
27708 return NULL;
27709 }
27710
27711
27712 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27713 PyObject *resultobj;
27714 wxWindow *arg1 = (wxWindow *) 0 ;
27715 bool result;
27716 PyObject * obj0 = 0 ;
27717 char *kwnames[] = {
27718 (char *) "self", NULL
27719 };
27720
27721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27723 if (SWIG_arg_fail(1)) SWIG_fail;
27724 {
27725 PyThreadState* __tstate = wxPyBeginAllowThreads();
27726 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27727
27728 wxPyEndAllowThreads(__tstate);
27729 if (PyErr_Occurred()) SWIG_fail;
27730 }
27731 {
27732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27733 }
27734 return resultobj;
27735 fail:
27736 return NULL;
27737 }
27738
27739
27740 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27741 PyObject *resultobj;
27742 wxWindow *arg1 = (wxWindow *) 0 ;
27743 wxWindow *result;
27744 PyObject * obj0 = 0 ;
27745 char *kwnames[] = {
27746 (char *) "self", NULL
27747 };
27748
27749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27751 if (SWIG_arg_fail(1)) SWIG_fail;
27752 {
27753 PyThreadState* __tstate = wxPyBeginAllowThreads();
27754 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27755
27756 wxPyEndAllowThreads(__tstate);
27757 if (PyErr_Occurred()) SWIG_fail;
27758 }
27759 {
27760 resultobj = wxPyMake_wxObject(result, 0);
27761 }
27762 return resultobj;
27763 fail:
27764 return NULL;
27765 }
27766
27767
27768 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27769 PyObject *resultobj;
27770 wxWindow *arg1 = (wxWindow *) 0 ;
27771 wxWindow *arg2 = (wxWindow *) 0 ;
27772 wxWindow *result;
27773 PyObject * obj0 = 0 ;
27774 PyObject * obj1 = 0 ;
27775 char *kwnames[] = {
27776 (char *) "self",(char *) "child", NULL
27777 };
27778
27779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27781 if (SWIG_arg_fail(1)) SWIG_fail;
27782 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27783 if (SWIG_arg_fail(2)) SWIG_fail;
27784 {
27785 PyThreadState* __tstate = wxPyBeginAllowThreads();
27786 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27787
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 {
27792 resultobj = wxPyMake_wxObject(result, 0);
27793 }
27794 return resultobj;
27795 fail:
27796 return NULL;
27797 }
27798
27799
27800 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27801 PyObject *resultobj;
27802 wxWindow *arg1 = (wxWindow *) 0 ;
27803 wxWindow *arg2 = (wxWindow *) 0 ;
27804 PyObject * obj0 = 0 ;
27805 PyObject * obj1 = 0 ;
27806 char *kwnames[] = {
27807 (char *) "self",(char *) "win", NULL
27808 };
27809
27810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27812 if (SWIG_arg_fail(1)) SWIG_fail;
27813 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27814 if (SWIG_arg_fail(2)) SWIG_fail;
27815 {
27816 PyThreadState* __tstate = wxPyBeginAllowThreads();
27817 (arg1)->SetTmpDefaultItem(arg2);
27818
27819 wxPyEndAllowThreads(__tstate);
27820 if (PyErr_Occurred()) SWIG_fail;
27821 }
27822 Py_INCREF(Py_None); resultobj = Py_None;
27823 return resultobj;
27824 fail:
27825 return NULL;
27826 }
27827
27828
27829 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27830 PyObject *resultobj;
27831 wxWindow *arg1 = (wxWindow *) 0 ;
27832 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27833 bool result;
27834 PyObject * obj0 = 0 ;
27835 PyObject * obj1 = 0 ;
27836 char *kwnames[] = {
27837 (char *) "self",(char *) "flags", NULL
27838 };
27839
27840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27842 if (SWIG_arg_fail(1)) SWIG_fail;
27843 if (obj1) {
27844 {
27845 arg2 = (int)(SWIG_As_int(obj1));
27846 if (SWIG_arg_fail(2)) SWIG_fail;
27847 }
27848 }
27849 {
27850 PyThreadState* __tstate = wxPyBeginAllowThreads();
27851 result = (bool)(arg1)->Navigate(arg2);
27852
27853 wxPyEndAllowThreads(__tstate);
27854 if (PyErr_Occurred()) SWIG_fail;
27855 }
27856 {
27857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27858 }
27859 return resultobj;
27860 fail:
27861 return NULL;
27862 }
27863
27864
27865 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27866 PyObject *resultobj;
27867 wxWindow *arg1 = (wxWindow *) 0 ;
27868 wxWindow *arg2 = (wxWindow *) 0 ;
27869 PyObject * obj0 = 0 ;
27870 PyObject * obj1 = 0 ;
27871 char *kwnames[] = {
27872 (char *) "self",(char *) "win", NULL
27873 };
27874
27875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27877 if (SWIG_arg_fail(1)) SWIG_fail;
27878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27879 if (SWIG_arg_fail(2)) SWIG_fail;
27880 {
27881 PyThreadState* __tstate = wxPyBeginAllowThreads();
27882 (arg1)->MoveAfterInTabOrder(arg2);
27883
27884 wxPyEndAllowThreads(__tstate);
27885 if (PyErr_Occurred()) SWIG_fail;
27886 }
27887 Py_INCREF(Py_None); resultobj = Py_None;
27888 return resultobj;
27889 fail:
27890 return NULL;
27891 }
27892
27893
27894 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27895 PyObject *resultobj;
27896 wxWindow *arg1 = (wxWindow *) 0 ;
27897 wxWindow *arg2 = (wxWindow *) 0 ;
27898 PyObject * obj0 = 0 ;
27899 PyObject * obj1 = 0 ;
27900 char *kwnames[] = {
27901 (char *) "self",(char *) "win", NULL
27902 };
27903
27904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27906 if (SWIG_arg_fail(1)) SWIG_fail;
27907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27908 if (SWIG_arg_fail(2)) SWIG_fail;
27909 {
27910 PyThreadState* __tstate = wxPyBeginAllowThreads();
27911 (arg1)->MoveBeforeInTabOrder(arg2);
27912
27913 wxPyEndAllowThreads(__tstate);
27914 if (PyErr_Occurred()) SWIG_fail;
27915 }
27916 Py_INCREF(Py_None); resultobj = Py_None;
27917 return resultobj;
27918 fail:
27919 return NULL;
27920 }
27921
27922
27923 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27924 PyObject *resultobj;
27925 wxWindow *arg1 = (wxWindow *) 0 ;
27926 PyObject *result;
27927 PyObject * obj0 = 0 ;
27928 char *kwnames[] = {
27929 (char *) "self", NULL
27930 };
27931
27932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27934 if (SWIG_arg_fail(1)) SWIG_fail;
27935 {
27936 PyThreadState* __tstate = wxPyBeginAllowThreads();
27937 result = (PyObject *)wxWindow_GetChildren(arg1);
27938
27939 wxPyEndAllowThreads(__tstate);
27940 if (PyErr_Occurred()) SWIG_fail;
27941 }
27942 resultobj = result;
27943 return resultobj;
27944 fail:
27945 return NULL;
27946 }
27947
27948
27949 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27950 PyObject *resultobj;
27951 wxWindow *arg1 = (wxWindow *) 0 ;
27952 wxWindow *result;
27953 PyObject * obj0 = 0 ;
27954 char *kwnames[] = {
27955 (char *) "self", NULL
27956 };
27957
27958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27960 if (SWIG_arg_fail(1)) SWIG_fail;
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27964
27965 wxPyEndAllowThreads(__tstate);
27966 if (PyErr_Occurred()) SWIG_fail;
27967 }
27968 {
27969 resultobj = wxPyMake_wxObject(result, 0);
27970 }
27971 return resultobj;
27972 fail:
27973 return NULL;
27974 }
27975
27976
27977 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27978 PyObject *resultobj;
27979 wxWindow *arg1 = (wxWindow *) 0 ;
27980 wxWindow *result;
27981 PyObject * obj0 = 0 ;
27982 char *kwnames[] = {
27983 (char *) "self", NULL
27984 };
27985
27986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27988 if (SWIG_arg_fail(1)) SWIG_fail;
27989 {
27990 PyThreadState* __tstate = wxPyBeginAllowThreads();
27991 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27992
27993 wxPyEndAllowThreads(__tstate);
27994 if (PyErr_Occurred()) SWIG_fail;
27995 }
27996 {
27997 resultobj = wxPyMake_wxObject(result, 0);
27998 }
27999 return resultobj;
28000 fail:
28001 return NULL;
28002 }
28003
28004
28005 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28006 PyObject *resultobj;
28007 wxWindow *arg1 = (wxWindow *) 0 ;
28008 bool result;
28009 PyObject * obj0 = 0 ;
28010 char *kwnames[] = {
28011 (char *) "self", NULL
28012 };
28013
28014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28016 if (SWIG_arg_fail(1)) SWIG_fail;
28017 {
28018 PyThreadState* __tstate = wxPyBeginAllowThreads();
28019 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28020
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 {
28025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28026 }
28027 return resultobj;
28028 fail:
28029 return NULL;
28030 }
28031
28032
28033 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28034 PyObject *resultobj;
28035 wxWindow *arg1 = (wxWindow *) 0 ;
28036 wxWindow *arg2 = (wxWindow *) 0 ;
28037 bool result;
28038 PyObject * obj0 = 0 ;
28039 PyObject * obj1 = 0 ;
28040 char *kwnames[] = {
28041 (char *) "self",(char *) "newParent", NULL
28042 };
28043
28044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28046 if (SWIG_arg_fail(1)) SWIG_fail;
28047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28048 if (SWIG_arg_fail(2)) SWIG_fail;
28049 {
28050 PyThreadState* __tstate = wxPyBeginAllowThreads();
28051 result = (bool)(arg1)->Reparent(arg2);
28052
28053 wxPyEndAllowThreads(__tstate);
28054 if (PyErr_Occurred()) SWIG_fail;
28055 }
28056 {
28057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28058 }
28059 return resultobj;
28060 fail:
28061 return NULL;
28062 }
28063
28064
28065 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28066 PyObject *resultobj;
28067 wxWindow *arg1 = (wxWindow *) 0 ;
28068 wxWindow *arg2 = (wxWindow *) 0 ;
28069 PyObject * obj0 = 0 ;
28070 PyObject * obj1 = 0 ;
28071 char *kwnames[] = {
28072 (char *) "self",(char *) "child", NULL
28073 };
28074
28075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28077 if (SWIG_arg_fail(1)) SWIG_fail;
28078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28079 if (SWIG_arg_fail(2)) SWIG_fail;
28080 {
28081 PyThreadState* __tstate = wxPyBeginAllowThreads();
28082 (arg1)->AddChild(arg2);
28083
28084 wxPyEndAllowThreads(__tstate);
28085 if (PyErr_Occurred()) SWIG_fail;
28086 }
28087 Py_INCREF(Py_None); resultobj = Py_None;
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28095 PyObject *resultobj;
28096 wxWindow *arg1 = (wxWindow *) 0 ;
28097 wxWindow *arg2 = (wxWindow *) 0 ;
28098 PyObject * obj0 = 0 ;
28099 PyObject * obj1 = 0 ;
28100 char *kwnames[] = {
28101 (char *) "self",(char *) "child", NULL
28102 };
28103
28104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28106 if (SWIG_arg_fail(1)) SWIG_fail;
28107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28108 if (SWIG_arg_fail(2)) SWIG_fail;
28109 {
28110 PyThreadState* __tstate = wxPyBeginAllowThreads();
28111 (arg1)->RemoveChild(arg2);
28112
28113 wxPyEndAllowThreads(__tstate);
28114 if (PyErr_Occurred()) SWIG_fail;
28115 }
28116 Py_INCREF(Py_None); resultobj = Py_None;
28117 return resultobj;
28118 fail:
28119 return NULL;
28120 }
28121
28122
28123 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28124 PyObject *resultobj;
28125 wxWindow *arg1 = (wxWindow *) 0 ;
28126 long arg2 ;
28127 wxWindow *result;
28128 PyObject * obj0 = 0 ;
28129 PyObject * obj1 = 0 ;
28130 char *kwnames[] = {
28131 (char *) "self",(char *) "winid", NULL
28132 };
28133
28134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28136 if (SWIG_arg_fail(1)) SWIG_fail;
28137 {
28138 arg2 = (long)(SWIG_As_long(obj1));
28139 if (SWIG_arg_fail(2)) SWIG_fail;
28140 }
28141 {
28142 PyThreadState* __tstate = wxPyBeginAllowThreads();
28143 result = (wxWindow *)(arg1)->FindWindow(arg2);
28144
28145 wxPyEndAllowThreads(__tstate);
28146 if (PyErr_Occurred()) SWIG_fail;
28147 }
28148 {
28149 resultobj = wxPyMake_wxObject(result, 0);
28150 }
28151 return resultobj;
28152 fail:
28153 return NULL;
28154 }
28155
28156
28157 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28158 PyObject *resultobj;
28159 wxWindow *arg1 = (wxWindow *) 0 ;
28160 wxString *arg2 = 0 ;
28161 wxWindow *result;
28162 bool temp2 = false ;
28163 PyObject * obj0 = 0 ;
28164 PyObject * obj1 = 0 ;
28165 char *kwnames[] = {
28166 (char *) "self",(char *) "name", NULL
28167 };
28168
28169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28171 if (SWIG_arg_fail(1)) SWIG_fail;
28172 {
28173 arg2 = wxString_in_helper(obj1);
28174 if (arg2 == NULL) SWIG_fail;
28175 temp2 = true;
28176 }
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28180
28181 wxPyEndAllowThreads(__tstate);
28182 if (PyErr_Occurred()) SWIG_fail;
28183 }
28184 {
28185 resultobj = wxPyMake_wxObject(result, 0);
28186 }
28187 {
28188 if (temp2)
28189 delete arg2;
28190 }
28191 return resultobj;
28192 fail:
28193 {
28194 if (temp2)
28195 delete arg2;
28196 }
28197 return NULL;
28198 }
28199
28200
28201 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28202 PyObject *resultobj;
28203 wxWindow *arg1 = (wxWindow *) 0 ;
28204 wxEvtHandler *result;
28205 PyObject * obj0 = 0 ;
28206 char *kwnames[] = {
28207 (char *) "self", NULL
28208 };
28209
28210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28212 if (SWIG_arg_fail(1)) SWIG_fail;
28213 {
28214 PyThreadState* __tstate = wxPyBeginAllowThreads();
28215 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28216
28217 wxPyEndAllowThreads(__tstate);
28218 if (PyErr_Occurred()) SWIG_fail;
28219 }
28220 {
28221 resultobj = wxPyMake_wxObject(result, 0);
28222 }
28223 return resultobj;
28224 fail:
28225 return NULL;
28226 }
28227
28228
28229 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28230 PyObject *resultobj;
28231 wxWindow *arg1 = (wxWindow *) 0 ;
28232 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28233 PyObject * obj0 = 0 ;
28234 PyObject * obj1 = 0 ;
28235 char *kwnames[] = {
28236 (char *) "self",(char *) "handler", NULL
28237 };
28238
28239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28241 if (SWIG_arg_fail(1)) SWIG_fail;
28242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28243 if (SWIG_arg_fail(2)) SWIG_fail;
28244 {
28245 PyThreadState* __tstate = wxPyBeginAllowThreads();
28246 (arg1)->SetEventHandler(arg2);
28247
28248 wxPyEndAllowThreads(__tstate);
28249 if (PyErr_Occurred()) SWIG_fail;
28250 }
28251 Py_INCREF(Py_None); resultobj = Py_None;
28252 return resultobj;
28253 fail:
28254 return NULL;
28255 }
28256
28257
28258 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28259 PyObject *resultobj;
28260 wxWindow *arg1 = (wxWindow *) 0 ;
28261 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28262 PyObject * obj0 = 0 ;
28263 PyObject * obj1 = 0 ;
28264 char *kwnames[] = {
28265 (char *) "self",(char *) "handler", NULL
28266 };
28267
28268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28270 if (SWIG_arg_fail(1)) SWIG_fail;
28271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28272 if (SWIG_arg_fail(2)) SWIG_fail;
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 (arg1)->PushEventHandler(arg2);
28276
28277 wxPyEndAllowThreads(__tstate);
28278 if (PyErr_Occurred()) SWIG_fail;
28279 }
28280 Py_INCREF(Py_None); resultobj = Py_None;
28281 return resultobj;
28282 fail:
28283 return NULL;
28284 }
28285
28286
28287 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28288 PyObject *resultobj;
28289 wxWindow *arg1 = (wxWindow *) 0 ;
28290 bool arg2 = (bool) false ;
28291 wxEvtHandler *result;
28292 PyObject * obj0 = 0 ;
28293 PyObject * obj1 = 0 ;
28294 char *kwnames[] = {
28295 (char *) "self",(char *) "deleteHandler", NULL
28296 };
28297
28298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28300 if (SWIG_arg_fail(1)) SWIG_fail;
28301 if (obj1) {
28302 {
28303 arg2 = (bool)(SWIG_As_bool(obj1));
28304 if (SWIG_arg_fail(2)) SWIG_fail;
28305 }
28306 }
28307 {
28308 PyThreadState* __tstate = wxPyBeginAllowThreads();
28309 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28310
28311 wxPyEndAllowThreads(__tstate);
28312 if (PyErr_Occurred()) SWIG_fail;
28313 }
28314 {
28315 resultobj = wxPyMake_wxObject(result, 0);
28316 }
28317 return resultobj;
28318 fail:
28319 return NULL;
28320 }
28321
28322
28323 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28324 PyObject *resultobj;
28325 wxWindow *arg1 = (wxWindow *) 0 ;
28326 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28327 bool result;
28328 PyObject * obj0 = 0 ;
28329 PyObject * obj1 = 0 ;
28330 char *kwnames[] = {
28331 (char *) "self",(char *) "handler", NULL
28332 };
28333
28334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28336 if (SWIG_arg_fail(1)) SWIG_fail;
28337 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28338 if (SWIG_arg_fail(2)) SWIG_fail;
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 result = (bool)(arg1)->RemoveEventHandler(arg2);
28342
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 {
28347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28348 }
28349 return resultobj;
28350 fail:
28351 return NULL;
28352 }
28353
28354
28355 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28356 PyObject *resultobj;
28357 wxWindow *arg1 = (wxWindow *) 0 ;
28358 wxValidator *arg2 = 0 ;
28359 PyObject * obj0 = 0 ;
28360 PyObject * obj1 = 0 ;
28361 char *kwnames[] = {
28362 (char *) "self",(char *) "validator", NULL
28363 };
28364
28365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28367 if (SWIG_arg_fail(1)) SWIG_fail;
28368 {
28369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28370 if (SWIG_arg_fail(2)) SWIG_fail;
28371 if (arg2 == NULL) {
28372 SWIG_null_ref("wxValidator");
28373 }
28374 if (SWIG_arg_fail(2)) SWIG_fail;
28375 }
28376 {
28377 PyThreadState* __tstate = wxPyBeginAllowThreads();
28378 (arg1)->SetValidator((wxValidator const &)*arg2);
28379
28380 wxPyEndAllowThreads(__tstate);
28381 if (PyErr_Occurred()) SWIG_fail;
28382 }
28383 Py_INCREF(Py_None); resultobj = Py_None;
28384 return resultobj;
28385 fail:
28386 return NULL;
28387 }
28388
28389
28390 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28391 PyObject *resultobj;
28392 wxWindow *arg1 = (wxWindow *) 0 ;
28393 wxValidator *result;
28394 PyObject * obj0 = 0 ;
28395 char *kwnames[] = {
28396 (char *) "self", NULL
28397 };
28398
28399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28401 if (SWIG_arg_fail(1)) SWIG_fail;
28402 {
28403 PyThreadState* __tstate = wxPyBeginAllowThreads();
28404 result = (wxValidator *)(arg1)->GetValidator();
28405
28406 wxPyEndAllowThreads(__tstate);
28407 if (PyErr_Occurred()) SWIG_fail;
28408 }
28409 {
28410 resultobj = wxPyMake_wxObject(result, 0);
28411 }
28412 return resultobj;
28413 fail:
28414 return NULL;
28415 }
28416
28417
28418 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28419 PyObject *resultobj;
28420 wxWindow *arg1 = (wxWindow *) 0 ;
28421 bool result;
28422 PyObject * obj0 = 0 ;
28423 char *kwnames[] = {
28424 (char *) "self", NULL
28425 };
28426
28427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28429 if (SWIG_arg_fail(1)) SWIG_fail;
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 result = (bool)(arg1)->Validate();
28433
28434 wxPyEndAllowThreads(__tstate);
28435 if (PyErr_Occurred()) SWIG_fail;
28436 }
28437 {
28438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28439 }
28440 return resultobj;
28441 fail:
28442 return NULL;
28443 }
28444
28445
28446 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28447 PyObject *resultobj;
28448 wxWindow *arg1 = (wxWindow *) 0 ;
28449 bool result;
28450 PyObject * obj0 = 0 ;
28451 char *kwnames[] = {
28452 (char *) "self", NULL
28453 };
28454
28455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28457 if (SWIG_arg_fail(1)) SWIG_fail;
28458 {
28459 PyThreadState* __tstate = wxPyBeginAllowThreads();
28460 result = (bool)(arg1)->TransferDataToWindow();
28461
28462 wxPyEndAllowThreads(__tstate);
28463 if (PyErr_Occurred()) SWIG_fail;
28464 }
28465 {
28466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28467 }
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28475 PyObject *resultobj;
28476 wxWindow *arg1 = (wxWindow *) 0 ;
28477 bool result;
28478 PyObject * obj0 = 0 ;
28479 char *kwnames[] = {
28480 (char *) "self", NULL
28481 };
28482
28483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28485 if (SWIG_arg_fail(1)) SWIG_fail;
28486 {
28487 PyThreadState* __tstate = wxPyBeginAllowThreads();
28488 result = (bool)(arg1)->TransferDataFromWindow();
28489
28490 wxPyEndAllowThreads(__tstate);
28491 if (PyErr_Occurred()) SWIG_fail;
28492 }
28493 {
28494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28495 }
28496 return resultobj;
28497 fail:
28498 return NULL;
28499 }
28500
28501
28502 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28503 PyObject *resultobj;
28504 wxWindow *arg1 = (wxWindow *) 0 ;
28505 PyObject * obj0 = 0 ;
28506 char *kwnames[] = {
28507 (char *) "self", NULL
28508 };
28509
28510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28512 if (SWIG_arg_fail(1)) SWIG_fail;
28513 {
28514 PyThreadState* __tstate = wxPyBeginAllowThreads();
28515 (arg1)->InitDialog();
28516
28517 wxPyEndAllowThreads(__tstate);
28518 if (PyErr_Occurred()) SWIG_fail;
28519 }
28520 Py_INCREF(Py_None); resultobj = Py_None;
28521 return resultobj;
28522 fail:
28523 return NULL;
28524 }
28525
28526
28527 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28528 PyObject *resultobj;
28529 wxWindow *arg1 = (wxWindow *) 0 ;
28530 wxAcceleratorTable *arg2 = 0 ;
28531 PyObject * obj0 = 0 ;
28532 PyObject * obj1 = 0 ;
28533 char *kwnames[] = {
28534 (char *) "self",(char *) "accel", NULL
28535 };
28536
28537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28539 if (SWIG_arg_fail(1)) SWIG_fail;
28540 {
28541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28542 if (SWIG_arg_fail(2)) SWIG_fail;
28543 if (arg2 == NULL) {
28544 SWIG_null_ref("wxAcceleratorTable");
28545 }
28546 if (SWIG_arg_fail(2)) SWIG_fail;
28547 }
28548 {
28549 PyThreadState* __tstate = wxPyBeginAllowThreads();
28550 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28551
28552 wxPyEndAllowThreads(__tstate);
28553 if (PyErr_Occurred()) SWIG_fail;
28554 }
28555 Py_INCREF(Py_None); resultobj = Py_None;
28556 return resultobj;
28557 fail:
28558 return NULL;
28559 }
28560
28561
28562 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28563 PyObject *resultobj;
28564 wxWindow *arg1 = (wxWindow *) 0 ;
28565 wxAcceleratorTable *result;
28566 PyObject * obj0 = 0 ;
28567 char *kwnames[] = {
28568 (char *) "self", NULL
28569 };
28570
28571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28573 if (SWIG_arg_fail(1)) SWIG_fail;
28574 {
28575 PyThreadState* __tstate = wxPyBeginAllowThreads();
28576 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28577
28578 wxPyEndAllowThreads(__tstate);
28579 if (PyErr_Occurred()) SWIG_fail;
28580 }
28581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28582 return resultobj;
28583 fail:
28584 return NULL;
28585 }
28586
28587
28588 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28589 PyObject *resultobj;
28590 wxWindow *arg1 = (wxWindow *) 0 ;
28591 int arg2 ;
28592 int arg3 ;
28593 int arg4 ;
28594 bool result;
28595 PyObject * obj0 = 0 ;
28596 PyObject * obj1 = 0 ;
28597 PyObject * obj2 = 0 ;
28598 PyObject * obj3 = 0 ;
28599 char *kwnames[] = {
28600 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28601 };
28602
28603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28605 if (SWIG_arg_fail(1)) SWIG_fail;
28606 {
28607 arg2 = (int)(SWIG_As_int(obj1));
28608 if (SWIG_arg_fail(2)) SWIG_fail;
28609 }
28610 {
28611 arg3 = (int)(SWIG_As_int(obj2));
28612 if (SWIG_arg_fail(3)) SWIG_fail;
28613 }
28614 {
28615 arg4 = (int)(SWIG_As_int(obj3));
28616 if (SWIG_arg_fail(4)) SWIG_fail;
28617 }
28618 {
28619 PyThreadState* __tstate = wxPyBeginAllowThreads();
28620 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28621
28622 wxPyEndAllowThreads(__tstate);
28623 if (PyErr_Occurred()) SWIG_fail;
28624 }
28625 {
28626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28627 }
28628 return resultobj;
28629 fail:
28630 return NULL;
28631 }
28632
28633
28634 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28635 PyObject *resultobj;
28636 wxWindow *arg1 = (wxWindow *) 0 ;
28637 int arg2 ;
28638 bool result;
28639 PyObject * obj0 = 0 ;
28640 PyObject * obj1 = 0 ;
28641 char *kwnames[] = {
28642 (char *) "self",(char *) "hotkeyId", NULL
28643 };
28644
28645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28647 if (SWIG_arg_fail(1)) SWIG_fail;
28648 {
28649 arg2 = (int)(SWIG_As_int(obj1));
28650 if (SWIG_arg_fail(2)) SWIG_fail;
28651 }
28652 {
28653 PyThreadState* __tstate = wxPyBeginAllowThreads();
28654 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28655
28656 wxPyEndAllowThreads(__tstate);
28657 if (PyErr_Occurred()) SWIG_fail;
28658 }
28659 {
28660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28661 }
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28669 PyObject *resultobj;
28670 wxWindow *arg1 = (wxWindow *) 0 ;
28671 wxPoint *arg2 = 0 ;
28672 wxPoint result;
28673 wxPoint temp2 ;
28674 PyObject * obj0 = 0 ;
28675 PyObject * obj1 = 0 ;
28676 char *kwnames[] = {
28677 (char *) "self",(char *) "pt", NULL
28678 };
28679
28680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28682 if (SWIG_arg_fail(1)) SWIG_fail;
28683 {
28684 arg2 = &temp2;
28685 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28686 }
28687 {
28688 PyThreadState* __tstate = wxPyBeginAllowThreads();
28689 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28690
28691 wxPyEndAllowThreads(__tstate);
28692 if (PyErr_Occurred()) SWIG_fail;
28693 }
28694 {
28695 wxPoint * resultptr;
28696 resultptr = new wxPoint((wxPoint &)(result));
28697 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28698 }
28699 return resultobj;
28700 fail:
28701 return NULL;
28702 }
28703
28704
28705 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28706 PyObject *resultobj;
28707 wxWindow *arg1 = (wxWindow *) 0 ;
28708 wxSize *arg2 = 0 ;
28709 wxSize result;
28710 wxSize temp2 ;
28711 PyObject * obj0 = 0 ;
28712 PyObject * obj1 = 0 ;
28713 char *kwnames[] = {
28714 (char *) "self",(char *) "sz", NULL
28715 };
28716
28717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28719 if (SWIG_arg_fail(1)) SWIG_fail;
28720 {
28721 arg2 = &temp2;
28722 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28723 }
28724 {
28725 PyThreadState* __tstate = wxPyBeginAllowThreads();
28726 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28727
28728 wxPyEndAllowThreads(__tstate);
28729 if (PyErr_Occurred()) SWIG_fail;
28730 }
28731 {
28732 wxSize * resultptr;
28733 resultptr = new wxSize((wxSize &)(result));
28734 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28735 }
28736 return resultobj;
28737 fail:
28738 return NULL;
28739 }
28740
28741
28742 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28743 PyObject *resultobj;
28744 wxWindow *arg1 = (wxWindow *) 0 ;
28745 wxPoint *arg2 = 0 ;
28746 wxPoint result;
28747 wxPoint temp2 ;
28748 PyObject * obj0 = 0 ;
28749 PyObject * obj1 = 0 ;
28750 char *kwnames[] = {
28751 (char *) "self",(char *) "pt", NULL
28752 };
28753
28754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28756 if (SWIG_arg_fail(1)) SWIG_fail;
28757 {
28758 arg2 = &temp2;
28759 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28760 }
28761 {
28762 PyThreadState* __tstate = wxPyBeginAllowThreads();
28763 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28764
28765 wxPyEndAllowThreads(__tstate);
28766 if (PyErr_Occurred()) SWIG_fail;
28767 }
28768 {
28769 wxPoint * resultptr;
28770 resultptr = new wxPoint((wxPoint &)(result));
28771 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28772 }
28773 return resultobj;
28774 fail:
28775 return NULL;
28776 }
28777
28778
28779 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28780 PyObject *resultobj;
28781 wxWindow *arg1 = (wxWindow *) 0 ;
28782 wxSize *arg2 = 0 ;
28783 wxSize result;
28784 wxSize temp2 ;
28785 PyObject * obj0 = 0 ;
28786 PyObject * obj1 = 0 ;
28787 char *kwnames[] = {
28788 (char *) "self",(char *) "sz", NULL
28789 };
28790
28791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28793 if (SWIG_arg_fail(1)) SWIG_fail;
28794 {
28795 arg2 = &temp2;
28796 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28797 }
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28801
28802 wxPyEndAllowThreads(__tstate);
28803 if (PyErr_Occurred()) SWIG_fail;
28804 }
28805 {
28806 wxSize * resultptr;
28807 resultptr = new wxSize((wxSize &)(result));
28808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28809 }
28810 return resultobj;
28811 fail:
28812 return NULL;
28813 }
28814
28815
28816 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28817 PyObject *resultobj;
28818 wxWindow *arg1 = (wxWindow *) 0 ;
28819 wxPoint *arg2 = 0 ;
28820 wxPoint result;
28821 wxPoint temp2 ;
28822 PyObject * obj0 = 0 ;
28823 PyObject * obj1 = 0 ;
28824 char *kwnames[] = {
28825 (char *) "self",(char *) "pt", NULL
28826 };
28827
28828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28830 if (SWIG_arg_fail(1)) SWIG_fail;
28831 {
28832 arg2 = &temp2;
28833 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28834 }
28835 {
28836 PyThreadState* __tstate = wxPyBeginAllowThreads();
28837 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28838
28839 wxPyEndAllowThreads(__tstate);
28840 if (PyErr_Occurred()) SWIG_fail;
28841 }
28842 {
28843 wxPoint * resultptr;
28844 resultptr = new wxPoint((wxPoint &)(result));
28845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28846 }
28847 return resultobj;
28848 fail:
28849 return NULL;
28850 }
28851
28852
28853 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28854 PyObject *resultobj;
28855 wxWindow *arg1 = (wxWindow *) 0 ;
28856 wxSize *arg2 = 0 ;
28857 wxSize result;
28858 wxSize temp2 ;
28859 PyObject * obj0 = 0 ;
28860 PyObject * obj1 = 0 ;
28861 char *kwnames[] = {
28862 (char *) "self",(char *) "sz", NULL
28863 };
28864
28865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28867 if (SWIG_arg_fail(1)) SWIG_fail;
28868 {
28869 arg2 = &temp2;
28870 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28871 }
28872 {
28873 PyThreadState* __tstate = wxPyBeginAllowThreads();
28874 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28875
28876 wxPyEndAllowThreads(__tstate);
28877 if (PyErr_Occurred()) SWIG_fail;
28878 }
28879 {
28880 wxSize * resultptr;
28881 resultptr = new wxSize((wxSize &)(result));
28882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28883 }
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28891 PyObject *resultobj;
28892 wxWindow *arg1 = (wxWindow *) 0 ;
28893 int arg2 ;
28894 int arg3 ;
28895 PyObject * obj0 = 0 ;
28896 PyObject * obj1 = 0 ;
28897 PyObject * obj2 = 0 ;
28898 char *kwnames[] = {
28899 (char *) "self",(char *) "x",(char *) "y", NULL
28900 };
28901
28902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28904 if (SWIG_arg_fail(1)) SWIG_fail;
28905 {
28906 arg2 = (int)(SWIG_As_int(obj1));
28907 if (SWIG_arg_fail(2)) SWIG_fail;
28908 }
28909 {
28910 arg3 = (int)(SWIG_As_int(obj2));
28911 if (SWIG_arg_fail(3)) SWIG_fail;
28912 }
28913 {
28914 PyThreadState* __tstate = wxPyBeginAllowThreads();
28915 (arg1)->WarpPointer(arg2,arg3);
28916
28917 wxPyEndAllowThreads(__tstate);
28918 if (PyErr_Occurred()) SWIG_fail;
28919 }
28920 Py_INCREF(Py_None); resultobj = Py_None;
28921 return resultobj;
28922 fail:
28923 return NULL;
28924 }
28925
28926
28927 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28928 PyObject *resultobj;
28929 wxWindow *arg1 = (wxWindow *) 0 ;
28930 PyObject * obj0 = 0 ;
28931 char *kwnames[] = {
28932 (char *) "self", NULL
28933 };
28934
28935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28937 if (SWIG_arg_fail(1)) SWIG_fail;
28938 {
28939 PyThreadState* __tstate = wxPyBeginAllowThreads();
28940 (arg1)->CaptureMouse();
28941
28942 wxPyEndAllowThreads(__tstate);
28943 if (PyErr_Occurred()) SWIG_fail;
28944 }
28945 Py_INCREF(Py_None); resultobj = Py_None;
28946 return resultobj;
28947 fail:
28948 return NULL;
28949 }
28950
28951
28952 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28953 PyObject *resultobj;
28954 wxWindow *arg1 = (wxWindow *) 0 ;
28955 PyObject * obj0 = 0 ;
28956 char *kwnames[] = {
28957 (char *) "self", NULL
28958 };
28959
28960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28962 if (SWIG_arg_fail(1)) SWIG_fail;
28963 {
28964 PyThreadState* __tstate = wxPyBeginAllowThreads();
28965 (arg1)->ReleaseMouse();
28966
28967 wxPyEndAllowThreads(__tstate);
28968 if (PyErr_Occurred()) SWIG_fail;
28969 }
28970 Py_INCREF(Py_None); resultobj = Py_None;
28971 return resultobj;
28972 fail:
28973 return NULL;
28974 }
28975
28976
28977 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28978 PyObject *resultobj;
28979 wxWindow *result;
28980 char *kwnames[] = {
28981 NULL
28982 };
28983
28984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28985 {
28986 if (!wxPyCheckForApp()) SWIG_fail;
28987 PyThreadState* __tstate = wxPyBeginAllowThreads();
28988 result = (wxWindow *)wxWindow::GetCapture();
28989
28990 wxPyEndAllowThreads(__tstate);
28991 if (PyErr_Occurred()) SWIG_fail;
28992 }
28993 {
28994 resultobj = wxPyMake_wxObject(result, 0);
28995 }
28996 return resultobj;
28997 fail:
28998 return NULL;
28999 }
29000
29001
29002 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29003 PyObject *resultobj;
29004 wxWindow *arg1 = (wxWindow *) 0 ;
29005 bool result;
29006 PyObject * obj0 = 0 ;
29007 char *kwnames[] = {
29008 (char *) "self", NULL
29009 };
29010
29011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29013 if (SWIG_arg_fail(1)) SWIG_fail;
29014 {
29015 PyThreadState* __tstate = wxPyBeginAllowThreads();
29016 result = (bool)((wxWindow const *)arg1)->HasCapture();
29017
29018 wxPyEndAllowThreads(__tstate);
29019 if (PyErr_Occurred()) SWIG_fail;
29020 }
29021 {
29022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29023 }
29024 return resultobj;
29025 fail:
29026 return NULL;
29027 }
29028
29029
29030 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29031 PyObject *resultobj;
29032 wxWindow *arg1 = (wxWindow *) 0 ;
29033 bool arg2 = (bool) true ;
29034 wxRect *arg3 = (wxRect *) NULL ;
29035 PyObject * obj0 = 0 ;
29036 PyObject * obj1 = 0 ;
29037 PyObject * obj2 = 0 ;
29038 char *kwnames[] = {
29039 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29040 };
29041
29042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29044 if (SWIG_arg_fail(1)) SWIG_fail;
29045 if (obj1) {
29046 {
29047 arg2 = (bool)(SWIG_As_bool(obj1));
29048 if (SWIG_arg_fail(2)) SWIG_fail;
29049 }
29050 }
29051 if (obj2) {
29052 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29053 if (SWIG_arg_fail(3)) SWIG_fail;
29054 }
29055 {
29056 PyThreadState* __tstate = wxPyBeginAllowThreads();
29057 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29058
29059 wxPyEndAllowThreads(__tstate);
29060 if (PyErr_Occurred()) SWIG_fail;
29061 }
29062 Py_INCREF(Py_None); resultobj = Py_None;
29063 return resultobj;
29064 fail:
29065 return NULL;
29066 }
29067
29068
29069 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29070 PyObject *resultobj;
29071 wxWindow *arg1 = (wxWindow *) 0 ;
29072 wxRect *arg2 = 0 ;
29073 bool arg3 = (bool) true ;
29074 wxRect temp2 ;
29075 PyObject * obj0 = 0 ;
29076 PyObject * obj1 = 0 ;
29077 PyObject * obj2 = 0 ;
29078 char *kwnames[] = {
29079 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29080 };
29081
29082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29084 if (SWIG_arg_fail(1)) SWIG_fail;
29085 {
29086 arg2 = &temp2;
29087 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29088 }
29089 if (obj2) {
29090 {
29091 arg3 = (bool)(SWIG_As_bool(obj2));
29092 if (SWIG_arg_fail(3)) SWIG_fail;
29093 }
29094 }
29095 {
29096 PyThreadState* __tstate = wxPyBeginAllowThreads();
29097 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29098
29099 wxPyEndAllowThreads(__tstate);
29100 if (PyErr_Occurred()) SWIG_fail;
29101 }
29102 Py_INCREF(Py_None); resultobj = Py_None;
29103 return resultobj;
29104 fail:
29105 return NULL;
29106 }
29107
29108
29109 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29110 PyObject *resultobj;
29111 wxWindow *arg1 = (wxWindow *) 0 ;
29112 PyObject * obj0 = 0 ;
29113 char *kwnames[] = {
29114 (char *) "self", NULL
29115 };
29116
29117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29119 if (SWIG_arg_fail(1)) SWIG_fail;
29120 {
29121 PyThreadState* __tstate = wxPyBeginAllowThreads();
29122 (arg1)->Update();
29123
29124 wxPyEndAllowThreads(__tstate);
29125 if (PyErr_Occurred()) SWIG_fail;
29126 }
29127 Py_INCREF(Py_None); resultobj = Py_None;
29128 return resultobj;
29129 fail:
29130 return NULL;
29131 }
29132
29133
29134 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29135 PyObject *resultobj;
29136 wxWindow *arg1 = (wxWindow *) 0 ;
29137 PyObject * obj0 = 0 ;
29138 char *kwnames[] = {
29139 (char *) "self", NULL
29140 };
29141
29142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29144 if (SWIG_arg_fail(1)) SWIG_fail;
29145 {
29146 PyThreadState* __tstate = wxPyBeginAllowThreads();
29147 (arg1)->ClearBackground();
29148
29149 wxPyEndAllowThreads(__tstate);
29150 if (PyErr_Occurred()) SWIG_fail;
29151 }
29152 Py_INCREF(Py_None); resultobj = Py_None;
29153 return resultobj;
29154 fail:
29155 return NULL;
29156 }
29157
29158
29159 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29160 PyObject *resultobj;
29161 wxWindow *arg1 = (wxWindow *) 0 ;
29162 PyObject * obj0 = 0 ;
29163 char *kwnames[] = {
29164 (char *) "self", NULL
29165 };
29166
29167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29169 if (SWIG_arg_fail(1)) SWIG_fail;
29170 {
29171 PyThreadState* __tstate = wxPyBeginAllowThreads();
29172 (arg1)->Freeze();
29173
29174 wxPyEndAllowThreads(__tstate);
29175 if (PyErr_Occurred()) SWIG_fail;
29176 }
29177 Py_INCREF(Py_None); resultobj = Py_None;
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29185 PyObject *resultobj;
29186 wxWindow *arg1 = (wxWindow *) 0 ;
29187 PyObject * obj0 = 0 ;
29188 char *kwnames[] = {
29189 (char *) "self", NULL
29190 };
29191
29192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29194 if (SWIG_arg_fail(1)) SWIG_fail;
29195 {
29196 PyThreadState* __tstate = wxPyBeginAllowThreads();
29197 (arg1)->Thaw();
29198
29199 wxPyEndAllowThreads(__tstate);
29200 if (PyErr_Occurred()) SWIG_fail;
29201 }
29202 Py_INCREF(Py_None); resultobj = Py_None;
29203 return resultobj;
29204 fail:
29205 return NULL;
29206 }
29207
29208
29209 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29210 PyObject *resultobj;
29211 wxWindow *arg1 = (wxWindow *) 0 ;
29212 wxDC *arg2 = 0 ;
29213 PyObject * obj0 = 0 ;
29214 PyObject * obj1 = 0 ;
29215 char *kwnames[] = {
29216 (char *) "self",(char *) "dc", NULL
29217 };
29218
29219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29221 if (SWIG_arg_fail(1)) SWIG_fail;
29222 {
29223 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29224 if (SWIG_arg_fail(2)) SWIG_fail;
29225 if (arg2 == NULL) {
29226 SWIG_null_ref("wxDC");
29227 }
29228 if (SWIG_arg_fail(2)) SWIG_fail;
29229 }
29230 {
29231 PyThreadState* __tstate = wxPyBeginAllowThreads();
29232 (arg1)->PrepareDC(*arg2);
29233
29234 wxPyEndAllowThreads(__tstate);
29235 if (PyErr_Occurred()) SWIG_fail;
29236 }
29237 Py_INCREF(Py_None); resultobj = Py_None;
29238 return resultobj;
29239 fail:
29240 return NULL;
29241 }
29242
29243
29244 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29245 PyObject *resultobj;
29246 wxWindow *arg1 = (wxWindow *) 0 ;
29247 wxRegion *result;
29248 PyObject * obj0 = 0 ;
29249 char *kwnames[] = {
29250 (char *) "self", NULL
29251 };
29252
29253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29255 if (SWIG_arg_fail(1)) SWIG_fail;
29256 {
29257 PyThreadState* __tstate = wxPyBeginAllowThreads();
29258 {
29259 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29260 result = (wxRegion *) &_result_ref;
29261 }
29262
29263 wxPyEndAllowThreads(__tstate);
29264 if (PyErr_Occurred()) SWIG_fail;
29265 }
29266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29267 return resultobj;
29268 fail:
29269 return NULL;
29270 }
29271
29272
29273 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29274 PyObject *resultobj;
29275 wxWindow *arg1 = (wxWindow *) 0 ;
29276 wxRect result;
29277 PyObject * obj0 = 0 ;
29278 char *kwnames[] = {
29279 (char *) "self", NULL
29280 };
29281
29282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29284 if (SWIG_arg_fail(1)) SWIG_fail;
29285 {
29286 PyThreadState* __tstate = wxPyBeginAllowThreads();
29287 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29288
29289 wxPyEndAllowThreads(__tstate);
29290 if (PyErr_Occurred()) SWIG_fail;
29291 }
29292 {
29293 wxRect * resultptr;
29294 resultptr = new wxRect((wxRect &)(result));
29295 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29296 }
29297 return resultobj;
29298 fail:
29299 return NULL;
29300 }
29301
29302
29303 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29304 PyObject *resultobj;
29305 wxWindow *arg1 = (wxWindow *) 0 ;
29306 int arg2 ;
29307 int arg3 ;
29308 int arg4 = (int) 1 ;
29309 int arg5 = (int) 1 ;
29310 bool result;
29311 PyObject * obj0 = 0 ;
29312 PyObject * obj1 = 0 ;
29313 PyObject * obj2 = 0 ;
29314 PyObject * obj3 = 0 ;
29315 PyObject * obj4 = 0 ;
29316 char *kwnames[] = {
29317 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29318 };
29319
29320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29322 if (SWIG_arg_fail(1)) SWIG_fail;
29323 {
29324 arg2 = (int)(SWIG_As_int(obj1));
29325 if (SWIG_arg_fail(2)) SWIG_fail;
29326 }
29327 {
29328 arg3 = (int)(SWIG_As_int(obj2));
29329 if (SWIG_arg_fail(3)) SWIG_fail;
29330 }
29331 if (obj3) {
29332 {
29333 arg4 = (int)(SWIG_As_int(obj3));
29334 if (SWIG_arg_fail(4)) SWIG_fail;
29335 }
29336 }
29337 if (obj4) {
29338 {
29339 arg5 = (int)(SWIG_As_int(obj4));
29340 if (SWIG_arg_fail(5)) SWIG_fail;
29341 }
29342 }
29343 {
29344 PyThreadState* __tstate = wxPyBeginAllowThreads();
29345 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29346
29347 wxPyEndAllowThreads(__tstate);
29348 if (PyErr_Occurred()) SWIG_fail;
29349 }
29350 {
29351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29352 }
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29360 PyObject *resultobj;
29361 wxWindow *arg1 = (wxWindow *) 0 ;
29362 wxPoint *arg2 = 0 ;
29363 bool result;
29364 wxPoint temp2 ;
29365 PyObject * obj0 = 0 ;
29366 PyObject * obj1 = 0 ;
29367 char *kwnames[] = {
29368 (char *) "self",(char *) "pt", NULL
29369 };
29370
29371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",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 ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29377 }
29378 {
29379 PyThreadState* __tstate = wxPyBeginAllowThreads();
29380 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29381
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 {
29386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29387 }
29388 return resultobj;
29389 fail:
29390 return NULL;
29391 }
29392
29393
29394 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29395 PyObject *resultobj;
29396 wxWindow *arg1 = (wxWindow *) 0 ;
29397 wxRect *arg2 = 0 ;
29398 bool result;
29399 wxRect temp2 ;
29400 PyObject * obj0 = 0 ;
29401 PyObject * obj1 = 0 ;
29402 char *kwnames[] = {
29403 (char *) "self",(char *) "rect", NULL
29404 };
29405
29406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29408 if (SWIG_arg_fail(1)) SWIG_fail;
29409 {
29410 arg2 = &temp2;
29411 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29412 }
29413 {
29414 PyThreadState* __tstate = wxPyBeginAllowThreads();
29415 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29416
29417 wxPyEndAllowThreads(__tstate);
29418 if (PyErr_Occurred()) SWIG_fail;
29419 }
29420 {
29421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29422 }
29423 return resultobj;
29424 fail:
29425 return NULL;
29426 }
29427
29428
29429 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29430 PyObject *resultobj;
29431 wxWindow *arg1 = (wxWindow *) 0 ;
29432 wxVisualAttributes result;
29433 PyObject * obj0 = 0 ;
29434 char *kwnames[] = {
29435 (char *) "self", NULL
29436 };
29437
29438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29440 if (SWIG_arg_fail(1)) SWIG_fail;
29441 {
29442 PyThreadState* __tstate = wxPyBeginAllowThreads();
29443 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29444
29445 wxPyEndAllowThreads(__tstate);
29446 if (PyErr_Occurred()) SWIG_fail;
29447 }
29448 {
29449 wxVisualAttributes * resultptr;
29450 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29451 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29452 }
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29460 PyObject *resultobj;
29461 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29462 wxVisualAttributes result;
29463 PyObject * obj0 = 0 ;
29464 char *kwnames[] = {
29465 (char *) "variant", NULL
29466 };
29467
29468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29469 if (obj0) {
29470 {
29471 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29472 if (SWIG_arg_fail(1)) SWIG_fail;
29473 }
29474 }
29475 {
29476 if (!wxPyCheckForApp()) SWIG_fail;
29477 PyThreadState* __tstate = wxPyBeginAllowThreads();
29478 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29479
29480 wxPyEndAllowThreads(__tstate);
29481 if (PyErr_Occurred()) SWIG_fail;
29482 }
29483 {
29484 wxVisualAttributes * resultptr;
29485 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29486 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29487 }
29488 return resultobj;
29489 fail:
29490 return NULL;
29491 }
29492
29493
29494 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29495 PyObject *resultobj;
29496 wxWindow *arg1 = (wxWindow *) 0 ;
29497 wxColour *arg2 = 0 ;
29498 bool result;
29499 wxColour temp2 ;
29500 PyObject * obj0 = 0 ;
29501 PyObject * obj1 = 0 ;
29502 char *kwnames[] = {
29503 (char *) "self",(char *) "colour", NULL
29504 };
29505
29506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29508 if (SWIG_arg_fail(1)) SWIG_fail;
29509 {
29510 arg2 = &temp2;
29511 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29512 }
29513 {
29514 PyThreadState* __tstate = wxPyBeginAllowThreads();
29515 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29516
29517 wxPyEndAllowThreads(__tstate);
29518 if (PyErr_Occurred()) SWIG_fail;
29519 }
29520 {
29521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29522 }
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29530 PyObject *resultobj;
29531 wxWindow *arg1 = (wxWindow *) 0 ;
29532 wxColour *arg2 = 0 ;
29533 wxColour temp2 ;
29534 PyObject * obj0 = 0 ;
29535 PyObject * obj1 = 0 ;
29536 char *kwnames[] = {
29537 (char *) "self",(char *) "colour", NULL
29538 };
29539
29540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29542 if (SWIG_arg_fail(1)) SWIG_fail;
29543 {
29544 arg2 = &temp2;
29545 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29546 }
29547 {
29548 PyThreadState* __tstate = wxPyBeginAllowThreads();
29549 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29550
29551 wxPyEndAllowThreads(__tstate);
29552 if (PyErr_Occurred()) SWIG_fail;
29553 }
29554 Py_INCREF(Py_None); resultobj = Py_None;
29555 return resultobj;
29556 fail:
29557 return NULL;
29558 }
29559
29560
29561 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29562 PyObject *resultobj;
29563 wxWindow *arg1 = (wxWindow *) 0 ;
29564 wxColour *arg2 = 0 ;
29565 bool result;
29566 wxColour temp2 ;
29567 PyObject * obj0 = 0 ;
29568 PyObject * obj1 = 0 ;
29569 char *kwnames[] = {
29570 (char *) "self",(char *) "colour", NULL
29571 };
29572
29573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29575 if (SWIG_arg_fail(1)) SWIG_fail;
29576 {
29577 arg2 = &temp2;
29578 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29579 }
29580 {
29581 PyThreadState* __tstate = wxPyBeginAllowThreads();
29582 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
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_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29597 PyObject *resultobj;
29598 wxWindow *arg1 = (wxWindow *) 0 ;
29599 wxColour *arg2 = 0 ;
29600 wxColour temp2 ;
29601 PyObject * obj0 = 0 ;
29602 PyObject * obj1 = 0 ;
29603 char *kwnames[] = {
29604 (char *) "self",(char *) "colour", NULL
29605 };
29606
29607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",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 arg2 = &temp2;
29612 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29613 }
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29617
29618 wxPyEndAllowThreads(__tstate);
29619 if (PyErr_Occurred()) SWIG_fail;
29620 }
29621 Py_INCREF(Py_None); resultobj = Py_None;
29622 return resultobj;
29623 fail:
29624 return NULL;
29625 }
29626
29627
29628 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29629 PyObject *resultobj;
29630 wxWindow *arg1 = (wxWindow *) 0 ;
29631 wxColour result;
29632 PyObject * obj0 = 0 ;
29633 char *kwnames[] = {
29634 (char *) "self", NULL
29635 };
29636
29637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29639 if (SWIG_arg_fail(1)) SWIG_fail;
29640 {
29641 PyThreadState* __tstate = wxPyBeginAllowThreads();
29642 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29643
29644 wxPyEndAllowThreads(__tstate);
29645 if (PyErr_Occurred()) SWIG_fail;
29646 }
29647 {
29648 wxColour * resultptr;
29649 resultptr = new wxColour((wxColour &)(result));
29650 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29651 }
29652 return resultobj;
29653 fail:
29654 return NULL;
29655 }
29656
29657
29658 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29659 PyObject *resultobj;
29660 wxWindow *arg1 = (wxWindow *) 0 ;
29661 wxColour result;
29662 PyObject * obj0 = 0 ;
29663 char *kwnames[] = {
29664 (char *) "self", NULL
29665 };
29666
29667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29669 if (SWIG_arg_fail(1)) SWIG_fail;
29670 {
29671 PyThreadState* __tstate = wxPyBeginAllowThreads();
29672 result = ((wxWindow const *)arg1)->GetForegroundColour();
29673
29674 wxPyEndAllowThreads(__tstate);
29675 if (PyErr_Occurred()) SWIG_fail;
29676 }
29677 {
29678 wxColour * resultptr;
29679 resultptr = new wxColour((wxColour &)(result));
29680 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29681 }
29682 return resultobj;
29683 fail:
29684 return NULL;
29685 }
29686
29687
29688 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29689 PyObject *resultobj;
29690 wxWindow *arg1 = (wxWindow *) 0 ;
29691 bool result;
29692 PyObject * obj0 = 0 ;
29693 char *kwnames[] = {
29694 (char *) "self", NULL
29695 };
29696
29697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29699 if (SWIG_arg_fail(1)) SWIG_fail;
29700 {
29701 PyThreadState* __tstate = wxPyBeginAllowThreads();
29702 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29703
29704 wxPyEndAllowThreads(__tstate);
29705 if (PyErr_Occurred()) SWIG_fail;
29706 }
29707 {
29708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29709 }
29710 return resultobj;
29711 fail:
29712 return NULL;
29713 }
29714
29715
29716 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29717 PyObject *resultobj;
29718 wxWindow *arg1 = (wxWindow *) 0 ;
29719 bool result;
29720 PyObject * obj0 = 0 ;
29721 char *kwnames[] = {
29722 (char *) "self", NULL
29723 };
29724
29725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29727 if (SWIG_arg_fail(1)) SWIG_fail;
29728 {
29729 PyThreadState* __tstate = wxPyBeginAllowThreads();
29730 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29731
29732 wxPyEndAllowThreads(__tstate);
29733 if (PyErr_Occurred()) SWIG_fail;
29734 }
29735 {
29736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29737 }
29738 return resultobj;
29739 fail:
29740 return NULL;
29741 }
29742
29743
29744 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29745 PyObject *resultobj;
29746 wxWindow *arg1 = (wxWindow *) 0 ;
29747 wxBackgroundStyle arg2 ;
29748 bool result;
29749 PyObject * obj0 = 0 ;
29750 PyObject * obj1 = 0 ;
29751 char *kwnames[] = {
29752 (char *) "self",(char *) "style", NULL
29753 };
29754
29755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29757 if (SWIG_arg_fail(1)) SWIG_fail;
29758 {
29759 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29760 if (SWIG_arg_fail(2)) SWIG_fail;
29761 }
29762 {
29763 PyThreadState* __tstate = wxPyBeginAllowThreads();
29764 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29765
29766 wxPyEndAllowThreads(__tstate);
29767 if (PyErr_Occurred()) SWIG_fail;
29768 }
29769 {
29770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29771 }
29772 return resultobj;
29773 fail:
29774 return NULL;
29775 }
29776
29777
29778 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29779 PyObject *resultobj;
29780 wxWindow *arg1 = (wxWindow *) 0 ;
29781 wxBackgroundStyle result;
29782 PyObject * obj0 = 0 ;
29783 char *kwnames[] = {
29784 (char *) "self", NULL
29785 };
29786
29787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29789 if (SWIG_arg_fail(1)) SWIG_fail;
29790 {
29791 PyThreadState* __tstate = wxPyBeginAllowThreads();
29792 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29793
29794 wxPyEndAllowThreads(__tstate);
29795 if (PyErr_Occurred()) SWIG_fail;
29796 }
29797 resultobj = SWIG_From_int((result));
29798 return resultobj;
29799 fail:
29800 return NULL;
29801 }
29802
29803
29804 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29805 PyObject *resultobj;
29806 wxWindow *arg1 = (wxWindow *) 0 ;
29807 bool result;
29808 PyObject * obj0 = 0 ;
29809 char *kwnames[] = {
29810 (char *) "self", NULL
29811 };
29812
29813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29815 if (SWIG_arg_fail(1)) SWIG_fail;
29816 {
29817 PyThreadState* __tstate = wxPyBeginAllowThreads();
29818 result = (bool)(arg1)->HasTransparentBackground();
29819
29820 wxPyEndAllowThreads(__tstate);
29821 if (PyErr_Occurred()) SWIG_fail;
29822 }
29823 {
29824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29825 }
29826 return resultobj;
29827 fail:
29828 return NULL;
29829 }
29830
29831
29832 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29833 PyObject *resultobj;
29834 wxWindow *arg1 = (wxWindow *) 0 ;
29835 wxCursor *arg2 = 0 ;
29836 bool result;
29837 PyObject * obj0 = 0 ;
29838 PyObject * obj1 = 0 ;
29839 char *kwnames[] = {
29840 (char *) "self",(char *) "cursor", NULL
29841 };
29842
29843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29845 if (SWIG_arg_fail(1)) SWIG_fail;
29846 {
29847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29848 if (SWIG_arg_fail(2)) SWIG_fail;
29849 if (arg2 == NULL) {
29850 SWIG_null_ref("wxCursor");
29851 }
29852 if (SWIG_arg_fail(2)) SWIG_fail;
29853 }
29854 {
29855 PyThreadState* __tstate = wxPyBeginAllowThreads();
29856 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29857
29858 wxPyEndAllowThreads(__tstate);
29859 if (PyErr_Occurred()) SWIG_fail;
29860 }
29861 {
29862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29863 }
29864 return resultobj;
29865 fail:
29866 return NULL;
29867 }
29868
29869
29870 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29871 PyObject *resultobj;
29872 wxWindow *arg1 = (wxWindow *) 0 ;
29873 wxCursor result;
29874 PyObject * obj0 = 0 ;
29875 char *kwnames[] = {
29876 (char *) "self", NULL
29877 };
29878
29879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29881 if (SWIG_arg_fail(1)) SWIG_fail;
29882 {
29883 PyThreadState* __tstate = wxPyBeginAllowThreads();
29884 result = (arg1)->GetCursor();
29885
29886 wxPyEndAllowThreads(__tstate);
29887 if (PyErr_Occurred()) SWIG_fail;
29888 }
29889 {
29890 wxCursor * resultptr;
29891 resultptr = new wxCursor((wxCursor &)(result));
29892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29893 }
29894 return resultobj;
29895 fail:
29896 return NULL;
29897 }
29898
29899
29900 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29901 PyObject *resultobj;
29902 wxWindow *arg1 = (wxWindow *) 0 ;
29903 wxFont *arg2 = 0 ;
29904 bool result;
29905 PyObject * obj0 = 0 ;
29906 PyObject * obj1 = 0 ;
29907 char *kwnames[] = {
29908 (char *) "self",(char *) "font", NULL
29909 };
29910
29911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29913 if (SWIG_arg_fail(1)) SWIG_fail;
29914 {
29915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29916 if (SWIG_arg_fail(2)) SWIG_fail;
29917 if (arg2 == NULL) {
29918 SWIG_null_ref("wxFont");
29919 }
29920 if (SWIG_arg_fail(2)) SWIG_fail;
29921 }
29922 {
29923 PyThreadState* __tstate = wxPyBeginAllowThreads();
29924 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29925
29926 wxPyEndAllowThreads(__tstate);
29927 if (PyErr_Occurred()) SWIG_fail;
29928 }
29929 {
29930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29931 }
29932 return resultobj;
29933 fail:
29934 return NULL;
29935 }
29936
29937
29938 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29939 PyObject *resultobj;
29940 wxWindow *arg1 = (wxWindow *) 0 ;
29941 wxFont *arg2 = 0 ;
29942 PyObject * obj0 = 0 ;
29943 PyObject * obj1 = 0 ;
29944 char *kwnames[] = {
29945 (char *) "self",(char *) "font", NULL
29946 };
29947
29948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29950 if (SWIG_arg_fail(1)) SWIG_fail;
29951 {
29952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29953 if (SWIG_arg_fail(2)) SWIG_fail;
29954 if (arg2 == NULL) {
29955 SWIG_null_ref("wxFont");
29956 }
29957 if (SWIG_arg_fail(2)) SWIG_fail;
29958 }
29959 {
29960 PyThreadState* __tstate = wxPyBeginAllowThreads();
29961 (arg1)->SetOwnFont((wxFont const &)*arg2);
29962
29963 wxPyEndAllowThreads(__tstate);
29964 if (PyErr_Occurred()) SWIG_fail;
29965 }
29966 Py_INCREF(Py_None); resultobj = Py_None;
29967 return resultobj;
29968 fail:
29969 return NULL;
29970 }
29971
29972
29973 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29974 PyObject *resultobj;
29975 wxWindow *arg1 = (wxWindow *) 0 ;
29976 wxFont result;
29977 PyObject * obj0 = 0 ;
29978 char *kwnames[] = {
29979 (char *) "self", NULL
29980 };
29981
29982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29984 if (SWIG_arg_fail(1)) SWIG_fail;
29985 {
29986 PyThreadState* __tstate = wxPyBeginAllowThreads();
29987 result = (arg1)->GetFont();
29988
29989 wxPyEndAllowThreads(__tstate);
29990 if (PyErr_Occurred()) SWIG_fail;
29991 }
29992 {
29993 wxFont * resultptr;
29994 resultptr = new wxFont((wxFont &)(result));
29995 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29996 }
29997 return resultobj;
29998 fail:
29999 return NULL;
30000 }
30001
30002
30003 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30004 PyObject *resultobj;
30005 wxWindow *arg1 = (wxWindow *) 0 ;
30006 wxCaret *arg2 = (wxCaret *) 0 ;
30007 PyObject * obj0 = 0 ;
30008 PyObject * obj1 = 0 ;
30009 char *kwnames[] = {
30010 (char *) "self",(char *) "caret", NULL
30011 };
30012
30013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30015 if (SWIG_arg_fail(1)) SWIG_fail;
30016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30017 if (SWIG_arg_fail(2)) SWIG_fail;
30018 {
30019 PyThreadState* __tstate = wxPyBeginAllowThreads();
30020 (arg1)->SetCaret(arg2);
30021
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 Py_INCREF(Py_None); resultobj = Py_None;
30026 return resultobj;
30027 fail:
30028 return NULL;
30029 }
30030
30031
30032 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30033 PyObject *resultobj;
30034 wxWindow *arg1 = (wxWindow *) 0 ;
30035 wxCaret *result;
30036 PyObject * obj0 = 0 ;
30037 char *kwnames[] = {
30038 (char *) "self", NULL
30039 };
30040
30041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30043 if (SWIG_arg_fail(1)) SWIG_fail;
30044 {
30045 PyThreadState* __tstate = wxPyBeginAllowThreads();
30046 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30047
30048 wxPyEndAllowThreads(__tstate);
30049 if (PyErr_Occurred()) SWIG_fail;
30050 }
30051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30052 return resultobj;
30053 fail:
30054 return NULL;
30055 }
30056
30057
30058 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30059 PyObject *resultobj;
30060 wxWindow *arg1 = (wxWindow *) 0 ;
30061 int result;
30062 PyObject * obj0 = 0 ;
30063 char *kwnames[] = {
30064 (char *) "self", NULL
30065 };
30066
30067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30069 if (SWIG_arg_fail(1)) SWIG_fail;
30070 {
30071 PyThreadState* __tstate = wxPyBeginAllowThreads();
30072 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30073
30074 wxPyEndAllowThreads(__tstate);
30075 if (PyErr_Occurred()) SWIG_fail;
30076 }
30077 {
30078 resultobj = SWIG_From_int((int)(result));
30079 }
30080 return resultobj;
30081 fail:
30082 return NULL;
30083 }
30084
30085
30086 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30087 PyObject *resultobj;
30088 wxWindow *arg1 = (wxWindow *) 0 ;
30089 int result;
30090 PyObject * obj0 = 0 ;
30091 char *kwnames[] = {
30092 (char *) "self", NULL
30093 };
30094
30095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30097 if (SWIG_arg_fail(1)) SWIG_fail;
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30101
30102 wxPyEndAllowThreads(__tstate);
30103 if (PyErr_Occurred()) SWIG_fail;
30104 }
30105 {
30106 resultobj = SWIG_From_int((int)(result));
30107 }
30108 return resultobj;
30109 fail:
30110 return NULL;
30111 }
30112
30113
30114 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30115 PyObject *resultobj;
30116 wxWindow *arg1 = (wxWindow *) 0 ;
30117 wxString *arg2 = 0 ;
30118 int *arg3 = (int *) 0 ;
30119 int *arg4 = (int *) 0 ;
30120 bool temp2 = false ;
30121 int temp3 ;
30122 int res3 = 0 ;
30123 int temp4 ;
30124 int res4 = 0 ;
30125 PyObject * obj0 = 0 ;
30126 PyObject * obj1 = 0 ;
30127 char *kwnames[] = {
30128 (char *) "self",(char *) "string", NULL
30129 };
30130
30131 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30132 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30135 if (SWIG_arg_fail(1)) SWIG_fail;
30136 {
30137 arg2 = wxString_in_helper(obj1);
30138 if (arg2 == NULL) SWIG_fail;
30139 temp2 = true;
30140 }
30141 {
30142 PyThreadState* __tstate = wxPyBeginAllowThreads();
30143 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30144
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 Py_INCREF(Py_None); resultobj = Py_None;
30149 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30150 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30151 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30152 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30153 {
30154 if (temp2)
30155 delete arg2;
30156 }
30157 return resultobj;
30158 fail:
30159 {
30160 if (temp2)
30161 delete arg2;
30162 }
30163 return NULL;
30164 }
30165
30166
30167 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30168 PyObject *resultobj;
30169 wxWindow *arg1 = (wxWindow *) 0 ;
30170 wxString *arg2 = 0 ;
30171 int *arg3 = (int *) 0 ;
30172 int *arg4 = (int *) 0 ;
30173 int *arg5 = (int *) 0 ;
30174 int *arg6 = (int *) 0 ;
30175 wxFont *arg7 = (wxFont *) NULL ;
30176 bool temp2 = false ;
30177 int temp3 ;
30178 int res3 = 0 ;
30179 int temp4 ;
30180 int res4 = 0 ;
30181 int temp5 ;
30182 int res5 = 0 ;
30183 int temp6 ;
30184 int res6 = 0 ;
30185 PyObject * obj0 = 0 ;
30186 PyObject * obj1 = 0 ;
30187 PyObject * obj2 = 0 ;
30188 char *kwnames[] = {
30189 (char *) "self",(char *) "string",(char *) "font", NULL
30190 };
30191
30192 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30193 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30194 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30195 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30198 if (SWIG_arg_fail(1)) SWIG_fail;
30199 {
30200 arg2 = wxString_in_helper(obj1);
30201 if (arg2 == NULL) SWIG_fail;
30202 temp2 = true;
30203 }
30204 if (obj2) {
30205 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30206 if (SWIG_arg_fail(7)) SWIG_fail;
30207 }
30208 {
30209 PyThreadState* __tstate = wxPyBeginAllowThreads();
30210 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30211
30212 wxPyEndAllowThreads(__tstate);
30213 if (PyErr_Occurred()) SWIG_fail;
30214 }
30215 Py_INCREF(Py_None); resultobj = Py_None;
30216 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30217 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30218 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30219 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30220 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30221 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30222 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30223 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30224 {
30225 if (temp2)
30226 delete arg2;
30227 }
30228 return resultobj;
30229 fail:
30230 {
30231 if (temp2)
30232 delete arg2;
30233 }
30234 return NULL;
30235 }
30236
30237
30238 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30239 PyObject *resultobj;
30240 wxWindow *arg1 = (wxWindow *) 0 ;
30241 int *arg2 = (int *) 0 ;
30242 int *arg3 = (int *) 0 ;
30243 int temp2 ;
30244 int res2 = 0 ;
30245 int temp3 ;
30246 int res3 = 0 ;
30247 PyObject * obj0 = 0 ;
30248 PyObject * obj1 = 0 ;
30249 PyObject * obj2 = 0 ;
30250 char *kwnames[] = {
30251 (char *) "self",(char *) "x",(char *) "y", NULL
30252 };
30253
30254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30256 if (SWIG_arg_fail(1)) SWIG_fail;
30257 {
30258 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30259 temp2 = SWIG_As_int(obj1);
30260 if (SWIG_arg_fail(2)) SWIG_fail;
30261 arg2 = &temp2;
30262 res2 = SWIG_NEWOBJ;
30263 }
30264 }
30265 {
30266 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30267 temp3 = SWIG_As_int(obj2);
30268 if (SWIG_arg_fail(3)) SWIG_fail;
30269 arg3 = &temp3;
30270 res3 = SWIG_NEWOBJ;
30271 }
30272 }
30273 {
30274 PyThreadState* __tstate = wxPyBeginAllowThreads();
30275 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30276
30277 wxPyEndAllowThreads(__tstate);
30278 if (PyErr_Occurred()) SWIG_fail;
30279 }
30280 Py_INCREF(Py_None); resultobj = Py_None;
30281 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30282 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30283 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30284 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30285 return resultobj;
30286 fail:
30287 return NULL;
30288 }
30289
30290
30291 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30292 PyObject *resultobj;
30293 wxWindow *arg1 = (wxWindow *) 0 ;
30294 int *arg2 = (int *) 0 ;
30295 int *arg3 = (int *) 0 ;
30296 int temp2 ;
30297 int res2 = 0 ;
30298 int temp3 ;
30299 int res3 = 0 ;
30300 PyObject * obj0 = 0 ;
30301 PyObject * obj1 = 0 ;
30302 PyObject * obj2 = 0 ;
30303 char *kwnames[] = {
30304 (char *) "self",(char *) "x",(char *) "y", NULL
30305 };
30306
30307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30309 if (SWIG_arg_fail(1)) SWIG_fail;
30310 {
30311 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30312 temp2 = SWIG_As_int(obj1);
30313 if (SWIG_arg_fail(2)) SWIG_fail;
30314 arg2 = &temp2;
30315 res2 = SWIG_NEWOBJ;
30316 }
30317 }
30318 {
30319 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30320 temp3 = SWIG_As_int(obj2);
30321 if (SWIG_arg_fail(3)) SWIG_fail;
30322 arg3 = &temp3;
30323 res3 = SWIG_NEWOBJ;
30324 }
30325 }
30326 {
30327 PyThreadState* __tstate = wxPyBeginAllowThreads();
30328 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30329
30330 wxPyEndAllowThreads(__tstate);
30331 if (PyErr_Occurred()) SWIG_fail;
30332 }
30333 Py_INCREF(Py_None); resultobj = Py_None;
30334 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30335 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30336 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30337 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30338 return resultobj;
30339 fail:
30340 return NULL;
30341 }
30342
30343
30344 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30345 PyObject *resultobj;
30346 wxWindow *arg1 = (wxWindow *) 0 ;
30347 wxPoint *arg2 = 0 ;
30348 wxPoint result;
30349 wxPoint temp2 ;
30350 PyObject * obj0 = 0 ;
30351 PyObject * obj1 = 0 ;
30352 char *kwnames[] = {
30353 (char *) "self",(char *) "pt", NULL
30354 };
30355
30356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30358 if (SWIG_arg_fail(1)) SWIG_fail;
30359 {
30360 arg2 = &temp2;
30361 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30362 }
30363 {
30364 PyThreadState* __tstate = wxPyBeginAllowThreads();
30365 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30366
30367 wxPyEndAllowThreads(__tstate);
30368 if (PyErr_Occurred()) SWIG_fail;
30369 }
30370 {
30371 wxPoint * resultptr;
30372 resultptr = new wxPoint((wxPoint &)(result));
30373 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30374 }
30375 return resultobj;
30376 fail:
30377 return NULL;
30378 }
30379
30380
30381 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30382 PyObject *resultobj;
30383 wxWindow *arg1 = (wxWindow *) 0 ;
30384 wxPoint *arg2 = 0 ;
30385 wxPoint result;
30386 wxPoint temp2 ;
30387 PyObject * obj0 = 0 ;
30388 PyObject * obj1 = 0 ;
30389 char *kwnames[] = {
30390 (char *) "self",(char *) "pt", NULL
30391 };
30392
30393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30395 if (SWIG_arg_fail(1)) SWIG_fail;
30396 {
30397 arg2 = &temp2;
30398 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30399 }
30400 {
30401 PyThreadState* __tstate = wxPyBeginAllowThreads();
30402 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30403
30404 wxPyEndAllowThreads(__tstate);
30405 if (PyErr_Occurred()) SWIG_fail;
30406 }
30407 {
30408 wxPoint * resultptr;
30409 resultptr = new wxPoint((wxPoint &)(result));
30410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30411 }
30412 return resultobj;
30413 fail:
30414 return NULL;
30415 }
30416
30417
30418 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30419 PyObject *resultobj;
30420 wxWindow *arg1 = (wxWindow *) 0 ;
30421 int arg2 ;
30422 int arg3 ;
30423 wxHitTest result;
30424 PyObject * obj0 = 0 ;
30425 PyObject * obj1 = 0 ;
30426 PyObject * obj2 = 0 ;
30427 char *kwnames[] = {
30428 (char *) "self",(char *) "x",(char *) "y", NULL
30429 };
30430
30431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30433 if (SWIG_arg_fail(1)) SWIG_fail;
30434 {
30435 arg2 = (int)(SWIG_As_int(obj1));
30436 if (SWIG_arg_fail(2)) SWIG_fail;
30437 }
30438 {
30439 arg3 = (int)(SWIG_As_int(obj2));
30440 if (SWIG_arg_fail(3)) SWIG_fail;
30441 }
30442 {
30443 PyThreadState* __tstate = wxPyBeginAllowThreads();
30444 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30445
30446 wxPyEndAllowThreads(__tstate);
30447 if (PyErr_Occurred()) SWIG_fail;
30448 }
30449 resultobj = SWIG_From_int((result));
30450 return resultobj;
30451 fail:
30452 return NULL;
30453 }
30454
30455
30456 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30457 PyObject *resultobj;
30458 wxWindow *arg1 = (wxWindow *) 0 ;
30459 wxPoint *arg2 = 0 ;
30460 wxHitTest result;
30461 wxPoint temp2 ;
30462 PyObject * obj0 = 0 ;
30463 PyObject * obj1 = 0 ;
30464 char *kwnames[] = {
30465 (char *) "self",(char *) "pt", NULL
30466 };
30467
30468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30470 if (SWIG_arg_fail(1)) SWIG_fail;
30471 {
30472 arg2 = &temp2;
30473 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30474 }
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30478
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 resultobj = SWIG_From_int((result));
30483 return resultobj;
30484 fail:
30485 return NULL;
30486 }
30487
30488
30489 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30490 PyObject *resultobj;
30491 wxWindow *arg1 = (wxWindow *) 0 ;
30492 long arg2 ;
30493 wxBorder result;
30494 PyObject * obj0 = 0 ;
30495 PyObject * obj1 = 0 ;
30496
30497 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30499 if (SWIG_arg_fail(1)) SWIG_fail;
30500 {
30501 arg2 = (long)(SWIG_As_long(obj1));
30502 if (SWIG_arg_fail(2)) SWIG_fail;
30503 }
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30507
30508 wxPyEndAllowThreads(__tstate);
30509 if (PyErr_Occurred()) SWIG_fail;
30510 }
30511 resultobj = SWIG_From_int((result));
30512 return resultobj;
30513 fail:
30514 return NULL;
30515 }
30516
30517
30518 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30519 PyObject *resultobj;
30520 wxWindow *arg1 = (wxWindow *) 0 ;
30521 wxBorder result;
30522 PyObject * obj0 = 0 ;
30523
30524 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30526 if (SWIG_arg_fail(1)) SWIG_fail;
30527 {
30528 PyThreadState* __tstate = wxPyBeginAllowThreads();
30529 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30530
30531 wxPyEndAllowThreads(__tstate);
30532 if (PyErr_Occurred()) SWIG_fail;
30533 }
30534 resultobj = SWIG_From_int((result));
30535 return resultobj;
30536 fail:
30537 return NULL;
30538 }
30539
30540
30541 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30542 int argc;
30543 PyObject *argv[3];
30544 int ii;
30545
30546 argc = PyObject_Length(args);
30547 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30548 argv[ii] = PyTuple_GetItem(args,ii);
30549 }
30550 if (argc == 1) {
30551 int _v;
30552 {
30553 void *ptr;
30554 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30555 _v = 0;
30556 PyErr_Clear();
30557 } else {
30558 _v = 1;
30559 }
30560 }
30561 if (_v) {
30562 return _wrap_Window_GetBorder__SWIG_1(self,args);
30563 }
30564 }
30565 if (argc == 2) {
30566 int _v;
30567 {
30568 void *ptr;
30569 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30570 _v = 0;
30571 PyErr_Clear();
30572 } else {
30573 _v = 1;
30574 }
30575 }
30576 if (_v) {
30577 _v = SWIG_Check_long(argv[1]);
30578 if (_v) {
30579 return _wrap_Window_GetBorder__SWIG_0(self,args);
30580 }
30581 }
30582 }
30583
30584 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30585 return NULL;
30586 }
30587
30588
30589 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30590 PyObject *resultobj;
30591 wxWindow *arg1 = (wxWindow *) 0 ;
30592 long arg2 = (long) wxUPDATE_UI_NONE ;
30593 PyObject * obj0 = 0 ;
30594 PyObject * obj1 = 0 ;
30595 char *kwnames[] = {
30596 (char *) "self",(char *) "flags", NULL
30597 };
30598
30599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30601 if (SWIG_arg_fail(1)) SWIG_fail;
30602 if (obj1) {
30603 {
30604 arg2 = (long)(SWIG_As_long(obj1));
30605 if (SWIG_arg_fail(2)) SWIG_fail;
30606 }
30607 }
30608 {
30609 PyThreadState* __tstate = wxPyBeginAllowThreads();
30610 (arg1)->UpdateWindowUI(arg2);
30611
30612 wxPyEndAllowThreads(__tstate);
30613 if (PyErr_Occurred()) SWIG_fail;
30614 }
30615 Py_INCREF(Py_None); resultobj = Py_None;
30616 return resultobj;
30617 fail:
30618 return NULL;
30619 }
30620
30621
30622 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30623 PyObject *resultobj;
30624 wxWindow *arg1 = (wxWindow *) 0 ;
30625 wxMenu *arg2 = (wxMenu *) 0 ;
30626 int arg3 = (int) -1 ;
30627 int arg4 = (int) -1 ;
30628 bool result;
30629 PyObject * obj0 = 0 ;
30630 PyObject * obj1 = 0 ;
30631 PyObject * obj2 = 0 ;
30632 PyObject * obj3 = 0 ;
30633 char *kwnames[] = {
30634 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30635 };
30636
30637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30639 if (SWIG_arg_fail(1)) SWIG_fail;
30640 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30641 if (SWIG_arg_fail(2)) SWIG_fail;
30642 if (obj2) {
30643 {
30644 arg3 = (int)(SWIG_As_int(obj2));
30645 if (SWIG_arg_fail(3)) SWIG_fail;
30646 }
30647 }
30648 if (obj3) {
30649 {
30650 arg4 = (int)(SWIG_As_int(obj3));
30651 if (SWIG_arg_fail(4)) SWIG_fail;
30652 }
30653 }
30654 {
30655 PyThreadState* __tstate = wxPyBeginAllowThreads();
30656 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30657
30658 wxPyEndAllowThreads(__tstate);
30659 if (PyErr_Occurred()) SWIG_fail;
30660 }
30661 {
30662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30663 }
30664 return resultobj;
30665 fail:
30666 return NULL;
30667 }
30668
30669
30670 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30671 PyObject *resultobj;
30672 wxWindow *arg1 = (wxWindow *) 0 ;
30673 wxMenu *arg2 = (wxMenu *) 0 ;
30674 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30675 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30676 bool result;
30677 wxPoint temp3 ;
30678 PyObject * obj0 = 0 ;
30679 PyObject * obj1 = 0 ;
30680 PyObject * obj2 = 0 ;
30681 char *kwnames[] = {
30682 (char *) "self",(char *) "menu",(char *) "pos", NULL
30683 };
30684
30685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30687 if (SWIG_arg_fail(1)) SWIG_fail;
30688 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30689 if (SWIG_arg_fail(2)) SWIG_fail;
30690 if (obj2) {
30691 {
30692 arg3 = &temp3;
30693 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30694 }
30695 }
30696 {
30697 PyThreadState* __tstate = wxPyBeginAllowThreads();
30698 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30699
30700 wxPyEndAllowThreads(__tstate);
30701 if (PyErr_Occurred()) SWIG_fail;
30702 }
30703 {
30704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30705 }
30706 return resultobj;
30707 fail:
30708 return NULL;
30709 }
30710
30711
30712 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30713 PyObject *resultobj;
30714 wxWindow *arg1 = (wxWindow *) 0 ;
30715 long result;
30716 PyObject * obj0 = 0 ;
30717 char *kwnames[] = {
30718 (char *) "self", NULL
30719 };
30720
30721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30723 if (SWIG_arg_fail(1)) SWIG_fail;
30724 {
30725 PyThreadState* __tstate = wxPyBeginAllowThreads();
30726 result = (long)wxWindow_GetHandle(arg1);
30727
30728 wxPyEndAllowThreads(__tstate);
30729 if (PyErr_Occurred()) SWIG_fail;
30730 }
30731 {
30732 resultobj = SWIG_From_long((long)(result));
30733 }
30734 return resultobj;
30735 fail:
30736 return NULL;
30737 }
30738
30739
30740 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30741 PyObject *resultobj;
30742 wxWindow *arg1 = (wxWindow *) 0 ;
30743 long arg2 ;
30744 PyObject * obj0 = 0 ;
30745 PyObject * obj1 = 0 ;
30746 char *kwnames[] = {
30747 (char *) "self",(char *) "handle", NULL
30748 };
30749
30750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30752 if (SWIG_arg_fail(1)) SWIG_fail;
30753 {
30754 arg2 = (long)(SWIG_As_long(obj1));
30755 if (SWIG_arg_fail(2)) SWIG_fail;
30756 }
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 wxWindow_AssociateHandle(arg1,arg2);
30760
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 Py_INCREF(Py_None); resultobj = Py_None;
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30772 PyObject *resultobj;
30773 wxWindow *arg1 = (wxWindow *) 0 ;
30774 PyObject * obj0 = 0 ;
30775 char *kwnames[] = {
30776 (char *) "self", NULL
30777 };
30778
30779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30781 if (SWIG_arg_fail(1)) SWIG_fail;
30782 {
30783 PyThreadState* __tstate = wxPyBeginAllowThreads();
30784 (arg1)->DissociateHandle();
30785
30786 wxPyEndAllowThreads(__tstate);
30787 if (PyErr_Occurred()) SWIG_fail;
30788 }
30789 Py_INCREF(Py_None); resultobj = Py_None;
30790 return resultobj;
30791 fail:
30792 return NULL;
30793 }
30794
30795
30796 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30797 PyObject *resultobj;
30798 wxWindow *arg1 = (wxWindow *) 0 ;
30799 int arg2 ;
30800 bool result;
30801 PyObject * obj0 = 0 ;
30802 PyObject * obj1 = 0 ;
30803 char *kwnames[] = {
30804 (char *) "self",(char *) "orient", NULL
30805 };
30806
30807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30809 if (SWIG_arg_fail(1)) SWIG_fail;
30810 {
30811 arg2 = (int)(SWIG_As_int(obj1));
30812 if (SWIG_arg_fail(2)) SWIG_fail;
30813 }
30814 {
30815 PyThreadState* __tstate = wxPyBeginAllowThreads();
30816 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30817
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 {
30822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30823 }
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30831 PyObject *resultobj;
30832 wxWindow *arg1 = (wxWindow *) 0 ;
30833 int arg2 ;
30834 int arg3 ;
30835 int arg4 ;
30836 int arg5 ;
30837 bool arg6 = (bool) true ;
30838 PyObject * obj0 = 0 ;
30839 PyObject * obj1 = 0 ;
30840 PyObject * obj2 = 0 ;
30841 PyObject * obj3 = 0 ;
30842 PyObject * obj4 = 0 ;
30843 PyObject * obj5 = 0 ;
30844 char *kwnames[] = {
30845 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30846 };
30847
30848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30850 if (SWIG_arg_fail(1)) SWIG_fail;
30851 {
30852 arg2 = (int)(SWIG_As_int(obj1));
30853 if (SWIG_arg_fail(2)) SWIG_fail;
30854 }
30855 {
30856 arg3 = (int)(SWIG_As_int(obj2));
30857 if (SWIG_arg_fail(3)) SWIG_fail;
30858 }
30859 {
30860 arg4 = (int)(SWIG_As_int(obj3));
30861 if (SWIG_arg_fail(4)) SWIG_fail;
30862 }
30863 {
30864 arg5 = (int)(SWIG_As_int(obj4));
30865 if (SWIG_arg_fail(5)) SWIG_fail;
30866 }
30867 if (obj5) {
30868 {
30869 arg6 = (bool)(SWIG_As_bool(obj5));
30870 if (SWIG_arg_fail(6)) SWIG_fail;
30871 }
30872 }
30873 {
30874 PyThreadState* __tstate = wxPyBeginAllowThreads();
30875 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30876
30877 wxPyEndAllowThreads(__tstate);
30878 if (PyErr_Occurred()) SWIG_fail;
30879 }
30880 Py_INCREF(Py_None); resultobj = Py_None;
30881 return resultobj;
30882 fail:
30883 return NULL;
30884 }
30885
30886
30887 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30888 PyObject *resultobj;
30889 wxWindow *arg1 = (wxWindow *) 0 ;
30890 int arg2 ;
30891 int arg3 ;
30892 bool arg4 = (bool) true ;
30893 PyObject * obj0 = 0 ;
30894 PyObject * obj1 = 0 ;
30895 PyObject * obj2 = 0 ;
30896 PyObject * obj3 = 0 ;
30897 char *kwnames[] = {
30898 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30899 };
30900
30901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30903 if (SWIG_arg_fail(1)) SWIG_fail;
30904 {
30905 arg2 = (int)(SWIG_As_int(obj1));
30906 if (SWIG_arg_fail(2)) SWIG_fail;
30907 }
30908 {
30909 arg3 = (int)(SWIG_As_int(obj2));
30910 if (SWIG_arg_fail(3)) SWIG_fail;
30911 }
30912 if (obj3) {
30913 {
30914 arg4 = (bool)(SWIG_As_bool(obj3));
30915 if (SWIG_arg_fail(4)) SWIG_fail;
30916 }
30917 }
30918 {
30919 PyThreadState* __tstate = wxPyBeginAllowThreads();
30920 (arg1)->SetScrollPos(arg2,arg3,arg4);
30921
30922 wxPyEndAllowThreads(__tstate);
30923 if (PyErr_Occurred()) SWIG_fail;
30924 }
30925 Py_INCREF(Py_None); resultobj = Py_None;
30926 return resultobj;
30927 fail:
30928 return NULL;
30929 }
30930
30931
30932 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30933 PyObject *resultobj;
30934 wxWindow *arg1 = (wxWindow *) 0 ;
30935 int arg2 ;
30936 int result;
30937 PyObject * obj0 = 0 ;
30938 PyObject * obj1 = 0 ;
30939 char *kwnames[] = {
30940 (char *) "self",(char *) "orientation", NULL
30941 };
30942
30943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30945 if (SWIG_arg_fail(1)) SWIG_fail;
30946 {
30947 arg2 = (int)(SWIG_As_int(obj1));
30948 if (SWIG_arg_fail(2)) SWIG_fail;
30949 }
30950 {
30951 PyThreadState* __tstate = wxPyBeginAllowThreads();
30952 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30953
30954 wxPyEndAllowThreads(__tstate);
30955 if (PyErr_Occurred()) SWIG_fail;
30956 }
30957 {
30958 resultobj = SWIG_From_int((int)(result));
30959 }
30960 return resultobj;
30961 fail:
30962 return NULL;
30963 }
30964
30965
30966 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30967 PyObject *resultobj;
30968 wxWindow *arg1 = (wxWindow *) 0 ;
30969 int arg2 ;
30970 int result;
30971 PyObject * obj0 = 0 ;
30972 PyObject * obj1 = 0 ;
30973 char *kwnames[] = {
30974 (char *) "self",(char *) "orientation", NULL
30975 };
30976
30977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30979 if (SWIG_arg_fail(1)) SWIG_fail;
30980 {
30981 arg2 = (int)(SWIG_As_int(obj1));
30982 if (SWIG_arg_fail(2)) SWIG_fail;
30983 }
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30987
30988 wxPyEndAllowThreads(__tstate);
30989 if (PyErr_Occurred()) SWIG_fail;
30990 }
30991 {
30992 resultobj = SWIG_From_int((int)(result));
30993 }
30994 return resultobj;
30995 fail:
30996 return NULL;
30997 }
30998
30999
31000 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31001 PyObject *resultobj;
31002 wxWindow *arg1 = (wxWindow *) 0 ;
31003 int arg2 ;
31004 int result;
31005 PyObject * obj0 = 0 ;
31006 PyObject * obj1 = 0 ;
31007 char *kwnames[] = {
31008 (char *) "self",(char *) "orientation", NULL
31009 };
31010
31011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31013 if (SWIG_arg_fail(1)) SWIG_fail;
31014 {
31015 arg2 = (int)(SWIG_As_int(obj1));
31016 if (SWIG_arg_fail(2)) SWIG_fail;
31017 }
31018 {
31019 PyThreadState* __tstate = wxPyBeginAllowThreads();
31020 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31021
31022 wxPyEndAllowThreads(__tstate);
31023 if (PyErr_Occurred()) SWIG_fail;
31024 }
31025 {
31026 resultobj = SWIG_From_int((int)(result));
31027 }
31028 return resultobj;
31029 fail:
31030 return NULL;
31031 }
31032
31033
31034 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31035 PyObject *resultobj;
31036 wxWindow *arg1 = (wxWindow *) 0 ;
31037 int arg2 ;
31038 int arg3 ;
31039 wxRect *arg4 = (wxRect *) NULL ;
31040 PyObject * obj0 = 0 ;
31041 PyObject * obj1 = 0 ;
31042 PyObject * obj2 = 0 ;
31043 PyObject * obj3 = 0 ;
31044 char *kwnames[] = {
31045 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31046 };
31047
31048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31050 if (SWIG_arg_fail(1)) SWIG_fail;
31051 {
31052 arg2 = (int)(SWIG_As_int(obj1));
31053 if (SWIG_arg_fail(2)) SWIG_fail;
31054 }
31055 {
31056 arg3 = (int)(SWIG_As_int(obj2));
31057 if (SWIG_arg_fail(3)) SWIG_fail;
31058 }
31059 if (obj3) {
31060 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31061 if (SWIG_arg_fail(4)) SWIG_fail;
31062 }
31063 {
31064 PyThreadState* __tstate = wxPyBeginAllowThreads();
31065 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31066
31067 wxPyEndAllowThreads(__tstate);
31068 if (PyErr_Occurred()) SWIG_fail;
31069 }
31070 Py_INCREF(Py_None); resultobj = Py_None;
31071 return resultobj;
31072 fail:
31073 return NULL;
31074 }
31075
31076
31077 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31078 PyObject *resultobj;
31079 wxWindow *arg1 = (wxWindow *) 0 ;
31080 int arg2 ;
31081 bool result;
31082 PyObject * obj0 = 0 ;
31083 PyObject * obj1 = 0 ;
31084 char *kwnames[] = {
31085 (char *) "self",(char *) "lines", NULL
31086 };
31087
31088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31090 if (SWIG_arg_fail(1)) SWIG_fail;
31091 {
31092 arg2 = (int)(SWIG_As_int(obj1));
31093 if (SWIG_arg_fail(2)) SWIG_fail;
31094 }
31095 {
31096 PyThreadState* __tstate = wxPyBeginAllowThreads();
31097 result = (bool)(arg1)->ScrollLines(arg2);
31098
31099 wxPyEndAllowThreads(__tstate);
31100 if (PyErr_Occurred()) SWIG_fail;
31101 }
31102 {
31103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31104 }
31105 return resultobj;
31106 fail:
31107 return NULL;
31108 }
31109
31110
31111 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31112 PyObject *resultobj;
31113 wxWindow *arg1 = (wxWindow *) 0 ;
31114 int arg2 ;
31115 bool result;
31116 PyObject * obj0 = 0 ;
31117 PyObject * obj1 = 0 ;
31118 char *kwnames[] = {
31119 (char *) "self",(char *) "pages", NULL
31120 };
31121
31122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31124 if (SWIG_arg_fail(1)) SWIG_fail;
31125 {
31126 arg2 = (int)(SWIG_As_int(obj1));
31127 if (SWIG_arg_fail(2)) SWIG_fail;
31128 }
31129 {
31130 PyThreadState* __tstate = wxPyBeginAllowThreads();
31131 result = (bool)(arg1)->ScrollPages(arg2);
31132
31133 wxPyEndAllowThreads(__tstate);
31134 if (PyErr_Occurred()) SWIG_fail;
31135 }
31136 {
31137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31138 }
31139 return resultobj;
31140 fail:
31141 return NULL;
31142 }
31143
31144
31145 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31146 PyObject *resultobj;
31147 wxWindow *arg1 = (wxWindow *) 0 ;
31148 bool result;
31149 PyObject * obj0 = 0 ;
31150 char *kwnames[] = {
31151 (char *) "self", NULL
31152 };
31153
31154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31156 if (SWIG_arg_fail(1)) SWIG_fail;
31157 {
31158 PyThreadState* __tstate = wxPyBeginAllowThreads();
31159 result = (bool)(arg1)->LineUp();
31160
31161 wxPyEndAllowThreads(__tstate);
31162 if (PyErr_Occurred()) SWIG_fail;
31163 }
31164 {
31165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31166 }
31167 return resultobj;
31168 fail:
31169 return NULL;
31170 }
31171
31172
31173 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31174 PyObject *resultobj;
31175 wxWindow *arg1 = (wxWindow *) 0 ;
31176 bool result;
31177 PyObject * obj0 = 0 ;
31178 char *kwnames[] = {
31179 (char *) "self", NULL
31180 };
31181
31182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31184 if (SWIG_arg_fail(1)) SWIG_fail;
31185 {
31186 PyThreadState* __tstate = wxPyBeginAllowThreads();
31187 result = (bool)(arg1)->LineDown();
31188
31189 wxPyEndAllowThreads(__tstate);
31190 if (PyErr_Occurred()) SWIG_fail;
31191 }
31192 {
31193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31194 }
31195 return resultobj;
31196 fail:
31197 return NULL;
31198 }
31199
31200
31201 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31202 PyObject *resultobj;
31203 wxWindow *arg1 = (wxWindow *) 0 ;
31204 bool result;
31205 PyObject * obj0 = 0 ;
31206 char *kwnames[] = {
31207 (char *) "self", NULL
31208 };
31209
31210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31212 if (SWIG_arg_fail(1)) SWIG_fail;
31213 {
31214 PyThreadState* __tstate = wxPyBeginAllowThreads();
31215 result = (bool)(arg1)->PageUp();
31216
31217 wxPyEndAllowThreads(__tstate);
31218 if (PyErr_Occurred()) SWIG_fail;
31219 }
31220 {
31221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31222 }
31223 return resultobj;
31224 fail:
31225 return NULL;
31226 }
31227
31228
31229 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31230 PyObject *resultobj;
31231 wxWindow *arg1 = (wxWindow *) 0 ;
31232 bool result;
31233 PyObject * obj0 = 0 ;
31234 char *kwnames[] = {
31235 (char *) "self", NULL
31236 };
31237
31238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31240 if (SWIG_arg_fail(1)) SWIG_fail;
31241 {
31242 PyThreadState* __tstate = wxPyBeginAllowThreads();
31243 result = (bool)(arg1)->PageDown();
31244
31245 wxPyEndAllowThreads(__tstate);
31246 if (PyErr_Occurred()) SWIG_fail;
31247 }
31248 {
31249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31250 }
31251 return resultobj;
31252 fail:
31253 return NULL;
31254 }
31255
31256
31257 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31258 PyObject *resultobj;
31259 wxWindow *arg1 = (wxWindow *) 0 ;
31260 wxString *arg2 = 0 ;
31261 bool temp2 = false ;
31262 PyObject * obj0 = 0 ;
31263 PyObject * obj1 = 0 ;
31264 char *kwnames[] = {
31265 (char *) "self",(char *) "text", NULL
31266 };
31267
31268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31270 if (SWIG_arg_fail(1)) SWIG_fail;
31271 {
31272 arg2 = wxString_in_helper(obj1);
31273 if (arg2 == NULL) SWIG_fail;
31274 temp2 = true;
31275 }
31276 {
31277 PyThreadState* __tstate = wxPyBeginAllowThreads();
31278 (arg1)->SetHelpText((wxString const &)*arg2);
31279
31280 wxPyEndAllowThreads(__tstate);
31281 if (PyErr_Occurred()) SWIG_fail;
31282 }
31283 Py_INCREF(Py_None); resultobj = Py_None;
31284 {
31285 if (temp2)
31286 delete arg2;
31287 }
31288 return resultobj;
31289 fail:
31290 {
31291 if (temp2)
31292 delete arg2;
31293 }
31294 return NULL;
31295 }
31296
31297
31298 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31299 PyObject *resultobj;
31300 wxWindow *arg1 = (wxWindow *) 0 ;
31301 wxString *arg2 = 0 ;
31302 bool temp2 = false ;
31303 PyObject * obj0 = 0 ;
31304 PyObject * obj1 = 0 ;
31305 char *kwnames[] = {
31306 (char *) "self",(char *) "text", NULL
31307 };
31308
31309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31311 if (SWIG_arg_fail(1)) SWIG_fail;
31312 {
31313 arg2 = wxString_in_helper(obj1);
31314 if (arg2 == NULL) SWIG_fail;
31315 temp2 = true;
31316 }
31317 {
31318 PyThreadState* __tstate = wxPyBeginAllowThreads();
31319 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31320
31321 wxPyEndAllowThreads(__tstate);
31322 if (PyErr_Occurred()) SWIG_fail;
31323 }
31324 Py_INCREF(Py_None); resultobj = Py_None;
31325 {
31326 if (temp2)
31327 delete arg2;
31328 }
31329 return resultobj;
31330 fail:
31331 {
31332 if (temp2)
31333 delete arg2;
31334 }
31335 return NULL;
31336 }
31337
31338
31339 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31340 PyObject *resultobj;
31341 wxWindow *arg1 = (wxWindow *) 0 ;
31342 wxString result;
31343 PyObject * obj0 = 0 ;
31344 char *kwnames[] = {
31345 (char *) "self", NULL
31346 };
31347
31348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31350 if (SWIG_arg_fail(1)) SWIG_fail;
31351 {
31352 PyThreadState* __tstate = wxPyBeginAllowThreads();
31353 result = ((wxWindow const *)arg1)->GetHelpText();
31354
31355 wxPyEndAllowThreads(__tstate);
31356 if (PyErr_Occurred()) SWIG_fail;
31357 }
31358 {
31359 #if wxUSE_UNICODE
31360 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31361 #else
31362 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31363 #endif
31364 }
31365 return resultobj;
31366 fail:
31367 return NULL;
31368 }
31369
31370
31371 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31372 PyObject *resultobj;
31373 wxWindow *arg1 = (wxWindow *) 0 ;
31374 wxString *arg2 = 0 ;
31375 bool temp2 = false ;
31376 PyObject * obj0 = 0 ;
31377 PyObject * obj1 = 0 ;
31378 char *kwnames[] = {
31379 (char *) "self",(char *) "tip", NULL
31380 };
31381
31382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31384 if (SWIG_arg_fail(1)) SWIG_fail;
31385 {
31386 arg2 = wxString_in_helper(obj1);
31387 if (arg2 == NULL) SWIG_fail;
31388 temp2 = true;
31389 }
31390 {
31391 PyThreadState* __tstate = wxPyBeginAllowThreads();
31392 (arg1)->SetToolTip((wxString const &)*arg2);
31393
31394 wxPyEndAllowThreads(__tstate);
31395 if (PyErr_Occurred()) SWIG_fail;
31396 }
31397 Py_INCREF(Py_None); resultobj = Py_None;
31398 {
31399 if (temp2)
31400 delete arg2;
31401 }
31402 return resultobj;
31403 fail:
31404 {
31405 if (temp2)
31406 delete arg2;
31407 }
31408 return NULL;
31409 }
31410
31411
31412 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31413 PyObject *resultobj;
31414 wxWindow *arg1 = (wxWindow *) 0 ;
31415 wxToolTip *arg2 = (wxToolTip *) 0 ;
31416 PyObject * obj0 = 0 ;
31417 PyObject * obj1 = 0 ;
31418 char *kwnames[] = {
31419 (char *) "self",(char *) "tip", NULL
31420 };
31421
31422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31424 if (SWIG_arg_fail(1)) SWIG_fail;
31425 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31426 if (SWIG_arg_fail(2)) SWIG_fail;
31427 {
31428 PyThreadState* __tstate = wxPyBeginAllowThreads();
31429 (arg1)->SetToolTip(arg2);
31430
31431 wxPyEndAllowThreads(__tstate);
31432 if (PyErr_Occurred()) SWIG_fail;
31433 }
31434 Py_INCREF(Py_None); resultobj = Py_None;
31435 return resultobj;
31436 fail:
31437 return NULL;
31438 }
31439
31440
31441 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31442 PyObject *resultobj;
31443 wxWindow *arg1 = (wxWindow *) 0 ;
31444 wxToolTip *result;
31445 PyObject * obj0 = 0 ;
31446 char *kwnames[] = {
31447 (char *) "self", NULL
31448 };
31449
31450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31452 if (SWIG_arg_fail(1)) SWIG_fail;
31453 {
31454 PyThreadState* __tstate = wxPyBeginAllowThreads();
31455 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31456
31457 wxPyEndAllowThreads(__tstate);
31458 if (PyErr_Occurred()) SWIG_fail;
31459 }
31460 {
31461 resultobj = wxPyMake_wxObject(result, 0);
31462 }
31463 return resultobj;
31464 fail:
31465 return NULL;
31466 }
31467
31468
31469 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31470 PyObject *resultobj;
31471 wxWindow *arg1 = (wxWindow *) 0 ;
31472 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31473 PyObject * obj0 = 0 ;
31474 PyObject * obj1 = 0 ;
31475 char *kwnames[] = {
31476 (char *) "self",(char *) "dropTarget", NULL
31477 };
31478
31479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) 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_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31483 if (SWIG_arg_fail(2)) SWIG_fail;
31484 {
31485 PyThreadState* __tstate = wxPyBeginAllowThreads();
31486 (arg1)->SetDropTarget(arg2);
31487
31488 wxPyEndAllowThreads(__tstate);
31489 if (PyErr_Occurred()) SWIG_fail;
31490 }
31491 Py_INCREF(Py_None); resultobj = Py_None;
31492 return resultobj;
31493 fail:
31494 return NULL;
31495 }
31496
31497
31498 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31499 PyObject *resultobj;
31500 wxWindow *arg1 = (wxWindow *) 0 ;
31501 wxPyDropTarget *result;
31502 PyObject * obj0 = 0 ;
31503 char *kwnames[] = {
31504 (char *) "self", NULL
31505 };
31506
31507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31509 if (SWIG_arg_fail(1)) SWIG_fail;
31510 {
31511 PyThreadState* __tstate = wxPyBeginAllowThreads();
31512 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31513
31514 wxPyEndAllowThreads(__tstate);
31515 if (PyErr_Occurred()) SWIG_fail;
31516 }
31517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31518 return resultobj;
31519 fail:
31520 return NULL;
31521 }
31522
31523
31524 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31525 PyObject *resultobj;
31526 wxWindow *arg1 = (wxWindow *) 0 ;
31527 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31528 PyObject * obj0 = 0 ;
31529 PyObject * obj1 = 0 ;
31530 char *kwnames[] = {
31531 (char *) "self",(char *) "constraints", NULL
31532 };
31533
31534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31536 if (SWIG_arg_fail(1)) SWIG_fail;
31537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31538 if (SWIG_arg_fail(2)) SWIG_fail;
31539 {
31540 PyThreadState* __tstate = wxPyBeginAllowThreads();
31541 (arg1)->SetConstraints(arg2);
31542
31543 wxPyEndAllowThreads(__tstate);
31544 if (PyErr_Occurred()) SWIG_fail;
31545 }
31546 Py_INCREF(Py_None); resultobj = Py_None;
31547 return resultobj;
31548 fail:
31549 return NULL;
31550 }
31551
31552
31553 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31554 PyObject *resultobj;
31555 wxWindow *arg1 = (wxWindow *) 0 ;
31556 wxLayoutConstraints *result;
31557 PyObject * obj0 = 0 ;
31558 char *kwnames[] = {
31559 (char *) "self", NULL
31560 };
31561
31562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31564 if (SWIG_arg_fail(1)) SWIG_fail;
31565 {
31566 PyThreadState* __tstate = wxPyBeginAllowThreads();
31567 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31568
31569 wxPyEndAllowThreads(__tstate);
31570 if (PyErr_Occurred()) SWIG_fail;
31571 }
31572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31573 return resultobj;
31574 fail:
31575 return NULL;
31576 }
31577
31578
31579 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31580 PyObject *resultobj;
31581 wxWindow *arg1 = (wxWindow *) 0 ;
31582 bool arg2 ;
31583 PyObject * obj0 = 0 ;
31584 PyObject * obj1 = 0 ;
31585 char *kwnames[] = {
31586 (char *) "self",(char *) "autoLayout", NULL
31587 };
31588
31589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31591 if (SWIG_arg_fail(1)) SWIG_fail;
31592 {
31593 arg2 = (bool)(SWIG_As_bool(obj1));
31594 if (SWIG_arg_fail(2)) SWIG_fail;
31595 }
31596 {
31597 PyThreadState* __tstate = wxPyBeginAllowThreads();
31598 (arg1)->SetAutoLayout(arg2);
31599
31600 wxPyEndAllowThreads(__tstate);
31601 if (PyErr_Occurred()) SWIG_fail;
31602 }
31603 Py_INCREF(Py_None); resultobj = Py_None;
31604 return resultobj;
31605 fail:
31606 return NULL;
31607 }
31608
31609
31610 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31611 PyObject *resultobj;
31612 wxWindow *arg1 = (wxWindow *) 0 ;
31613 bool result;
31614 PyObject * obj0 = 0 ;
31615 char *kwnames[] = {
31616 (char *) "self", NULL
31617 };
31618
31619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31621 if (SWIG_arg_fail(1)) SWIG_fail;
31622 {
31623 PyThreadState* __tstate = wxPyBeginAllowThreads();
31624 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31625
31626 wxPyEndAllowThreads(__tstate);
31627 if (PyErr_Occurred()) SWIG_fail;
31628 }
31629 {
31630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31631 }
31632 return resultobj;
31633 fail:
31634 return NULL;
31635 }
31636
31637
31638 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31639 PyObject *resultobj;
31640 wxWindow *arg1 = (wxWindow *) 0 ;
31641 bool result;
31642 PyObject * obj0 = 0 ;
31643 char *kwnames[] = {
31644 (char *) "self", NULL
31645 };
31646
31647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31649 if (SWIG_arg_fail(1)) SWIG_fail;
31650 {
31651 PyThreadState* __tstate = wxPyBeginAllowThreads();
31652 result = (bool)(arg1)->Layout();
31653
31654 wxPyEndAllowThreads(__tstate);
31655 if (PyErr_Occurred()) SWIG_fail;
31656 }
31657 {
31658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31659 }
31660 return resultobj;
31661 fail:
31662 return NULL;
31663 }
31664
31665
31666 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31667 PyObject *resultobj;
31668 wxWindow *arg1 = (wxWindow *) 0 ;
31669 wxSizer *arg2 = (wxSizer *) 0 ;
31670 bool arg3 = (bool) true ;
31671 PyObject * obj0 = 0 ;
31672 PyObject * obj1 = 0 ;
31673 PyObject * obj2 = 0 ;
31674 char *kwnames[] = {
31675 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31676 };
31677
31678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31680 if (SWIG_arg_fail(1)) SWIG_fail;
31681 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31682 if (SWIG_arg_fail(2)) SWIG_fail;
31683 if (obj2) {
31684 {
31685 arg3 = (bool)(SWIG_As_bool(obj2));
31686 if (SWIG_arg_fail(3)) SWIG_fail;
31687 }
31688 }
31689 {
31690 PyThreadState* __tstate = wxPyBeginAllowThreads();
31691 (arg1)->SetSizer(arg2,arg3);
31692
31693 wxPyEndAllowThreads(__tstate);
31694 if (PyErr_Occurred()) SWIG_fail;
31695 }
31696 Py_INCREF(Py_None); resultobj = Py_None;
31697 return resultobj;
31698 fail:
31699 return NULL;
31700 }
31701
31702
31703 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31704 PyObject *resultobj;
31705 wxWindow *arg1 = (wxWindow *) 0 ;
31706 wxSizer *arg2 = (wxSizer *) 0 ;
31707 bool arg3 = (bool) true ;
31708 PyObject * obj0 = 0 ;
31709 PyObject * obj1 = 0 ;
31710 PyObject * obj2 = 0 ;
31711 char *kwnames[] = {
31712 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31713 };
31714
31715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31717 if (SWIG_arg_fail(1)) SWIG_fail;
31718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31719 if (SWIG_arg_fail(2)) SWIG_fail;
31720 if (obj2) {
31721 {
31722 arg3 = (bool)(SWIG_As_bool(obj2));
31723 if (SWIG_arg_fail(3)) SWIG_fail;
31724 }
31725 }
31726 {
31727 PyThreadState* __tstate = wxPyBeginAllowThreads();
31728 (arg1)->SetSizerAndFit(arg2,arg3);
31729
31730 wxPyEndAllowThreads(__tstate);
31731 if (PyErr_Occurred()) SWIG_fail;
31732 }
31733 Py_INCREF(Py_None); resultobj = Py_None;
31734 return resultobj;
31735 fail:
31736 return NULL;
31737 }
31738
31739
31740 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31741 PyObject *resultobj;
31742 wxWindow *arg1 = (wxWindow *) 0 ;
31743 wxSizer *result;
31744 PyObject * obj0 = 0 ;
31745 char *kwnames[] = {
31746 (char *) "self", NULL
31747 };
31748
31749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31751 if (SWIG_arg_fail(1)) SWIG_fail;
31752 {
31753 PyThreadState* __tstate = wxPyBeginAllowThreads();
31754 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31755
31756 wxPyEndAllowThreads(__tstate);
31757 if (PyErr_Occurred()) SWIG_fail;
31758 }
31759 {
31760 resultobj = wxPyMake_wxSizer(result, 0);
31761 }
31762 return resultobj;
31763 fail:
31764 return NULL;
31765 }
31766
31767
31768 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31769 PyObject *resultobj;
31770 wxWindow *arg1 = (wxWindow *) 0 ;
31771 wxSizer *arg2 = (wxSizer *) 0 ;
31772 PyObject * obj0 = 0 ;
31773 PyObject * obj1 = 0 ;
31774 char *kwnames[] = {
31775 (char *) "self",(char *) "sizer", NULL
31776 };
31777
31778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31780 if (SWIG_arg_fail(1)) SWIG_fail;
31781 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31782 if (SWIG_arg_fail(2)) SWIG_fail;
31783 {
31784 PyThreadState* __tstate = wxPyBeginAllowThreads();
31785 (arg1)->SetContainingSizer(arg2);
31786
31787 wxPyEndAllowThreads(__tstate);
31788 if (PyErr_Occurred()) SWIG_fail;
31789 }
31790 Py_INCREF(Py_None); resultobj = Py_None;
31791 return resultobj;
31792 fail:
31793 return NULL;
31794 }
31795
31796
31797 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31798 PyObject *resultobj;
31799 wxWindow *arg1 = (wxWindow *) 0 ;
31800 wxSizer *result;
31801 PyObject * obj0 = 0 ;
31802 char *kwnames[] = {
31803 (char *) "self", NULL
31804 };
31805
31806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31808 if (SWIG_arg_fail(1)) SWIG_fail;
31809 {
31810 PyThreadState* __tstate = wxPyBeginAllowThreads();
31811 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31812
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 {
31817 resultobj = wxPyMake_wxSizer(result, 0);
31818 }
31819 return resultobj;
31820 fail:
31821 return NULL;
31822 }
31823
31824
31825 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31826 PyObject *resultobj;
31827 wxWindow *arg1 = (wxWindow *) 0 ;
31828 PyObject * obj0 = 0 ;
31829 char *kwnames[] = {
31830 (char *) "self", NULL
31831 };
31832
31833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31835 if (SWIG_arg_fail(1)) SWIG_fail;
31836 {
31837 PyThreadState* __tstate = wxPyBeginAllowThreads();
31838 (arg1)->InheritAttributes();
31839
31840 wxPyEndAllowThreads(__tstate);
31841 if (PyErr_Occurred()) SWIG_fail;
31842 }
31843 Py_INCREF(Py_None); resultobj = Py_None;
31844 return resultobj;
31845 fail:
31846 return NULL;
31847 }
31848
31849
31850 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31851 PyObject *resultobj;
31852 wxWindow *arg1 = (wxWindow *) 0 ;
31853 bool result;
31854 PyObject * obj0 = 0 ;
31855 char *kwnames[] = {
31856 (char *) "self", NULL
31857 };
31858
31859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31861 if (SWIG_arg_fail(1)) SWIG_fail;
31862 {
31863 PyThreadState* __tstate = wxPyBeginAllowThreads();
31864 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31865
31866 wxPyEndAllowThreads(__tstate);
31867 if (PyErr_Occurred()) SWIG_fail;
31868 }
31869 {
31870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31871 }
31872 return resultobj;
31873 fail:
31874 return NULL;
31875 }
31876
31877
31878 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31879 PyObject *obj;
31880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31881 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31882 Py_INCREF(obj);
31883 return Py_BuildValue((char *)"");
31884 }
31885 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31886 PyObject *resultobj;
31887 long arg1 ;
31888 wxWindow *arg2 = (wxWindow *) NULL ;
31889 wxWindow *result;
31890 PyObject * obj0 = 0 ;
31891 PyObject * obj1 = 0 ;
31892 char *kwnames[] = {
31893 (char *) "id",(char *) "parent", NULL
31894 };
31895
31896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31897 {
31898 arg1 = (long)(SWIG_As_long(obj0));
31899 if (SWIG_arg_fail(1)) SWIG_fail;
31900 }
31901 if (obj1) {
31902 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31903 if (SWIG_arg_fail(2)) SWIG_fail;
31904 }
31905 {
31906 if (!wxPyCheckForApp()) SWIG_fail;
31907 PyThreadState* __tstate = wxPyBeginAllowThreads();
31908 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31909
31910 wxPyEndAllowThreads(__tstate);
31911 if (PyErr_Occurred()) SWIG_fail;
31912 }
31913 {
31914 resultobj = wxPyMake_wxObject(result, 0);
31915 }
31916 return resultobj;
31917 fail:
31918 return NULL;
31919 }
31920
31921
31922 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31923 PyObject *resultobj;
31924 wxString *arg1 = 0 ;
31925 wxWindow *arg2 = (wxWindow *) NULL ;
31926 wxWindow *result;
31927 bool temp1 = false ;
31928 PyObject * obj0 = 0 ;
31929 PyObject * obj1 = 0 ;
31930 char *kwnames[] = {
31931 (char *) "name",(char *) "parent", NULL
31932 };
31933
31934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31935 {
31936 arg1 = wxString_in_helper(obj0);
31937 if (arg1 == NULL) SWIG_fail;
31938 temp1 = true;
31939 }
31940 if (obj1) {
31941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31942 if (SWIG_arg_fail(2)) SWIG_fail;
31943 }
31944 {
31945 if (!wxPyCheckForApp()) SWIG_fail;
31946 PyThreadState* __tstate = wxPyBeginAllowThreads();
31947 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31948
31949 wxPyEndAllowThreads(__tstate);
31950 if (PyErr_Occurred()) SWIG_fail;
31951 }
31952 {
31953 resultobj = wxPyMake_wxObject(result, 0);
31954 }
31955 {
31956 if (temp1)
31957 delete arg1;
31958 }
31959 return resultobj;
31960 fail:
31961 {
31962 if (temp1)
31963 delete arg1;
31964 }
31965 return NULL;
31966 }
31967
31968
31969 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31970 PyObject *resultobj;
31971 wxString *arg1 = 0 ;
31972 wxWindow *arg2 = (wxWindow *) NULL ;
31973 wxWindow *result;
31974 bool temp1 = false ;
31975 PyObject * obj0 = 0 ;
31976 PyObject * obj1 = 0 ;
31977 char *kwnames[] = {
31978 (char *) "label",(char *) "parent", NULL
31979 };
31980
31981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31982 {
31983 arg1 = wxString_in_helper(obj0);
31984 if (arg1 == NULL) SWIG_fail;
31985 temp1 = true;
31986 }
31987 if (obj1) {
31988 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31989 if (SWIG_arg_fail(2)) SWIG_fail;
31990 }
31991 {
31992 if (!wxPyCheckForApp()) SWIG_fail;
31993 PyThreadState* __tstate = wxPyBeginAllowThreads();
31994 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31995
31996 wxPyEndAllowThreads(__tstate);
31997 if (PyErr_Occurred()) SWIG_fail;
31998 }
31999 {
32000 resultobj = wxPyMake_wxObject(result, 0);
32001 }
32002 {
32003 if (temp1)
32004 delete arg1;
32005 }
32006 return resultobj;
32007 fail:
32008 {
32009 if (temp1)
32010 delete arg1;
32011 }
32012 return NULL;
32013 }
32014
32015
32016 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32017 PyObject *resultobj;
32018 wxWindow *arg1 = (wxWindow *) 0 ;
32019 unsigned long arg2 ;
32020 wxWindow *result;
32021 PyObject * obj0 = 0 ;
32022 PyObject * obj1 = 0 ;
32023 char *kwnames[] = {
32024 (char *) "parent",(char *) "_hWnd", NULL
32025 };
32026
32027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32029 if (SWIG_arg_fail(1)) SWIG_fail;
32030 {
32031 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32032 if (SWIG_arg_fail(2)) SWIG_fail;
32033 }
32034 {
32035 PyThreadState* __tstate = wxPyBeginAllowThreads();
32036 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32037
32038 wxPyEndAllowThreads(__tstate);
32039 if (PyErr_Occurred()) SWIG_fail;
32040 }
32041 {
32042 resultobj = wxPyMake_wxObject(result, 0);
32043 }
32044 return resultobj;
32045 fail:
32046 return NULL;
32047 }
32048
32049
32050 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32051 PyObject *resultobj;
32052 wxValidator *result;
32053 char *kwnames[] = {
32054 NULL
32055 };
32056
32057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32058 {
32059 PyThreadState* __tstate = wxPyBeginAllowThreads();
32060 result = (wxValidator *)new wxValidator();
32061
32062 wxPyEndAllowThreads(__tstate);
32063 if (PyErr_Occurred()) SWIG_fail;
32064 }
32065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32066 return resultobj;
32067 fail:
32068 return NULL;
32069 }
32070
32071
32072 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32073 PyObject *resultobj;
32074 wxValidator *arg1 = (wxValidator *) 0 ;
32075 wxValidator *result;
32076 PyObject * obj0 = 0 ;
32077 char *kwnames[] = {
32078 (char *) "self", NULL
32079 };
32080
32081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32083 if (SWIG_arg_fail(1)) SWIG_fail;
32084 {
32085 PyThreadState* __tstate = wxPyBeginAllowThreads();
32086 result = (wxValidator *)(arg1)->Clone();
32087
32088 wxPyEndAllowThreads(__tstate);
32089 if (PyErr_Occurred()) SWIG_fail;
32090 }
32091 {
32092 resultobj = wxPyMake_wxObject(result, 0);
32093 }
32094 return resultobj;
32095 fail:
32096 return NULL;
32097 }
32098
32099
32100 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32101 PyObject *resultobj;
32102 wxValidator *arg1 = (wxValidator *) 0 ;
32103 wxWindow *arg2 = (wxWindow *) 0 ;
32104 bool result;
32105 PyObject * obj0 = 0 ;
32106 PyObject * obj1 = 0 ;
32107 char *kwnames[] = {
32108 (char *) "self",(char *) "parent", NULL
32109 };
32110
32111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32113 if (SWIG_arg_fail(1)) SWIG_fail;
32114 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32115 if (SWIG_arg_fail(2)) SWIG_fail;
32116 {
32117 PyThreadState* __tstate = wxPyBeginAllowThreads();
32118 result = (bool)(arg1)->Validate(arg2);
32119
32120 wxPyEndAllowThreads(__tstate);
32121 if (PyErr_Occurred()) SWIG_fail;
32122 }
32123 {
32124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32125 }
32126 return resultobj;
32127 fail:
32128 return NULL;
32129 }
32130
32131
32132 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32133 PyObject *resultobj;
32134 wxValidator *arg1 = (wxValidator *) 0 ;
32135 bool result;
32136 PyObject * obj0 = 0 ;
32137 char *kwnames[] = {
32138 (char *) "self", NULL
32139 };
32140
32141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32143 if (SWIG_arg_fail(1)) SWIG_fail;
32144 {
32145 PyThreadState* __tstate = wxPyBeginAllowThreads();
32146 result = (bool)(arg1)->TransferToWindow();
32147
32148 wxPyEndAllowThreads(__tstate);
32149 if (PyErr_Occurred()) SWIG_fail;
32150 }
32151 {
32152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32153 }
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32161 PyObject *resultobj;
32162 wxValidator *arg1 = (wxValidator *) 0 ;
32163 bool result;
32164 PyObject * obj0 = 0 ;
32165 char *kwnames[] = {
32166 (char *) "self", NULL
32167 };
32168
32169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32171 if (SWIG_arg_fail(1)) SWIG_fail;
32172 {
32173 PyThreadState* __tstate = wxPyBeginAllowThreads();
32174 result = (bool)(arg1)->TransferFromWindow();
32175
32176 wxPyEndAllowThreads(__tstate);
32177 if (PyErr_Occurred()) SWIG_fail;
32178 }
32179 {
32180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32181 }
32182 return resultobj;
32183 fail:
32184 return NULL;
32185 }
32186
32187
32188 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32189 PyObject *resultobj;
32190 wxValidator *arg1 = (wxValidator *) 0 ;
32191 wxWindow *result;
32192 PyObject * obj0 = 0 ;
32193 char *kwnames[] = {
32194 (char *) "self", NULL
32195 };
32196
32197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32199 if (SWIG_arg_fail(1)) SWIG_fail;
32200 {
32201 PyThreadState* __tstate = wxPyBeginAllowThreads();
32202 result = (wxWindow *)(arg1)->GetWindow();
32203
32204 wxPyEndAllowThreads(__tstate);
32205 if (PyErr_Occurred()) SWIG_fail;
32206 }
32207 {
32208 resultobj = wxPyMake_wxObject(result, 0);
32209 }
32210 return resultobj;
32211 fail:
32212 return NULL;
32213 }
32214
32215
32216 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32217 PyObject *resultobj;
32218 wxValidator *arg1 = (wxValidator *) 0 ;
32219 wxWindow *arg2 = (wxWindow *) 0 ;
32220 PyObject * obj0 = 0 ;
32221 PyObject * obj1 = 0 ;
32222 char *kwnames[] = {
32223 (char *) "self",(char *) "window", NULL
32224 };
32225
32226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32228 if (SWIG_arg_fail(1)) SWIG_fail;
32229 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32230 if (SWIG_arg_fail(2)) SWIG_fail;
32231 {
32232 PyThreadState* __tstate = wxPyBeginAllowThreads();
32233 (arg1)->SetWindow(arg2);
32234
32235 wxPyEndAllowThreads(__tstate);
32236 if (PyErr_Occurred()) SWIG_fail;
32237 }
32238 Py_INCREF(Py_None); resultobj = Py_None;
32239 return resultobj;
32240 fail:
32241 return NULL;
32242 }
32243
32244
32245 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32246 PyObject *resultobj;
32247 bool result;
32248 char *kwnames[] = {
32249 NULL
32250 };
32251
32252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32253 {
32254 PyThreadState* __tstate = wxPyBeginAllowThreads();
32255 result = (bool)wxValidator::IsSilent();
32256
32257 wxPyEndAllowThreads(__tstate);
32258 if (PyErr_Occurred()) SWIG_fail;
32259 }
32260 {
32261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32262 }
32263 return resultobj;
32264 fail:
32265 return NULL;
32266 }
32267
32268
32269 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32270 PyObject *resultobj;
32271 int arg1 = (int) true ;
32272 PyObject * obj0 = 0 ;
32273 char *kwnames[] = {
32274 (char *) "doIt", NULL
32275 };
32276
32277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32278 if (obj0) {
32279 {
32280 arg1 = (int)(SWIG_As_int(obj0));
32281 if (SWIG_arg_fail(1)) SWIG_fail;
32282 }
32283 }
32284 {
32285 PyThreadState* __tstate = wxPyBeginAllowThreads();
32286 wxValidator::SetBellOnError(arg1);
32287
32288 wxPyEndAllowThreads(__tstate);
32289 if (PyErr_Occurred()) SWIG_fail;
32290 }
32291 Py_INCREF(Py_None); resultobj = Py_None;
32292 return resultobj;
32293 fail:
32294 return NULL;
32295 }
32296
32297
32298 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32299 PyObject *obj;
32300 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32301 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32302 Py_INCREF(obj);
32303 return Py_BuildValue((char *)"");
32304 }
32305 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32306 PyObject *resultobj;
32307 wxPyValidator *result;
32308 char *kwnames[] = {
32309 NULL
32310 };
32311
32312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32313 {
32314 PyThreadState* __tstate = wxPyBeginAllowThreads();
32315 result = (wxPyValidator *)new wxPyValidator();
32316
32317 wxPyEndAllowThreads(__tstate);
32318 if (PyErr_Occurred()) SWIG_fail;
32319 }
32320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32321 return resultobj;
32322 fail:
32323 return NULL;
32324 }
32325
32326
32327 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32328 PyObject *resultobj;
32329 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32330 PyObject *arg2 = (PyObject *) 0 ;
32331 PyObject *arg3 = (PyObject *) 0 ;
32332 int arg4 = (int) true ;
32333 PyObject * obj0 = 0 ;
32334 PyObject * obj1 = 0 ;
32335 PyObject * obj2 = 0 ;
32336 PyObject * obj3 = 0 ;
32337 char *kwnames[] = {
32338 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32339 };
32340
32341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32343 if (SWIG_arg_fail(1)) SWIG_fail;
32344 arg2 = obj1;
32345 arg3 = obj2;
32346 if (obj3) {
32347 {
32348 arg4 = (int)(SWIG_As_int(obj3));
32349 if (SWIG_arg_fail(4)) SWIG_fail;
32350 }
32351 }
32352 {
32353 PyThreadState* __tstate = wxPyBeginAllowThreads();
32354 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32355
32356 wxPyEndAllowThreads(__tstate);
32357 if (PyErr_Occurred()) SWIG_fail;
32358 }
32359 Py_INCREF(Py_None); resultobj = Py_None;
32360 return resultobj;
32361 fail:
32362 return NULL;
32363 }
32364
32365
32366 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32367 PyObject *obj;
32368 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32369 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32370 Py_INCREF(obj);
32371 return Py_BuildValue((char *)"");
32372 }
32373 static int _wrap_DefaultValidator_set(PyObject *) {
32374 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32375 return 1;
32376 }
32377
32378
32379 static PyObject *_wrap_DefaultValidator_get(void) {
32380 PyObject *pyobj;
32381
32382 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32383 return pyobj;
32384 }
32385
32386
32387 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32388 PyObject *resultobj;
32389 wxString const &arg1_defvalue = wxPyEmptyString ;
32390 wxString *arg1 = (wxString *) &arg1_defvalue ;
32391 long arg2 = (long) 0 ;
32392 wxMenu *result;
32393 bool temp1 = false ;
32394 PyObject * obj0 = 0 ;
32395 PyObject * obj1 = 0 ;
32396 char *kwnames[] = {
32397 (char *) "title",(char *) "style", NULL
32398 };
32399
32400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32401 if (obj0) {
32402 {
32403 arg1 = wxString_in_helper(obj0);
32404 if (arg1 == NULL) SWIG_fail;
32405 temp1 = true;
32406 }
32407 }
32408 if (obj1) {
32409 {
32410 arg2 = (long)(SWIG_As_long(obj1));
32411 if (SWIG_arg_fail(2)) SWIG_fail;
32412 }
32413 }
32414 {
32415 if (!wxPyCheckForApp()) SWIG_fail;
32416 PyThreadState* __tstate = wxPyBeginAllowThreads();
32417 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32418
32419 wxPyEndAllowThreads(__tstate);
32420 if (PyErr_Occurred()) SWIG_fail;
32421 }
32422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32423 {
32424 if (temp1)
32425 delete arg1;
32426 }
32427 return resultobj;
32428 fail:
32429 {
32430 if (temp1)
32431 delete arg1;
32432 }
32433 return NULL;
32434 }
32435
32436
32437 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32438 PyObject *resultobj;
32439 wxMenu *arg1 = (wxMenu *) 0 ;
32440 int arg2 ;
32441 wxString *arg3 = 0 ;
32442 wxString const &arg4_defvalue = wxPyEmptyString ;
32443 wxString *arg4 = (wxString *) &arg4_defvalue ;
32444 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32445 wxMenuItem *result;
32446 bool temp3 = false ;
32447 bool temp4 = false ;
32448 PyObject * obj0 = 0 ;
32449 PyObject * obj1 = 0 ;
32450 PyObject * obj2 = 0 ;
32451 PyObject * obj3 = 0 ;
32452 PyObject * obj4 = 0 ;
32453 char *kwnames[] = {
32454 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32455 };
32456
32457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32459 if (SWIG_arg_fail(1)) SWIG_fail;
32460 {
32461 arg2 = (int)(SWIG_As_int(obj1));
32462 if (SWIG_arg_fail(2)) SWIG_fail;
32463 }
32464 {
32465 arg3 = wxString_in_helper(obj2);
32466 if (arg3 == NULL) SWIG_fail;
32467 temp3 = true;
32468 }
32469 if (obj3) {
32470 {
32471 arg4 = wxString_in_helper(obj3);
32472 if (arg4 == NULL) SWIG_fail;
32473 temp4 = true;
32474 }
32475 }
32476 if (obj4) {
32477 {
32478 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32479 if (SWIG_arg_fail(5)) SWIG_fail;
32480 }
32481 }
32482 {
32483 PyThreadState* __tstate = wxPyBeginAllowThreads();
32484 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32485
32486 wxPyEndAllowThreads(__tstate);
32487 if (PyErr_Occurred()) SWIG_fail;
32488 }
32489 {
32490 resultobj = wxPyMake_wxObject(result, 0);
32491 }
32492 {
32493 if (temp3)
32494 delete arg3;
32495 }
32496 {
32497 if (temp4)
32498 delete arg4;
32499 }
32500 return resultobj;
32501 fail:
32502 {
32503 if (temp3)
32504 delete arg3;
32505 }
32506 {
32507 if (temp4)
32508 delete arg4;
32509 }
32510 return NULL;
32511 }
32512
32513
32514 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32515 PyObject *resultobj;
32516 wxMenu *arg1 = (wxMenu *) 0 ;
32517 wxMenuItem *result;
32518 PyObject * obj0 = 0 ;
32519 char *kwnames[] = {
32520 (char *) "self", NULL
32521 };
32522
32523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32525 if (SWIG_arg_fail(1)) SWIG_fail;
32526 {
32527 PyThreadState* __tstate = wxPyBeginAllowThreads();
32528 result = (wxMenuItem *)(arg1)->AppendSeparator();
32529
32530 wxPyEndAllowThreads(__tstate);
32531 if (PyErr_Occurred()) SWIG_fail;
32532 }
32533 {
32534 resultobj = wxPyMake_wxObject(result, 0);
32535 }
32536 return resultobj;
32537 fail:
32538 return NULL;
32539 }
32540
32541
32542 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32543 PyObject *resultobj;
32544 wxMenu *arg1 = (wxMenu *) 0 ;
32545 int arg2 ;
32546 wxString *arg3 = 0 ;
32547 wxString const &arg4_defvalue = wxPyEmptyString ;
32548 wxString *arg4 = (wxString *) &arg4_defvalue ;
32549 wxMenuItem *result;
32550 bool temp3 = false ;
32551 bool temp4 = false ;
32552 PyObject * obj0 = 0 ;
32553 PyObject * obj1 = 0 ;
32554 PyObject * obj2 = 0 ;
32555 PyObject * obj3 = 0 ;
32556 char *kwnames[] = {
32557 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32558 };
32559
32560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32562 if (SWIG_arg_fail(1)) SWIG_fail;
32563 {
32564 arg2 = (int)(SWIG_As_int(obj1));
32565 if (SWIG_arg_fail(2)) SWIG_fail;
32566 }
32567 {
32568 arg3 = wxString_in_helper(obj2);
32569 if (arg3 == NULL) SWIG_fail;
32570 temp3 = true;
32571 }
32572 if (obj3) {
32573 {
32574 arg4 = wxString_in_helper(obj3);
32575 if (arg4 == NULL) SWIG_fail;
32576 temp4 = true;
32577 }
32578 }
32579 {
32580 PyThreadState* __tstate = wxPyBeginAllowThreads();
32581 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32582
32583 wxPyEndAllowThreads(__tstate);
32584 if (PyErr_Occurred()) SWIG_fail;
32585 }
32586 {
32587 resultobj = wxPyMake_wxObject(result, 0);
32588 }
32589 {
32590 if (temp3)
32591 delete arg3;
32592 }
32593 {
32594 if (temp4)
32595 delete arg4;
32596 }
32597 return resultobj;
32598 fail:
32599 {
32600 if (temp3)
32601 delete arg3;
32602 }
32603 {
32604 if (temp4)
32605 delete arg4;
32606 }
32607 return NULL;
32608 }
32609
32610
32611 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32612 PyObject *resultobj;
32613 wxMenu *arg1 = (wxMenu *) 0 ;
32614 int arg2 ;
32615 wxString *arg3 = 0 ;
32616 wxString const &arg4_defvalue = wxPyEmptyString ;
32617 wxString *arg4 = (wxString *) &arg4_defvalue ;
32618 wxMenuItem *result;
32619 bool temp3 = false ;
32620 bool temp4 = false ;
32621 PyObject * obj0 = 0 ;
32622 PyObject * obj1 = 0 ;
32623 PyObject * obj2 = 0 ;
32624 PyObject * obj3 = 0 ;
32625 char *kwnames[] = {
32626 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32627 };
32628
32629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32631 if (SWIG_arg_fail(1)) SWIG_fail;
32632 {
32633 arg2 = (int)(SWIG_As_int(obj1));
32634 if (SWIG_arg_fail(2)) SWIG_fail;
32635 }
32636 {
32637 arg3 = wxString_in_helper(obj2);
32638 if (arg3 == NULL) SWIG_fail;
32639 temp3 = true;
32640 }
32641 if (obj3) {
32642 {
32643 arg4 = wxString_in_helper(obj3);
32644 if (arg4 == NULL) SWIG_fail;
32645 temp4 = true;
32646 }
32647 }
32648 {
32649 PyThreadState* __tstate = wxPyBeginAllowThreads();
32650 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32651
32652 wxPyEndAllowThreads(__tstate);
32653 if (PyErr_Occurred()) SWIG_fail;
32654 }
32655 {
32656 resultobj = wxPyMake_wxObject(result, 0);
32657 }
32658 {
32659 if (temp3)
32660 delete arg3;
32661 }
32662 {
32663 if (temp4)
32664 delete arg4;
32665 }
32666 return resultobj;
32667 fail:
32668 {
32669 if (temp3)
32670 delete arg3;
32671 }
32672 {
32673 if (temp4)
32674 delete arg4;
32675 }
32676 return NULL;
32677 }
32678
32679
32680 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32681 PyObject *resultobj;
32682 wxMenu *arg1 = (wxMenu *) 0 ;
32683 int arg2 ;
32684 wxString *arg3 = 0 ;
32685 wxMenu *arg4 = (wxMenu *) 0 ;
32686 wxString const &arg5_defvalue = wxPyEmptyString ;
32687 wxString *arg5 = (wxString *) &arg5_defvalue ;
32688 wxMenuItem *result;
32689 bool temp3 = false ;
32690 bool temp5 = false ;
32691 PyObject * obj0 = 0 ;
32692 PyObject * obj1 = 0 ;
32693 PyObject * obj2 = 0 ;
32694 PyObject * obj3 = 0 ;
32695 PyObject * obj4 = 0 ;
32696 char *kwnames[] = {
32697 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32698 };
32699
32700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32702 if (SWIG_arg_fail(1)) SWIG_fail;
32703 {
32704 arg2 = (int)(SWIG_As_int(obj1));
32705 if (SWIG_arg_fail(2)) SWIG_fail;
32706 }
32707 {
32708 arg3 = wxString_in_helper(obj2);
32709 if (arg3 == NULL) SWIG_fail;
32710 temp3 = true;
32711 }
32712 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32713 if (SWIG_arg_fail(4)) SWIG_fail;
32714 if (obj4) {
32715 {
32716 arg5 = wxString_in_helper(obj4);
32717 if (arg5 == NULL) SWIG_fail;
32718 temp5 = true;
32719 }
32720 }
32721 {
32722 PyThreadState* __tstate = wxPyBeginAllowThreads();
32723 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32724
32725 wxPyEndAllowThreads(__tstate);
32726 if (PyErr_Occurred()) SWIG_fail;
32727 }
32728 {
32729 resultobj = wxPyMake_wxObject(result, 0);
32730 }
32731 {
32732 if (temp3)
32733 delete arg3;
32734 }
32735 {
32736 if (temp5)
32737 delete arg5;
32738 }
32739 return resultobj;
32740 fail:
32741 {
32742 if (temp3)
32743 delete arg3;
32744 }
32745 {
32746 if (temp5)
32747 delete arg5;
32748 }
32749 return NULL;
32750 }
32751
32752
32753 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32754 PyObject *resultobj;
32755 wxMenu *arg1 = (wxMenu *) 0 ;
32756 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32757 wxMenuItem *result;
32758 PyObject * obj0 = 0 ;
32759 PyObject * obj1 = 0 ;
32760 char *kwnames[] = {
32761 (char *) "self",(char *) "item", NULL
32762 };
32763
32764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32766 if (SWIG_arg_fail(1)) SWIG_fail;
32767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32768 if (SWIG_arg_fail(2)) SWIG_fail;
32769 {
32770 PyThreadState* __tstate = wxPyBeginAllowThreads();
32771 result = (wxMenuItem *)(arg1)->Append(arg2);
32772
32773 wxPyEndAllowThreads(__tstate);
32774 if (PyErr_Occurred()) SWIG_fail;
32775 }
32776 {
32777 resultobj = wxPyMake_wxObject(result, 0);
32778 }
32779 return resultobj;
32780 fail:
32781 return NULL;
32782 }
32783
32784
32785 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32786 PyObject *resultobj;
32787 wxMenu *arg1 = (wxMenu *) 0 ;
32788 PyObject * obj0 = 0 ;
32789 char *kwnames[] = {
32790 (char *) "self", NULL
32791 };
32792
32793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32795 if (SWIG_arg_fail(1)) SWIG_fail;
32796 {
32797 PyThreadState* __tstate = wxPyBeginAllowThreads();
32798 (arg1)->Break();
32799
32800 wxPyEndAllowThreads(__tstate);
32801 if (PyErr_Occurred()) SWIG_fail;
32802 }
32803 Py_INCREF(Py_None); resultobj = Py_None;
32804 return resultobj;
32805 fail:
32806 return NULL;
32807 }
32808
32809
32810 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32811 PyObject *resultobj;
32812 wxMenu *arg1 = (wxMenu *) 0 ;
32813 size_t arg2 ;
32814 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32815 wxMenuItem *result;
32816 PyObject * obj0 = 0 ;
32817 PyObject * obj1 = 0 ;
32818 PyObject * obj2 = 0 ;
32819 char *kwnames[] = {
32820 (char *) "self",(char *) "pos",(char *) "item", NULL
32821 };
32822
32823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32825 if (SWIG_arg_fail(1)) SWIG_fail;
32826 {
32827 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32828 if (SWIG_arg_fail(2)) SWIG_fail;
32829 }
32830 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32831 if (SWIG_arg_fail(3)) SWIG_fail;
32832 {
32833 PyThreadState* __tstate = wxPyBeginAllowThreads();
32834 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32835
32836 wxPyEndAllowThreads(__tstate);
32837 if (PyErr_Occurred()) SWIG_fail;
32838 }
32839 {
32840 resultobj = wxPyMake_wxObject(result, 0);
32841 }
32842 return resultobj;
32843 fail:
32844 return NULL;
32845 }
32846
32847
32848 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32849 PyObject *resultobj;
32850 wxMenu *arg1 = (wxMenu *) 0 ;
32851 size_t arg2 ;
32852 int arg3 ;
32853 wxString *arg4 = 0 ;
32854 wxString const &arg5_defvalue = wxPyEmptyString ;
32855 wxString *arg5 = (wxString *) &arg5_defvalue ;
32856 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32857 wxMenuItem *result;
32858 bool temp4 = false ;
32859 bool temp5 = false ;
32860 PyObject * obj0 = 0 ;
32861 PyObject * obj1 = 0 ;
32862 PyObject * obj2 = 0 ;
32863 PyObject * obj3 = 0 ;
32864 PyObject * obj4 = 0 ;
32865 PyObject * obj5 = 0 ;
32866 char *kwnames[] = {
32867 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32868 };
32869
32870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32872 if (SWIG_arg_fail(1)) SWIG_fail;
32873 {
32874 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32875 if (SWIG_arg_fail(2)) SWIG_fail;
32876 }
32877 {
32878 arg3 = (int)(SWIG_As_int(obj2));
32879 if (SWIG_arg_fail(3)) SWIG_fail;
32880 }
32881 {
32882 arg4 = wxString_in_helper(obj3);
32883 if (arg4 == NULL) SWIG_fail;
32884 temp4 = true;
32885 }
32886 if (obj4) {
32887 {
32888 arg5 = wxString_in_helper(obj4);
32889 if (arg5 == NULL) SWIG_fail;
32890 temp5 = true;
32891 }
32892 }
32893 if (obj5) {
32894 {
32895 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32896 if (SWIG_arg_fail(6)) SWIG_fail;
32897 }
32898 }
32899 {
32900 PyThreadState* __tstate = wxPyBeginAllowThreads();
32901 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32902
32903 wxPyEndAllowThreads(__tstate);
32904 if (PyErr_Occurred()) SWIG_fail;
32905 }
32906 {
32907 resultobj = wxPyMake_wxObject(result, 0);
32908 }
32909 {
32910 if (temp4)
32911 delete arg4;
32912 }
32913 {
32914 if (temp5)
32915 delete arg5;
32916 }
32917 return resultobj;
32918 fail:
32919 {
32920 if (temp4)
32921 delete arg4;
32922 }
32923 {
32924 if (temp5)
32925 delete arg5;
32926 }
32927 return NULL;
32928 }
32929
32930
32931 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32932 PyObject *resultobj;
32933 wxMenu *arg1 = (wxMenu *) 0 ;
32934 size_t arg2 ;
32935 wxMenuItem *result;
32936 PyObject * obj0 = 0 ;
32937 PyObject * obj1 = 0 ;
32938 char *kwnames[] = {
32939 (char *) "self",(char *) "pos", NULL
32940 };
32941
32942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32944 if (SWIG_arg_fail(1)) SWIG_fail;
32945 {
32946 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32947 if (SWIG_arg_fail(2)) SWIG_fail;
32948 }
32949 {
32950 PyThreadState* __tstate = wxPyBeginAllowThreads();
32951 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32952
32953 wxPyEndAllowThreads(__tstate);
32954 if (PyErr_Occurred()) SWIG_fail;
32955 }
32956 {
32957 resultobj = wxPyMake_wxObject(result, 0);
32958 }
32959 return resultobj;
32960 fail:
32961 return NULL;
32962 }
32963
32964
32965 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32966 PyObject *resultobj;
32967 wxMenu *arg1 = (wxMenu *) 0 ;
32968 size_t arg2 ;
32969 int arg3 ;
32970 wxString *arg4 = 0 ;
32971 wxString const &arg5_defvalue = wxPyEmptyString ;
32972 wxString *arg5 = (wxString *) &arg5_defvalue ;
32973 wxMenuItem *result;
32974 bool temp4 = false ;
32975 bool temp5 = false ;
32976 PyObject * obj0 = 0 ;
32977 PyObject * obj1 = 0 ;
32978 PyObject * obj2 = 0 ;
32979 PyObject * obj3 = 0 ;
32980 PyObject * obj4 = 0 ;
32981 char *kwnames[] = {
32982 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32983 };
32984
32985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32987 if (SWIG_arg_fail(1)) SWIG_fail;
32988 {
32989 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32990 if (SWIG_arg_fail(2)) SWIG_fail;
32991 }
32992 {
32993 arg3 = (int)(SWIG_As_int(obj2));
32994 if (SWIG_arg_fail(3)) SWIG_fail;
32995 }
32996 {
32997 arg4 = wxString_in_helper(obj3);
32998 if (arg4 == NULL) SWIG_fail;
32999 temp4 = true;
33000 }
33001 if (obj4) {
33002 {
33003 arg5 = wxString_in_helper(obj4);
33004 if (arg5 == NULL) SWIG_fail;
33005 temp5 = true;
33006 }
33007 }
33008 {
33009 PyThreadState* __tstate = wxPyBeginAllowThreads();
33010 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33011
33012 wxPyEndAllowThreads(__tstate);
33013 if (PyErr_Occurred()) SWIG_fail;
33014 }
33015 {
33016 resultobj = wxPyMake_wxObject(result, 0);
33017 }
33018 {
33019 if (temp4)
33020 delete arg4;
33021 }
33022 {
33023 if (temp5)
33024 delete arg5;
33025 }
33026 return resultobj;
33027 fail:
33028 {
33029 if (temp4)
33030 delete arg4;
33031 }
33032 {
33033 if (temp5)
33034 delete arg5;
33035 }
33036 return NULL;
33037 }
33038
33039
33040 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33041 PyObject *resultobj;
33042 wxMenu *arg1 = (wxMenu *) 0 ;
33043 size_t arg2 ;
33044 int arg3 ;
33045 wxString *arg4 = 0 ;
33046 wxString const &arg5_defvalue = wxPyEmptyString ;
33047 wxString *arg5 = (wxString *) &arg5_defvalue ;
33048 wxMenuItem *result;
33049 bool temp4 = false ;
33050 bool temp5 = false ;
33051 PyObject * obj0 = 0 ;
33052 PyObject * obj1 = 0 ;
33053 PyObject * obj2 = 0 ;
33054 PyObject * obj3 = 0 ;
33055 PyObject * obj4 = 0 ;
33056 char *kwnames[] = {
33057 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33058 };
33059
33060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33062 if (SWIG_arg_fail(1)) SWIG_fail;
33063 {
33064 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33065 if (SWIG_arg_fail(2)) SWIG_fail;
33066 }
33067 {
33068 arg3 = (int)(SWIG_As_int(obj2));
33069 if (SWIG_arg_fail(3)) SWIG_fail;
33070 }
33071 {
33072 arg4 = wxString_in_helper(obj3);
33073 if (arg4 == NULL) SWIG_fail;
33074 temp4 = true;
33075 }
33076 if (obj4) {
33077 {
33078 arg5 = wxString_in_helper(obj4);
33079 if (arg5 == NULL) SWIG_fail;
33080 temp5 = true;
33081 }
33082 }
33083 {
33084 PyThreadState* __tstate = wxPyBeginAllowThreads();
33085 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33086
33087 wxPyEndAllowThreads(__tstate);
33088 if (PyErr_Occurred()) SWIG_fail;
33089 }
33090 {
33091 resultobj = wxPyMake_wxObject(result, 0);
33092 }
33093 {
33094 if (temp4)
33095 delete arg4;
33096 }
33097 {
33098 if (temp5)
33099 delete arg5;
33100 }
33101 return resultobj;
33102 fail:
33103 {
33104 if (temp4)
33105 delete arg4;
33106 }
33107 {
33108 if (temp5)
33109 delete arg5;
33110 }
33111 return NULL;
33112 }
33113
33114
33115 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33116 PyObject *resultobj;
33117 wxMenu *arg1 = (wxMenu *) 0 ;
33118 size_t arg2 ;
33119 int arg3 ;
33120 wxString *arg4 = 0 ;
33121 wxMenu *arg5 = (wxMenu *) 0 ;
33122 wxString const &arg6_defvalue = wxPyEmptyString ;
33123 wxString *arg6 = (wxString *) &arg6_defvalue ;
33124 wxMenuItem *result;
33125 bool temp4 = false ;
33126 bool temp6 = false ;
33127 PyObject * obj0 = 0 ;
33128 PyObject * obj1 = 0 ;
33129 PyObject * obj2 = 0 ;
33130 PyObject * obj3 = 0 ;
33131 PyObject * obj4 = 0 ;
33132 PyObject * obj5 = 0 ;
33133 char *kwnames[] = {
33134 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33135 };
33136
33137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33139 if (SWIG_arg_fail(1)) SWIG_fail;
33140 {
33141 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33142 if (SWIG_arg_fail(2)) SWIG_fail;
33143 }
33144 {
33145 arg3 = (int)(SWIG_As_int(obj2));
33146 if (SWIG_arg_fail(3)) SWIG_fail;
33147 }
33148 {
33149 arg4 = wxString_in_helper(obj3);
33150 if (arg4 == NULL) SWIG_fail;
33151 temp4 = true;
33152 }
33153 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33154 if (SWIG_arg_fail(5)) SWIG_fail;
33155 if (obj5) {
33156 {
33157 arg6 = wxString_in_helper(obj5);
33158 if (arg6 == NULL) SWIG_fail;
33159 temp6 = true;
33160 }
33161 }
33162 {
33163 PyThreadState* __tstate = wxPyBeginAllowThreads();
33164 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33165
33166 wxPyEndAllowThreads(__tstate);
33167 if (PyErr_Occurred()) SWIG_fail;
33168 }
33169 {
33170 resultobj = wxPyMake_wxObject(result, 0);
33171 }
33172 {
33173 if (temp4)
33174 delete arg4;
33175 }
33176 {
33177 if (temp6)
33178 delete arg6;
33179 }
33180 return resultobj;
33181 fail:
33182 {
33183 if (temp4)
33184 delete arg4;
33185 }
33186 {
33187 if (temp6)
33188 delete arg6;
33189 }
33190 return NULL;
33191 }
33192
33193
33194 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33195 PyObject *resultobj;
33196 wxMenu *arg1 = (wxMenu *) 0 ;
33197 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33198 wxMenuItem *result;
33199 PyObject * obj0 = 0 ;
33200 PyObject * obj1 = 0 ;
33201 char *kwnames[] = {
33202 (char *) "self",(char *) "item", NULL
33203 };
33204
33205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33207 if (SWIG_arg_fail(1)) SWIG_fail;
33208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33209 if (SWIG_arg_fail(2)) SWIG_fail;
33210 {
33211 PyThreadState* __tstate = wxPyBeginAllowThreads();
33212 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33213
33214 wxPyEndAllowThreads(__tstate);
33215 if (PyErr_Occurred()) SWIG_fail;
33216 }
33217 {
33218 resultobj = wxPyMake_wxObject(result, 0);
33219 }
33220 return resultobj;
33221 fail:
33222 return NULL;
33223 }
33224
33225
33226 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33227 PyObject *resultobj;
33228 wxMenu *arg1 = (wxMenu *) 0 ;
33229 int arg2 ;
33230 wxString *arg3 = 0 ;
33231 wxString const &arg4_defvalue = wxPyEmptyString ;
33232 wxString *arg4 = (wxString *) &arg4_defvalue ;
33233 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33234 wxMenuItem *result;
33235 bool temp3 = false ;
33236 bool temp4 = false ;
33237 PyObject * obj0 = 0 ;
33238 PyObject * obj1 = 0 ;
33239 PyObject * obj2 = 0 ;
33240 PyObject * obj3 = 0 ;
33241 PyObject * obj4 = 0 ;
33242 char *kwnames[] = {
33243 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33244 };
33245
33246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33248 if (SWIG_arg_fail(1)) SWIG_fail;
33249 {
33250 arg2 = (int)(SWIG_As_int(obj1));
33251 if (SWIG_arg_fail(2)) SWIG_fail;
33252 }
33253 {
33254 arg3 = wxString_in_helper(obj2);
33255 if (arg3 == NULL) SWIG_fail;
33256 temp3 = true;
33257 }
33258 if (obj3) {
33259 {
33260 arg4 = wxString_in_helper(obj3);
33261 if (arg4 == NULL) SWIG_fail;
33262 temp4 = true;
33263 }
33264 }
33265 if (obj4) {
33266 {
33267 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33268 if (SWIG_arg_fail(5)) SWIG_fail;
33269 }
33270 }
33271 {
33272 PyThreadState* __tstate = wxPyBeginAllowThreads();
33273 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33274
33275 wxPyEndAllowThreads(__tstate);
33276 if (PyErr_Occurred()) SWIG_fail;
33277 }
33278 {
33279 resultobj = wxPyMake_wxObject(result, 0);
33280 }
33281 {
33282 if (temp3)
33283 delete arg3;
33284 }
33285 {
33286 if (temp4)
33287 delete arg4;
33288 }
33289 return resultobj;
33290 fail:
33291 {
33292 if (temp3)
33293 delete arg3;
33294 }
33295 {
33296 if (temp4)
33297 delete arg4;
33298 }
33299 return NULL;
33300 }
33301
33302
33303 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33304 PyObject *resultobj;
33305 wxMenu *arg1 = (wxMenu *) 0 ;
33306 wxMenuItem *result;
33307 PyObject * obj0 = 0 ;
33308 char *kwnames[] = {
33309 (char *) "self", NULL
33310 };
33311
33312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33314 if (SWIG_arg_fail(1)) SWIG_fail;
33315 {
33316 PyThreadState* __tstate = wxPyBeginAllowThreads();
33317 result = (wxMenuItem *)(arg1)->PrependSeparator();
33318
33319 wxPyEndAllowThreads(__tstate);
33320 if (PyErr_Occurred()) SWIG_fail;
33321 }
33322 {
33323 resultobj = wxPyMake_wxObject(result, 0);
33324 }
33325 return resultobj;
33326 fail:
33327 return NULL;
33328 }
33329
33330
33331 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33332 PyObject *resultobj;
33333 wxMenu *arg1 = (wxMenu *) 0 ;
33334 int arg2 ;
33335 wxString *arg3 = 0 ;
33336 wxString const &arg4_defvalue = wxPyEmptyString ;
33337 wxString *arg4 = (wxString *) &arg4_defvalue ;
33338 wxMenuItem *result;
33339 bool temp3 = false ;
33340 bool temp4 = false ;
33341 PyObject * obj0 = 0 ;
33342 PyObject * obj1 = 0 ;
33343 PyObject * obj2 = 0 ;
33344 PyObject * obj3 = 0 ;
33345 char *kwnames[] = {
33346 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33347 };
33348
33349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33351 if (SWIG_arg_fail(1)) SWIG_fail;
33352 {
33353 arg2 = (int)(SWIG_As_int(obj1));
33354 if (SWIG_arg_fail(2)) SWIG_fail;
33355 }
33356 {
33357 arg3 = wxString_in_helper(obj2);
33358 if (arg3 == NULL) SWIG_fail;
33359 temp3 = true;
33360 }
33361 if (obj3) {
33362 {
33363 arg4 = wxString_in_helper(obj3);
33364 if (arg4 == NULL) SWIG_fail;
33365 temp4 = true;
33366 }
33367 }
33368 {
33369 PyThreadState* __tstate = wxPyBeginAllowThreads();
33370 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33371
33372 wxPyEndAllowThreads(__tstate);
33373 if (PyErr_Occurred()) SWIG_fail;
33374 }
33375 {
33376 resultobj = wxPyMake_wxObject(result, 0);
33377 }
33378 {
33379 if (temp3)
33380 delete arg3;
33381 }
33382 {
33383 if (temp4)
33384 delete arg4;
33385 }
33386 return resultobj;
33387 fail:
33388 {
33389 if (temp3)
33390 delete arg3;
33391 }
33392 {
33393 if (temp4)
33394 delete arg4;
33395 }
33396 return NULL;
33397 }
33398
33399
33400 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33401 PyObject *resultobj;
33402 wxMenu *arg1 = (wxMenu *) 0 ;
33403 int arg2 ;
33404 wxString *arg3 = 0 ;
33405 wxString const &arg4_defvalue = wxPyEmptyString ;
33406 wxString *arg4 = (wxString *) &arg4_defvalue ;
33407 wxMenuItem *result;
33408 bool temp3 = false ;
33409 bool temp4 = false ;
33410 PyObject * obj0 = 0 ;
33411 PyObject * obj1 = 0 ;
33412 PyObject * obj2 = 0 ;
33413 PyObject * obj3 = 0 ;
33414 char *kwnames[] = {
33415 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33416 };
33417
33418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33420 if (SWIG_arg_fail(1)) SWIG_fail;
33421 {
33422 arg2 = (int)(SWIG_As_int(obj1));
33423 if (SWIG_arg_fail(2)) SWIG_fail;
33424 }
33425 {
33426 arg3 = wxString_in_helper(obj2);
33427 if (arg3 == NULL) SWIG_fail;
33428 temp3 = true;
33429 }
33430 if (obj3) {
33431 {
33432 arg4 = wxString_in_helper(obj3);
33433 if (arg4 == NULL) SWIG_fail;
33434 temp4 = true;
33435 }
33436 }
33437 {
33438 PyThreadState* __tstate = wxPyBeginAllowThreads();
33439 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33440
33441 wxPyEndAllowThreads(__tstate);
33442 if (PyErr_Occurred()) SWIG_fail;
33443 }
33444 {
33445 resultobj = wxPyMake_wxObject(result, 0);
33446 }
33447 {
33448 if (temp3)
33449 delete arg3;
33450 }
33451 {
33452 if (temp4)
33453 delete arg4;
33454 }
33455 return resultobj;
33456 fail:
33457 {
33458 if (temp3)
33459 delete arg3;
33460 }
33461 {
33462 if (temp4)
33463 delete arg4;
33464 }
33465 return NULL;
33466 }
33467
33468
33469 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33470 PyObject *resultobj;
33471 wxMenu *arg1 = (wxMenu *) 0 ;
33472 int arg2 ;
33473 wxString *arg3 = 0 ;
33474 wxMenu *arg4 = (wxMenu *) 0 ;
33475 wxString const &arg5_defvalue = wxPyEmptyString ;
33476 wxString *arg5 = (wxString *) &arg5_defvalue ;
33477 wxMenuItem *result;
33478 bool temp3 = false ;
33479 bool temp5 = false ;
33480 PyObject * obj0 = 0 ;
33481 PyObject * obj1 = 0 ;
33482 PyObject * obj2 = 0 ;
33483 PyObject * obj3 = 0 ;
33484 PyObject * obj4 = 0 ;
33485 char *kwnames[] = {
33486 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33487 };
33488
33489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33491 if (SWIG_arg_fail(1)) SWIG_fail;
33492 {
33493 arg2 = (int)(SWIG_As_int(obj1));
33494 if (SWIG_arg_fail(2)) SWIG_fail;
33495 }
33496 {
33497 arg3 = wxString_in_helper(obj2);
33498 if (arg3 == NULL) SWIG_fail;
33499 temp3 = true;
33500 }
33501 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33502 if (SWIG_arg_fail(4)) SWIG_fail;
33503 if (obj4) {
33504 {
33505 arg5 = wxString_in_helper(obj4);
33506 if (arg5 == NULL) SWIG_fail;
33507 temp5 = true;
33508 }
33509 }
33510 {
33511 PyThreadState* __tstate = wxPyBeginAllowThreads();
33512 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33513
33514 wxPyEndAllowThreads(__tstate);
33515 if (PyErr_Occurred()) SWIG_fail;
33516 }
33517 {
33518 resultobj = wxPyMake_wxObject(result, 0);
33519 }
33520 {
33521 if (temp3)
33522 delete arg3;
33523 }
33524 {
33525 if (temp5)
33526 delete arg5;
33527 }
33528 return resultobj;
33529 fail:
33530 {
33531 if (temp3)
33532 delete arg3;
33533 }
33534 {
33535 if (temp5)
33536 delete arg5;
33537 }
33538 return NULL;
33539 }
33540
33541
33542 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33543 PyObject *resultobj;
33544 wxMenu *arg1 = (wxMenu *) 0 ;
33545 int arg2 ;
33546 wxMenuItem *result;
33547 PyObject * obj0 = 0 ;
33548 PyObject * obj1 = 0 ;
33549 char *kwnames[] = {
33550 (char *) "self",(char *) "id", NULL
33551 };
33552
33553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33555 if (SWIG_arg_fail(1)) SWIG_fail;
33556 {
33557 arg2 = (int)(SWIG_As_int(obj1));
33558 if (SWIG_arg_fail(2)) SWIG_fail;
33559 }
33560 {
33561 PyThreadState* __tstate = wxPyBeginAllowThreads();
33562 result = (wxMenuItem *)(arg1)->Remove(arg2);
33563
33564 wxPyEndAllowThreads(__tstate);
33565 if (PyErr_Occurred()) SWIG_fail;
33566 }
33567 {
33568 resultobj = wxPyMake_wxObject(result, 0);
33569 }
33570 return resultobj;
33571 fail:
33572 return NULL;
33573 }
33574
33575
33576 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33577 PyObject *resultobj;
33578 wxMenu *arg1 = (wxMenu *) 0 ;
33579 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33580 wxMenuItem *result;
33581 PyObject * obj0 = 0 ;
33582 PyObject * obj1 = 0 ;
33583 char *kwnames[] = {
33584 (char *) "self",(char *) "item", NULL
33585 };
33586
33587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33589 if (SWIG_arg_fail(1)) SWIG_fail;
33590 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33591 if (SWIG_arg_fail(2)) SWIG_fail;
33592 {
33593 PyThreadState* __tstate = wxPyBeginAllowThreads();
33594 result = (wxMenuItem *)(arg1)->Remove(arg2);
33595
33596 wxPyEndAllowThreads(__tstate);
33597 if (PyErr_Occurred()) SWIG_fail;
33598 }
33599 {
33600 resultobj = wxPyMake_wxObject(result, 0);
33601 }
33602 return resultobj;
33603 fail:
33604 return NULL;
33605 }
33606
33607
33608 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33609 PyObject *resultobj;
33610 wxMenu *arg1 = (wxMenu *) 0 ;
33611 int arg2 ;
33612 bool result;
33613 PyObject * obj0 = 0 ;
33614 PyObject * obj1 = 0 ;
33615 char *kwnames[] = {
33616 (char *) "self",(char *) "id", NULL
33617 };
33618
33619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33621 if (SWIG_arg_fail(1)) SWIG_fail;
33622 {
33623 arg2 = (int)(SWIG_As_int(obj1));
33624 if (SWIG_arg_fail(2)) SWIG_fail;
33625 }
33626 {
33627 PyThreadState* __tstate = wxPyBeginAllowThreads();
33628 result = (bool)(arg1)->Delete(arg2);
33629
33630 wxPyEndAllowThreads(__tstate);
33631 if (PyErr_Occurred()) SWIG_fail;
33632 }
33633 {
33634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33635 }
33636 return resultobj;
33637 fail:
33638 return NULL;
33639 }
33640
33641
33642 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33643 PyObject *resultobj;
33644 wxMenu *arg1 = (wxMenu *) 0 ;
33645 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33646 bool result;
33647 PyObject * obj0 = 0 ;
33648 PyObject * obj1 = 0 ;
33649 char *kwnames[] = {
33650 (char *) "self",(char *) "item", NULL
33651 };
33652
33653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33655 if (SWIG_arg_fail(1)) SWIG_fail;
33656 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33657 if (SWIG_arg_fail(2)) SWIG_fail;
33658 {
33659 PyThreadState* __tstate = wxPyBeginAllowThreads();
33660 result = (bool)(arg1)->Delete(arg2);
33661
33662 wxPyEndAllowThreads(__tstate);
33663 if (PyErr_Occurred()) SWIG_fail;
33664 }
33665 {
33666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33667 }
33668 return resultobj;
33669 fail:
33670 return NULL;
33671 }
33672
33673
33674 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33675 PyObject *resultobj;
33676 wxMenu *arg1 = (wxMenu *) 0 ;
33677 PyObject * obj0 = 0 ;
33678 char *kwnames[] = {
33679 (char *) "self", NULL
33680 };
33681
33682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33684 if (SWIG_arg_fail(1)) SWIG_fail;
33685 {
33686 PyThreadState* __tstate = wxPyBeginAllowThreads();
33687 wxMenu_Destroy(arg1);
33688
33689 wxPyEndAllowThreads(__tstate);
33690 if (PyErr_Occurred()) SWIG_fail;
33691 }
33692 Py_INCREF(Py_None); resultobj = Py_None;
33693 return resultobj;
33694 fail:
33695 return NULL;
33696 }
33697
33698
33699 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33700 PyObject *resultobj;
33701 wxMenu *arg1 = (wxMenu *) 0 ;
33702 int arg2 ;
33703 bool result;
33704 PyObject * obj0 = 0 ;
33705 PyObject * obj1 = 0 ;
33706 char *kwnames[] = {
33707 (char *) "self",(char *) "id", NULL
33708 };
33709
33710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33712 if (SWIG_arg_fail(1)) SWIG_fail;
33713 {
33714 arg2 = (int)(SWIG_As_int(obj1));
33715 if (SWIG_arg_fail(2)) SWIG_fail;
33716 }
33717 {
33718 PyThreadState* __tstate = wxPyBeginAllowThreads();
33719 result = (bool)(arg1)->Destroy(arg2);
33720
33721 wxPyEndAllowThreads(__tstate);
33722 if (PyErr_Occurred()) SWIG_fail;
33723 }
33724 {
33725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33726 }
33727 return resultobj;
33728 fail:
33729 return NULL;
33730 }
33731
33732
33733 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33734 PyObject *resultobj;
33735 wxMenu *arg1 = (wxMenu *) 0 ;
33736 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33737 bool result;
33738 PyObject * obj0 = 0 ;
33739 PyObject * obj1 = 0 ;
33740 char *kwnames[] = {
33741 (char *) "self",(char *) "item", NULL
33742 };
33743
33744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33746 if (SWIG_arg_fail(1)) SWIG_fail;
33747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33748 if (SWIG_arg_fail(2)) SWIG_fail;
33749 {
33750 PyThreadState* __tstate = wxPyBeginAllowThreads();
33751 result = (bool)(arg1)->Destroy(arg2);
33752
33753 wxPyEndAllowThreads(__tstate);
33754 if (PyErr_Occurred()) SWIG_fail;
33755 }
33756 {
33757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33758 }
33759 return resultobj;
33760 fail:
33761 return NULL;
33762 }
33763
33764
33765 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33766 PyObject *resultobj;
33767 wxMenu *arg1 = (wxMenu *) 0 ;
33768 size_t result;
33769 PyObject * obj0 = 0 ;
33770 char *kwnames[] = {
33771 (char *) "self", NULL
33772 };
33773
33774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33776 if (SWIG_arg_fail(1)) SWIG_fail;
33777 {
33778 PyThreadState* __tstate = wxPyBeginAllowThreads();
33779 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33780
33781 wxPyEndAllowThreads(__tstate);
33782 if (PyErr_Occurred()) SWIG_fail;
33783 }
33784 {
33785 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33786 }
33787 return resultobj;
33788 fail:
33789 return NULL;
33790 }
33791
33792
33793 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33794 PyObject *resultobj;
33795 wxMenu *arg1 = (wxMenu *) 0 ;
33796 PyObject *result;
33797 PyObject * obj0 = 0 ;
33798 char *kwnames[] = {
33799 (char *) "self", NULL
33800 };
33801
33802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33804 if (SWIG_arg_fail(1)) SWIG_fail;
33805 {
33806 PyThreadState* __tstate = wxPyBeginAllowThreads();
33807 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33808
33809 wxPyEndAllowThreads(__tstate);
33810 if (PyErr_Occurred()) SWIG_fail;
33811 }
33812 resultobj = result;
33813 return resultobj;
33814 fail:
33815 return NULL;
33816 }
33817
33818
33819 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33820 PyObject *resultobj;
33821 wxMenu *arg1 = (wxMenu *) 0 ;
33822 wxString *arg2 = 0 ;
33823 int result;
33824 bool temp2 = false ;
33825 PyObject * obj0 = 0 ;
33826 PyObject * obj1 = 0 ;
33827 char *kwnames[] = {
33828 (char *) "self",(char *) "item", NULL
33829 };
33830
33831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33833 if (SWIG_arg_fail(1)) SWIG_fail;
33834 {
33835 arg2 = wxString_in_helper(obj1);
33836 if (arg2 == NULL) SWIG_fail;
33837 temp2 = true;
33838 }
33839 {
33840 PyThreadState* __tstate = wxPyBeginAllowThreads();
33841 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33842
33843 wxPyEndAllowThreads(__tstate);
33844 if (PyErr_Occurred()) SWIG_fail;
33845 }
33846 {
33847 resultobj = SWIG_From_int((int)(result));
33848 }
33849 {
33850 if (temp2)
33851 delete arg2;
33852 }
33853 return resultobj;
33854 fail:
33855 {
33856 if (temp2)
33857 delete arg2;
33858 }
33859 return NULL;
33860 }
33861
33862
33863 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33864 PyObject *resultobj;
33865 wxMenu *arg1 = (wxMenu *) 0 ;
33866 int arg2 ;
33867 wxMenuItem *result;
33868 PyObject * obj0 = 0 ;
33869 PyObject * obj1 = 0 ;
33870 char *kwnames[] = {
33871 (char *) "self",(char *) "id", NULL
33872 };
33873
33874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33876 if (SWIG_arg_fail(1)) SWIG_fail;
33877 {
33878 arg2 = (int)(SWIG_As_int(obj1));
33879 if (SWIG_arg_fail(2)) SWIG_fail;
33880 }
33881 {
33882 PyThreadState* __tstate = wxPyBeginAllowThreads();
33883 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33884
33885 wxPyEndAllowThreads(__tstate);
33886 if (PyErr_Occurred()) SWIG_fail;
33887 }
33888 {
33889 resultobj = wxPyMake_wxObject(result, 0);
33890 }
33891 return resultobj;
33892 fail:
33893 return NULL;
33894 }
33895
33896
33897 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33898 PyObject *resultobj;
33899 wxMenu *arg1 = (wxMenu *) 0 ;
33900 size_t arg2 ;
33901 wxMenuItem *result;
33902 PyObject * obj0 = 0 ;
33903 PyObject * obj1 = 0 ;
33904 char *kwnames[] = {
33905 (char *) "self",(char *) "position", NULL
33906 };
33907
33908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33910 if (SWIG_arg_fail(1)) SWIG_fail;
33911 {
33912 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33913 if (SWIG_arg_fail(2)) SWIG_fail;
33914 }
33915 {
33916 PyThreadState* __tstate = wxPyBeginAllowThreads();
33917 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33918
33919 wxPyEndAllowThreads(__tstate);
33920 if (PyErr_Occurred()) SWIG_fail;
33921 }
33922 {
33923 resultobj = wxPyMake_wxObject(result, 0);
33924 }
33925 return resultobj;
33926 fail:
33927 return NULL;
33928 }
33929
33930
33931 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33932 PyObject *resultobj;
33933 wxMenu *arg1 = (wxMenu *) 0 ;
33934 int arg2 ;
33935 bool arg3 ;
33936 PyObject * obj0 = 0 ;
33937 PyObject * obj1 = 0 ;
33938 PyObject * obj2 = 0 ;
33939 char *kwnames[] = {
33940 (char *) "self",(char *) "id",(char *) "enable", NULL
33941 };
33942
33943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33945 if (SWIG_arg_fail(1)) SWIG_fail;
33946 {
33947 arg2 = (int)(SWIG_As_int(obj1));
33948 if (SWIG_arg_fail(2)) SWIG_fail;
33949 }
33950 {
33951 arg3 = (bool)(SWIG_As_bool(obj2));
33952 if (SWIG_arg_fail(3)) SWIG_fail;
33953 }
33954 {
33955 PyThreadState* __tstate = wxPyBeginAllowThreads();
33956 (arg1)->Enable(arg2,arg3);
33957
33958 wxPyEndAllowThreads(__tstate);
33959 if (PyErr_Occurred()) SWIG_fail;
33960 }
33961 Py_INCREF(Py_None); resultobj = Py_None;
33962 return resultobj;
33963 fail:
33964 return NULL;
33965 }
33966
33967
33968 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33969 PyObject *resultobj;
33970 wxMenu *arg1 = (wxMenu *) 0 ;
33971 int arg2 ;
33972 bool result;
33973 PyObject * obj0 = 0 ;
33974 PyObject * obj1 = 0 ;
33975 char *kwnames[] = {
33976 (char *) "self",(char *) "id", NULL
33977 };
33978
33979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33981 if (SWIG_arg_fail(1)) SWIG_fail;
33982 {
33983 arg2 = (int)(SWIG_As_int(obj1));
33984 if (SWIG_arg_fail(2)) SWIG_fail;
33985 }
33986 {
33987 PyThreadState* __tstate = wxPyBeginAllowThreads();
33988 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33989
33990 wxPyEndAllowThreads(__tstate);
33991 if (PyErr_Occurred()) SWIG_fail;
33992 }
33993 {
33994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33995 }
33996 return resultobj;
33997 fail:
33998 return NULL;
33999 }
34000
34001
34002 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34003 PyObject *resultobj;
34004 wxMenu *arg1 = (wxMenu *) 0 ;
34005 int arg2 ;
34006 bool arg3 ;
34007 PyObject * obj0 = 0 ;
34008 PyObject * obj1 = 0 ;
34009 PyObject * obj2 = 0 ;
34010 char *kwnames[] = {
34011 (char *) "self",(char *) "id",(char *) "check", NULL
34012 };
34013
34014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34016 if (SWIG_arg_fail(1)) SWIG_fail;
34017 {
34018 arg2 = (int)(SWIG_As_int(obj1));
34019 if (SWIG_arg_fail(2)) SWIG_fail;
34020 }
34021 {
34022 arg3 = (bool)(SWIG_As_bool(obj2));
34023 if (SWIG_arg_fail(3)) SWIG_fail;
34024 }
34025 {
34026 PyThreadState* __tstate = wxPyBeginAllowThreads();
34027 (arg1)->Check(arg2,arg3);
34028
34029 wxPyEndAllowThreads(__tstate);
34030 if (PyErr_Occurred()) SWIG_fail;
34031 }
34032 Py_INCREF(Py_None); resultobj = Py_None;
34033 return resultobj;
34034 fail:
34035 return NULL;
34036 }
34037
34038
34039 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34040 PyObject *resultobj;
34041 wxMenu *arg1 = (wxMenu *) 0 ;
34042 int arg2 ;
34043 bool result;
34044 PyObject * obj0 = 0 ;
34045 PyObject * obj1 = 0 ;
34046 char *kwnames[] = {
34047 (char *) "self",(char *) "id", NULL
34048 };
34049
34050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34052 if (SWIG_arg_fail(1)) SWIG_fail;
34053 {
34054 arg2 = (int)(SWIG_As_int(obj1));
34055 if (SWIG_arg_fail(2)) SWIG_fail;
34056 }
34057 {
34058 PyThreadState* __tstate = wxPyBeginAllowThreads();
34059 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34060
34061 wxPyEndAllowThreads(__tstate);
34062 if (PyErr_Occurred()) SWIG_fail;
34063 }
34064 {
34065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34066 }
34067 return resultobj;
34068 fail:
34069 return NULL;
34070 }
34071
34072
34073 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34074 PyObject *resultobj;
34075 wxMenu *arg1 = (wxMenu *) 0 ;
34076 int arg2 ;
34077 wxString *arg3 = 0 ;
34078 bool temp3 = false ;
34079 PyObject * obj0 = 0 ;
34080 PyObject * obj1 = 0 ;
34081 PyObject * obj2 = 0 ;
34082 char *kwnames[] = {
34083 (char *) "self",(char *) "id",(char *) "label", NULL
34084 };
34085
34086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34088 if (SWIG_arg_fail(1)) SWIG_fail;
34089 {
34090 arg2 = (int)(SWIG_As_int(obj1));
34091 if (SWIG_arg_fail(2)) SWIG_fail;
34092 }
34093 {
34094 arg3 = wxString_in_helper(obj2);
34095 if (arg3 == NULL) SWIG_fail;
34096 temp3 = true;
34097 }
34098 {
34099 PyThreadState* __tstate = wxPyBeginAllowThreads();
34100 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34101
34102 wxPyEndAllowThreads(__tstate);
34103 if (PyErr_Occurred()) SWIG_fail;
34104 }
34105 Py_INCREF(Py_None); resultobj = Py_None;
34106 {
34107 if (temp3)
34108 delete arg3;
34109 }
34110 return resultobj;
34111 fail:
34112 {
34113 if (temp3)
34114 delete arg3;
34115 }
34116 return NULL;
34117 }
34118
34119
34120 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34121 PyObject *resultobj;
34122 wxMenu *arg1 = (wxMenu *) 0 ;
34123 int arg2 ;
34124 wxString result;
34125 PyObject * obj0 = 0 ;
34126 PyObject * obj1 = 0 ;
34127 char *kwnames[] = {
34128 (char *) "self",(char *) "id", NULL
34129 };
34130
34131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34133 if (SWIG_arg_fail(1)) SWIG_fail;
34134 {
34135 arg2 = (int)(SWIG_As_int(obj1));
34136 if (SWIG_arg_fail(2)) SWIG_fail;
34137 }
34138 {
34139 PyThreadState* __tstate = wxPyBeginAllowThreads();
34140 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34141
34142 wxPyEndAllowThreads(__tstate);
34143 if (PyErr_Occurred()) SWIG_fail;
34144 }
34145 {
34146 #if wxUSE_UNICODE
34147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34148 #else
34149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34150 #endif
34151 }
34152 return resultobj;
34153 fail:
34154 return NULL;
34155 }
34156
34157
34158 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34159 PyObject *resultobj;
34160 wxMenu *arg1 = (wxMenu *) 0 ;
34161 int arg2 ;
34162 wxString *arg3 = 0 ;
34163 bool temp3 = false ;
34164 PyObject * obj0 = 0 ;
34165 PyObject * obj1 = 0 ;
34166 PyObject * obj2 = 0 ;
34167 char *kwnames[] = {
34168 (char *) "self",(char *) "id",(char *) "helpString", NULL
34169 };
34170
34171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34173 if (SWIG_arg_fail(1)) SWIG_fail;
34174 {
34175 arg2 = (int)(SWIG_As_int(obj1));
34176 if (SWIG_arg_fail(2)) SWIG_fail;
34177 }
34178 {
34179 arg3 = wxString_in_helper(obj2);
34180 if (arg3 == NULL) SWIG_fail;
34181 temp3 = true;
34182 }
34183 {
34184 PyThreadState* __tstate = wxPyBeginAllowThreads();
34185 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34186
34187 wxPyEndAllowThreads(__tstate);
34188 if (PyErr_Occurred()) SWIG_fail;
34189 }
34190 Py_INCREF(Py_None); resultobj = Py_None;
34191 {
34192 if (temp3)
34193 delete arg3;
34194 }
34195 return resultobj;
34196 fail:
34197 {
34198 if (temp3)
34199 delete arg3;
34200 }
34201 return NULL;
34202 }
34203
34204
34205 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34206 PyObject *resultobj;
34207 wxMenu *arg1 = (wxMenu *) 0 ;
34208 int arg2 ;
34209 wxString result;
34210 PyObject * obj0 = 0 ;
34211 PyObject * obj1 = 0 ;
34212 char *kwnames[] = {
34213 (char *) "self",(char *) "id", NULL
34214 };
34215
34216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34218 if (SWIG_arg_fail(1)) SWIG_fail;
34219 {
34220 arg2 = (int)(SWIG_As_int(obj1));
34221 if (SWIG_arg_fail(2)) SWIG_fail;
34222 }
34223 {
34224 PyThreadState* __tstate = wxPyBeginAllowThreads();
34225 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34226
34227 wxPyEndAllowThreads(__tstate);
34228 if (PyErr_Occurred()) SWIG_fail;
34229 }
34230 {
34231 #if wxUSE_UNICODE
34232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34233 #else
34234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34235 #endif
34236 }
34237 return resultobj;
34238 fail:
34239 return NULL;
34240 }
34241
34242
34243 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34244 PyObject *resultobj;
34245 wxMenu *arg1 = (wxMenu *) 0 ;
34246 wxString *arg2 = 0 ;
34247 bool temp2 = false ;
34248 PyObject * obj0 = 0 ;
34249 PyObject * obj1 = 0 ;
34250 char *kwnames[] = {
34251 (char *) "self",(char *) "title", NULL
34252 };
34253
34254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34256 if (SWIG_arg_fail(1)) SWIG_fail;
34257 {
34258 arg2 = wxString_in_helper(obj1);
34259 if (arg2 == NULL) SWIG_fail;
34260 temp2 = true;
34261 }
34262 {
34263 PyThreadState* __tstate = wxPyBeginAllowThreads();
34264 (arg1)->SetTitle((wxString const &)*arg2);
34265
34266 wxPyEndAllowThreads(__tstate);
34267 if (PyErr_Occurred()) SWIG_fail;
34268 }
34269 Py_INCREF(Py_None); resultobj = Py_None;
34270 {
34271 if (temp2)
34272 delete arg2;
34273 }
34274 return resultobj;
34275 fail:
34276 {
34277 if (temp2)
34278 delete arg2;
34279 }
34280 return NULL;
34281 }
34282
34283
34284 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34285 PyObject *resultobj;
34286 wxMenu *arg1 = (wxMenu *) 0 ;
34287 wxString result;
34288 PyObject * obj0 = 0 ;
34289 char *kwnames[] = {
34290 (char *) "self", NULL
34291 };
34292
34293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34295 if (SWIG_arg_fail(1)) SWIG_fail;
34296 {
34297 PyThreadState* __tstate = wxPyBeginAllowThreads();
34298 result = ((wxMenu const *)arg1)->GetTitle();
34299
34300 wxPyEndAllowThreads(__tstate);
34301 if (PyErr_Occurred()) SWIG_fail;
34302 }
34303 {
34304 #if wxUSE_UNICODE
34305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34306 #else
34307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34308 #endif
34309 }
34310 return resultobj;
34311 fail:
34312 return NULL;
34313 }
34314
34315
34316 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34317 PyObject *resultobj;
34318 wxMenu *arg1 = (wxMenu *) 0 ;
34319 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34320 PyObject * obj0 = 0 ;
34321 PyObject * obj1 = 0 ;
34322 char *kwnames[] = {
34323 (char *) "self",(char *) "handler", NULL
34324 };
34325
34326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34328 if (SWIG_arg_fail(1)) SWIG_fail;
34329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34330 if (SWIG_arg_fail(2)) SWIG_fail;
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 (arg1)->SetEventHandler(arg2);
34334
34335 wxPyEndAllowThreads(__tstate);
34336 if (PyErr_Occurred()) SWIG_fail;
34337 }
34338 Py_INCREF(Py_None); resultobj = Py_None;
34339 return resultobj;
34340 fail:
34341 return NULL;
34342 }
34343
34344
34345 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34346 PyObject *resultobj;
34347 wxMenu *arg1 = (wxMenu *) 0 ;
34348 wxEvtHandler *result;
34349 PyObject * obj0 = 0 ;
34350 char *kwnames[] = {
34351 (char *) "self", NULL
34352 };
34353
34354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34356 if (SWIG_arg_fail(1)) SWIG_fail;
34357 {
34358 PyThreadState* __tstate = wxPyBeginAllowThreads();
34359 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34360
34361 wxPyEndAllowThreads(__tstate);
34362 if (PyErr_Occurred()) SWIG_fail;
34363 }
34364 {
34365 resultobj = wxPyMake_wxObject(result, 0);
34366 }
34367 return resultobj;
34368 fail:
34369 return NULL;
34370 }
34371
34372
34373 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34374 PyObject *resultobj;
34375 wxMenu *arg1 = (wxMenu *) 0 ;
34376 wxWindow *arg2 = (wxWindow *) 0 ;
34377 PyObject * obj0 = 0 ;
34378 PyObject * obj1 = 0 ;
34379 char *kwnames[] = {
34380 (char *) "self",(char *) "win", NULL
34381 };
34382
34383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34385 if (SWIG_arg_fail(1)) SWIG_fail;
34386 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34387 if (SWIG_arg_fail(2)) SWIG_fail;
34388 {
34389 PyThreadState* __tstate = wxPyBeginAllowThreads();
34390 (arg1)->SetInvokingWindow(arg2);
34391
34392 wxPyEndAllowThreads(__tstate);
34393 if (PyErr_Occurred()) SWIG_fail;
34394 }
34395 Py_INCREF(Py_None); resultobj = Py_None;
34396 return resultobj;
34397 fail:
34398 return NULL;
34399 }
34400
34401
34402 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34403 PyObject *resultobj;
34404 wxMenu *arg1 = (wxMenu *) 0 ;
34405 wxWindow *result;
34406 PyObject * obj0 = 0 ;
34407 char *kwnames[] = {
34408 (char *) "self", NULL
34409 };
34410
34411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34413 if (SWIG_arg_fail(1)) SWIG_fail;
34414 {
34415 PyThreadState* __tstate = wxPyBeginAllowThreads();
34416 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34417
34418 wxPyEndAllowThreads(__tstate);
34419 if (PyErr_Occurred()) SWIG_fail;
34420 }
34421 {
34422 resultobj = wxPyMake_wxObject(result, 0);
34423 }
34424 return resultobj;
34425 fail:
34426 return NULL;
34427 }
34428
34429
34430 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34431 PyObject *resultobj;
34432 wxMenu *arg1 = (wxMenu *) 0 ;
34433 long result;
34434 PyObject * obj0 = 0 ;
34435 char *kwnames[] = {
34436 (char *) "self", NULL
34437 };
34438
34439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34441 if (SWIG_arg_fail(1)) SWIG_fail;
34442 {
34443 PyThreadState* __tstate = wxPyBeginAllowThreads();
34444 result = (long)((wxMenu const *)arg1)->GetStyle();
34445
34446 wxPyEndAllowThreads(__tstate);
34447 if (PyErr_Occurred()) SWIG_fail;
34448 }
34449 {
34450 resultobj = SWIG_From_long((long)(result));
34451 }
34452 return resultobj;
34453 fail:
34454 return NULL;
34455 }
34456
34457
34458 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34459 PyObject *resultobj;
34460 wxMenu *arg1 = (wxMenu *) 0 ;
34461 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34462 PyObject * obj0 = 0 ;
34463 PyObject * obj1 = 0 ;
34464 char *kwnames[] = {
34465 (char *) "self",(char *) "source", NULL
34466 };
34467
34468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34470 if (SWIG_arg_fail(1)) SWIG_fail;
34471 if (obj1) {
34472 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34473 if (SWIG_arg_fail(2)) SWIG_fail;
34474 }
34475 {
34476 PyThreadState* __tstate = wxPyBeginAllowThreads();
34477 (arg1)->UpdateUI(arg2);
34478
34479 wxPyEndAllowThreads(__tstate);
34480 if (PyErr_Occurred()) SWIG_fail;
34481 }
34482 Py_INCREF(Py_None); resultobj = Py_None;
34483 return resultobj;
34484 fail:
34485 return NULL;
34486 }
34487
34488
34489 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34490 PyObject *resultobj;
34491 wxMenu *arg1 = (wxMenu *) 0 ;
34492 wxMenuBar *result;
34493 PyObject * obj0 = 0 ;
34494 char *kwnames[] = {
34495 (char *) "self", NULL
34496 };
34497
34498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34500 if (SWIG_arg_fail(1)) SWIG_fail;
34501 {
34502 PyThreadState* __tstate = wxPyBeginAllowThreads();
34503 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34504
34505 wxPyEndAllowThreads(__tstate);
34506 if (PyErr_Occurred()) SWIG_fail;
34507 }
34508 {
34509 resultobj = wxPyMake_wxObject(result, 0);
34510 }
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34518 PyObject *resultobj;
34519 wxMenu *arg1 = (wxMenu *) 0 ;
34520 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34521 PyObject * obj0 = 0 ;
34522 PyObject * obj1 = 0 ;
34523 char *kwnames[] = {
34524 (char *) "self",(char *) "menubar", NULL
34525 };
34526
34527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34529 if (SWIG_arg_fail(1)) SWIG_fail;
34530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34531 if (SWIG_arg_fail(2)) SWIG_fail;
34532 {
34533 PyThreadState* __tstate = wxPyBeginAllowThreads();
34534 (arg1)->Attach(arg2);
34535
34536 wxPyEndAllowThreads(__tstate);
34537 if (PyErr_Occurred()) SWIG_fail;
34538 }
34539 Py_INCREF(Py_None); resultobj = Py_None;
34540 return resultobj;
34541 fail:
34542 return NULL;
34543 }
34544
34545
34546 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34547 PyObject *resultobj;
34548 wxMenu *arg1 = (wxMenu *) 0 ;
34549 PyObject * obj0 = 0 ;
34550 char *kwnames[] = {
34551 (char *) "self", NULL
34552 };
34553
34554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34556 if (SWIG_arg_fail(1)) SWIG_fail;
34557 {
34558 PyThreadState* __tstate = wxPyBeginAllowThreads();
34559 (arg1)->Detach();
34560
34561 wxPyEndAllowThreads(__tstate);
34562 if (PyErr_Occurred()) SWIG_fail;
34563 }
34564 Py_INCREF(Py_None); resultobj = Py_None;
34565 return resultobj;
34566 fail:
34567 return NULL;
34568 }
34569
34570
34571 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34572 PyObject *resultobj;
34573 wxMenu *arg1 = (wxMenu *) 0 ;
34574 bool result;
34575 PyObject * obj0 = 0 ;
34576 char *kwnames[] = {
34577 (char *) "self", NULL
34578 };
34579
34580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34582 if (SWIG_arg_fail(1)) SWIG_fail;
34583 {
34584 PyThreadState* __tstate = wxPyBeginAllowThreads();
34585 result = (bool)((wxMenu const *)arg1)->IsAttached();
34586
34587 wxPyEndAllowThreads(__tstate);
34588 if (PyErr_Occurred()) SWIG_fail;
34589 }
34590 {
34591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34592 }
34593 return resultobj;
34594 fail:
34595 return NULL;
34596 }
34597
34598
34599 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34600 PyObject *resultobj;
34601 wxMenu *arg1 = (wxMenu *) 0 ;
34602 wxMenu *arg2 = (wxMenu *) 0 ;
34603 PyObject * obj0 = 0 ;
34604 PyObject * obj1 = 0 ;
34605 char *kwnames[] = {
34606 (char *) "self",(char *) "parent", NULL
34607 };
34608
34609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34611 if (SWIG_arg_fail(1)) SWIG_fail;
34612 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34613 if (SWIG_arg_fail(2)) SWIG_fail;
34614 {
34615 PyThreadState* __tstate = wxPyBeginAllowThreads();
34616 (arg1)->SetParent(arg2);
34617
34618 wxPyEndAllowThreads(__tstate);
34619 if (PyErr_Occurred()) SWIG_fail;
34620 }
34621 Py_INCREF(Py_None); resultobj = Py_None;
34622 return resultobj;
34623 fail:
34624 return NULL;
34625 }
34626
34627
34628 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34629 PyObject *resultobj;
34630 wxMenu *arg1 = (wxMenu *) 0 ;
34631 wxMenu *result;
34632 PyObject * obj0 = 0 ;
34633 char *kwnames[] = {
34634 (char *) "self", NULL
34635 };
34636
34637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34639 if (SWIG_arg_fail(1)) SWIG_fail;
34640 {
34641 PyThreadState* __tstate = wxPyBeginAllowThreads();
34642 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34643
34644 wxPyEndAllowThreads(__tstate);
34645 if (PyErr_Occurred()) SWIG_fail;
34646 }
34647 {
34648 resultobj = wxPyMake_wxObject(result, 0);
34649 }
34650 return resultobj;
34651 fail:
34652 return NULL;
34653 }
34654
34655
34656 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34657 PyObject *obj;
34658 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34659 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34660 Py_INCREF(obj);
34661 return Py_BuildValue((char *)"");
34662 }
34663 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34664 PyObject *resultobj;
34665 long arg1 = (long) 0 ;
34666 wxMenuBar *result;
34667 PyObject * obj0 = 0 ;
34668 char *kwnames[] = {
34669 (char *) "style", NULL
34670 };
34671
34672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34673 if (obj0) {
34674 {
34675 arg1 = (long)(SWIG_As_long(obj0));
34676 if (SWIG_arg_fail(1)) SWIG_fail;
34677 }
34678 }
34679 {
34680 if (!wxPyCheckForApp()) SWIG_fail;
34681 PyThreadState* __tstate = wxPyBeginAllowThreads();
34682 result = (wxMenuBar *)new wxMenuBar(arg1);
34683
34684 wxPyEndAllowThreads(__tstate);
34685 if (PyErr_Occurred()) SWIG_fail;
34686 }
34687 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34688 return resultobj;
34689 fail:
34690 return NULL;
34691 }
34692
34693
34694 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34695 PyObject *resultobj;
34696 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34697 wxMenu *arg2 = (wxMenu *) 0 ;
34698 wxString *arg3 = 0 ;
34699 bool result;
34700 bool temp3 = false ;
34701 PyObject * obj0 = 0 ;
34702 PyObject * obj1 = 0 ;
34703 PyObject * obj2 = 0 ;
34704 char *kwnames[] = {
34705 (char *) "self",(char *) "menu",(char *) "title", NULL
34706 };
34707
34708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34710 if (SWIG_arg_fail(1)) SWIG_fail;
34711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34712 if (SWIG_arg_fail(2)) SWIG_fail;
34713 {
34714 arg3 = wxString_in_helper(obj2);
34715 if (arg3 == NULL) SWIG_fail;
34716 temp3 = true;
34717 }
34718 {
34719 PyThreadState* __tstate = wxPyBeginAllowThreads();
34720 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34721
34722 wxPyEndAllowThreads(__tstate);
34723 if (PyErr_Occurred()) SWIG_fail;
34724 }
34725 {
34726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34727 }
34728 {
34729 if (temp3)
34730 delete arg3;
34731 }
34732 return resultobj;
34733 fail:
34734 {
34735 if (temp3)
34736 delete arg3;
34737 }
34738 return NULL;
34739 }
34740
34741
34742 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34743 PyObject *resultobj;
34744 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34745 size_t arg2 ;
34746 wxMenu *arg3 = (wxMenu *) 0 ;
34747 wxString *arg4 = 0 ;
34748 bool result;
34749 bool temp4 = false ;
34750 PyObject * obj0 = 0 ;
34751 PyObject * obj1 = 0 ;
34752 PyObject * obj2 = 0 ;
34753 PyObject * obj3 = 0 ;
34754 char *kwnames[] = {
34755 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34756 };
34757
34758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34766 if (SWIG_arg_fail(3)) SWIG_fail;
34767 {
34768 arg4 = wxString_in_helper(obj3);
34769 if (arg4 == NULL) SWIG_fail;
34770 temp4 = true;
34771 }
34772 {
34773 PyThreadState* __tstate = wxPyBeginAllowThreads();
34774 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34775
34776 wxPyEndAllowThreads(__tstate);
34777 if (PyErr_Occurred()) SWIG_fail;
34778 }
34779 {
34780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34781 }
34782 {
34783 if (temp4)
34784 delete arg4;
34785 }
34786 return resultobj;
34787 fail:
34788 {
34789 if (temp4)
34790 delete arg4;
34791 }
34792 return NULL;
34793 }
34794
34795
34796 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34797 PyObject *resultobj;
34798 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34799 size_t result;
34800 PyObject * obj0 = 0 ;
34801 char *kwnames[] = {
34802 (char *) "self", NULL
34803 };
34804
34805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34807 if (SWIG_arg_fail(1)) SWIG_fail;
34808 {
34809 PyThreadState* __tstate = wxPyBeginAllowThreads();
34810 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34811
34812 wxPyEndAllowThreads(__tstate);
34813 if (PyErr_Occurred()) SWIG_fail;
34814 }
34815 {
34816 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34817 }
34818 return resultobj;
34819 fail:
34820 return NULL;
34821 }
34822
34823
34824 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34825 PyObject *resultobj;
34826 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34827 size_t arg2 ;
34828 wxMenu *result;
34829 PyObject * obj0 = 0 ;
34830 PyObject * obj1 = 0 ;
34831 char *kwnames[] = {
34832 (char *) "self",(char *) "pos", NULL
34833 };
34834
34835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34837 if (SWIG_arg_fail(1)) SWIG_fail;
34838 {
34839 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34840 if (SWIG_arg_fail(2)) SWIG_fail;
34841 }
34842 {
34843 PyThreadState* __tstate = wxPyBeginAllowThreads();
34844 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34845
34846 wxPyEndAllowThreads(__tstate);
34847 if (PyErr_Occurred()) SWIG_fail;
34848 }
34849 {
34850 resultobj = wxPyMake_wxObject(result, 0);
34851 }
34852 return resultobj;
34853 fail:
34854 return NULL;
34855 }
34856
34857
34858 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34859 PyObject *resultobj;
34860 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34861 size_t arg2 ;
34862 wxMenu *arg3 = (wxMenu *) 0 ;
34863 wxString *arg4 = 0 ;
34864 wxMenu *result;
34865 bool temp4 = false ;
34866 PyObject * obj0 = 0 ;
34867 PyObject * obj1 = 0 ;
34868 PyObject * obj2 = 0 ;
34869 PyObject * obj3 = 0 ;
34870 char *kwnames[] = {
34871 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34872 };
34873
34874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34876 if (SWIG_arg_fail(1)) SWIG_fail;
34877 {
34878 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34879 if (SWIG_arg_fail(2)) SWIG_fail;
34880 }
34881 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34882 if (SWIG_arg_fail(3)) SWIG_fail;
34883 {
34884 arg4 = wxString_in_helper(obj3);
34885 if (arg4 == NULL) SWIG_fail;
34886 temp4 = true;
34887 }
34888 {
34889 PyThreadState* __tstate = wxPyBeginAllowThreads();
34890 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34891
34892 wxPyEndAllowThreads(__tstate);
34893 if (PyErr_Occurred()) SWIG_fail;
34894 }
34895 {
34896 resultobj = wxPyMake_wxObject(result, 0);
34897 }
34898 {
34899 if (temp4)
34900 delete arg4;
34901 }
34902 return resultobj;
34903 fail:
34904 {
34905 if (temp4)
34906 delete arg4;
34907 }
34908 return NULL;
34909 }
34910
34911
34912 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34913 PyObject *resultobj;
34914 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34915 size_t arg2 ;
34916 wxMenu *result;
34917 PyObject * obj0 = 0 ;
34918 PyObject * obj1 = 0 ;
34919 char *kwnames[] = {
34920 (char *) "self",(char *) "pos", NULL
34921 };
34922
34923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34925 if (SWIG_arg_fail(1)) SWIG_fail;
34926 {
34927 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34928 if (SWIG_arg_fail(2)) SWIG_fail;
34929 }
34930 {
34931 PyThreadState* __tstate = wxPyBeginAllowThreads();
34932 result = (wxMenu *)(arg1)->Remove(arg2);
34933
34934 wxPyEndAllowThreads(__tstate);
34935 if (PyErr_Occurred()) SWIG_fail;
34936 }
34937 {
34938 resultobj = wxPyMake_wxObject(result, 0);
34939 }
34940 return resultobj;
34941 fail:
34942 return NULL;
34943 }
34944
34945
34946 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34947 PyObject *resultobj;
34948 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34949 size_t arg2 ;
34950 bool arg3 ;
34951 PyObject * obj0 = 0 ;
34952 PyObject * obj1 = 0 ;
34953 PyObject * obj2 = 0 ;
34954 char *kwnames[] = {
34955 (char *) "self",(char *) "pos",(char *) "enable", NULL
34956 };
34957
34958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34960 if (SWIG_arg_fail(1)) SWIG_fail;
34961 {
34962 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34963 if (SWIG_arg_fail(2)) SWIG_fail;
34964 }
34965 {
34966 arg3 = (bool)(SWIG_As_bool(obj2));
34967 if (SWIG_arg_fail(3)) SWIG_fail;
34968 }
34969 {
34970 PyThreadState* __tstate = wxPyBeginAllowThreads();
34971 (arg1)->EnableTop(arg2,arg3);
34972
34973 wxPyEndAllowThreads(__tstate);
34974 if (PyErr_Occurred()) SWIG_fail;
34975 }
34976 Py_INCREF(Py_None); resultobj = Py_None;
34977 return resultobj;
34978 fail:
34979 return NULL;
34980 }
34981
34982
34983 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34984 PyObject *resultobj;
34985 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34986 size_t arg2 ;
34987 bool result;
34988 PyObject * obj0 = 0 ;
34989 PyObject * obj1 = 0 ;
34990 char *kwnames[] = {
34991 (char *) "self",(char *) "pos", NULL
34992 };
34993
34994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34996 if (SWIG_arg_fail(1)) SWIG_fail;
34997 {
34998 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34999 if (SWIG_arg_fail(2)) SWIG_fail;
35000 }
35001 {
35002 PyThreadState* __tstate = wxPyBeginAllowThreads();
35003 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35004
35005 wxPyEndAllowThreads(__tstate);
35006 if (PyErr_Occurred()) SWIG_fail;
35007 }
35008 {
35009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35010 }
35011 return resultobj;
35012 fail:
35013 return NULL;
35014 }
35015
35016
35017 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35018 PyObject *resultobj;
35019 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35020 size_t arg2 ;
35021 wxString *arg3 = 0 ;
35022 bool temp3 = false ;
35023 PyObject * obj0 = 0 ;
35024 PyObject * obj1 = 0 ;
35025 PyObject * obj2 = 0 ;
35026 char *kwnames[] = {
35027 (char *) "self",(char *) "pos",(char *) "label", NULL
35028 };
35029
35030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35032 if (SWIG_arg_fail(1)) SWIG_fail;
35033 {
35034 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35035 if (SWIG_arg_fail(2)) SWIG_fail;
35036 }
35037 {
35038 arg3 = wxString_in_helper(obj2);
35039 if (arg3 == NULL) SWIG_fail;
35040 temp3 = true;
35041 }
35042 {
35043 PyThreadState* __tstate = wxPyBeginAllowThreads();
35044 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35045
35046 wxPyEndAllowThreads(__tstate);
35047 if (PyErr_Occurred()) SWIG_fail;
35048 }
35049 Py_INCREF(Py_None); resultobj = Py_None;
35050 {
35051 if (temp3)
35052 delete arg3;
35053 }
35054 return resultobj;
35055 fail:
35056 {
35057 if (temp3)
35058 delete arg3;
35059 }
35060 return NULL;
35061 }
35062
35063
35064 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35065 PyObject *resultobj;
35066 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35067 size_t arg2 ;
35068 wxString result;
35069 PyObject * obj0 = 0 ;
35070 PyObject * obj1 = 0 ;
35071 char *kwnames[] = {
35072 (char *) "self",(char *) "pos", NULL
35073 };
35074
35075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35077 if (SWIG_arg_fail(1)) SWIG_fail;
35078 {
35079 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35080 if (SWIG_arg_fail(2)) SWIG_fail;
35081 }
35082 {
35083 PyThreadState* __tstate = wxPyBeginAllowThreads();
35084 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35085
35086 wxPyEndAllowThreads(__tstate);
35087 if (PyErr_Occurred()) SWIG_fail;
35088 }
35089 {
35090 #if wxUSE_UNICODE
35091 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35092 #else
35093 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35094 #endif
35095 }
35096 return resultobj;
35097 fail:
35098 return NULL;
35099 }
35100
35101
35102 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35103 PyObject *resultobj;
35104 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35105 wxString *arg2 = 0 ;
35106 wxString *arg3 = 0 ;
35107 int result;
35108 bool temp2 = false ;
35109 bool temp3 = false ;
35110 PyObject * obj0 = 0 ;
35111 PyObject * obj1 = 0 ;
35112 PyObject * obj2 = 0 ;
35113 char *kwnames[] = {
35114 (char *) "self",(char *) "menu",(char *) "item", NULL
35115 };
35116
35117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35119 if (SWIG_arg_fail(1)) SWIG_fail;
35120 {
35121 arg2 = wxString_in_helper(obj1);
35122 if (arg2 == NULL) SWIG_fail;
35123 temp2 = true;
35124 }
35125 {
35126 arg3 = wxString_in_helper(obj2);
35127 if (arg3 == NULL) SWIG_fail;
35128 temp3 = true;
35129 }
35130 {
35131 PyThreadState* __tstate = wxPyBeginAllowThreads();
35132 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35133
35134 wxPyEndAllowThreads(__tstate);
35135 if (PyErr_Occurred()) SWIG_fail;
35136 }
35137 {
35138 resultobj = SWIG_From_int((int)(result));
35139 }
35140 {
35141 if (temp2)
35142 delete arg2;
35143 }
35144 {
35145 if (temp3)
35146 delete arg3;
35147 }
35148 return resultobj;
35149 fail:
35150 {
35151 if (temp2)
35152 delete arg2;
35153 }
35154 {
35155 if (temp3)
35156 delete arg3;
35157 }
35158 return NULL;
35159 }
35160
35161
35162 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35163 PyObject *resultobj;
35164 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35165 int arg2 ;
35166 wxMenuItem *result;
35167 PyObject * obj0 = 0 ;
35168 PyObject * obj1 = 0 ;
35169 char *kwnames[] = {
35170 (char *) "self",(char *) "id", NULL
35171 };
35172
35173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35175 if (SWIG_arg_fail(1)) SWIG_fail;
35176 {
35177 arg2 = (int)(SWIG_As_int(obj1));
35178 if (SWIG_arg_fail(2)) SWIG_fail;
35179 }
35180 {
35181 PyThreadState* __tstate = wxPyBeginAllowThreads();
35182 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35183
35184 wxPyEndAllowThreads(__tstate);
35185 if (PyErr_Occurred()) SWIG_fail;
35186 }
35187 {
35188 resultobj = wxPyMake_wxObject(result, 0);
35189 }
35190 return resultobj;
35191 fail:
35192 return NULL;
35193 }
35194
35195
35196 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35197 PyObject *resultobj;
35198 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35199 wxString *arg2 = 0 ;
35200 int result;
35201 bool temp2 = false ;
35202 PyObject * obj0 = 0 ;
35203 PyObject * obj1 = 0 ;
35204 char *kwnames[] = {
35205 (char *) "self",(char *) "title", NULL
35206 };
35207
35208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35210 if (SWIG_arg_fail(1)) SWIG_fail;
35211 {
35212 arg2 = wxString_in_helper(obj1);
35213 if (arg2 == NULL) SWIG_fail;
35214 temp2 = true;
35215 }
35216 {
35217 PyThreadState* __tstate = wxPyBeginAllowThreads();
35218 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35219
35220 wxPyEndAllowThreads(__tstate);
35221 if (PyErr_Occurred()) SWIG_fail;
35222 }
35223 {
35224 resultobj = SWIG_From_int((int)(result));
35225 }
35226 {
35227 if (temp2)
35228 delete arg2;
35229 }
35230 return resultobj;
35231 fail:
35232 {
35233 if (temp2)
35234 delete arg2;
35235 }
35236 return NULL;
35237 }
35238
35239
35240 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35241 PyObject *resultobj;
35242 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35243 int arg2 ;
35244 bool arg3 ;
35245 PyObject * obj0 = 0 ;
35246 PyObject * obj1 = 0 ;
35247 PyObject * obj2 = 0 ;
35248 char *kwnames[] = {
35249 (char *) "self",(char *) "id",(char *) "enable", NULL
35250 };
35251
35252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35254 if (SWIG_arg_fail(1)) SWIG_fail;
35255 {
35256 arg2 = (int)(SWIG_As_int(obj1));
35257 if (SWIG_arg_fail(2)) SWIG_fail;
35258 }
35259 {
35260 arg3 = (bool)(SWIG_As_bool(obj2));
35261 if (SWIG_arg_fail(3)) SWIG_fail;
35262 }
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 (arg1)->Enable(arg2,arg3);
35266
35267 wxPyEndAllowThreads(__tstate);
35268 if (PyErr_Occurred()) SWIG_fail;
35269 }
35270 Py_INCREF(Py_None); resultobj = Py_None;
35271 return resultobj;
35272 fail:
35273 return NULL;
35274 }
35275
35276
35277 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35278 PyObject *resultobj;
35279 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35280 int arg2 ;
35281 bool arg3 ;
35282 PyObject * obj0 = 0 ;
35283 PyObject * obj1 = 0 ;
35284 PyObject * obj2 = 0 ;
35285 char *kwnames[] = {
35286 (char *) "self",(char *) "id",(char *) "check", NULL
35287 };
35288
35289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) 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 arg3 = (bool)(SWIG_As_bool(obj2));
35298 if (SWIG_arg_fail(3)) SWIG_fail;
35299 }
35300 {
35301 PyThreadState* __tstate = wxPyBeginAllowThreads();
35302 (arg1)->Check(arg2,arg3);
35303
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 Py_INCREF(Py_None); resultobj = Py_None;
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35315 PyObject *resultobj;
35316 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35317 int arg2 ;
35318 bool result;
35319 PyObject * obj0 = 0 ;
35320 PyObject * obj1 = 0 ;
35321 char *kwnames[] = {
35322 (char *) "self",(char *) "id", NULL
35323 };
35324
35325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
35330 if (SWIG_arg_fail(2)) SWIG_fail;
35331 }
35332 {
35333 PyThreadState* __tstate = wxPyBeginAllowThreads();
35334 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35335
35336 wxPyEndAllowThreads(__tstate);
35337 if (PyErr_Occurred()) SWIG_fail;
35338 }
35339 {
35340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35341 }
35342 return resultobj;
35343 fail:
35344 return NULL;
35345 }
35346
35347
35348 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35349 PyObject *resultobj;
35350 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35351 int arg2 ;
35352 bool result;
35353 PyObject * obj0 = 0 ;
35354 PyObject * obj1 = 0 ;
35355 char *kwnames[] = {
35356 (char *) "self",(char *) "id", NULL
35357 };
35358
35359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35361 if (SWIG_arg_fail(1)) SWIG_fail;
35362 {
35363 arg2 = (int)(SWIG_As_int(obj1));
35364 if (SWIG_arg_fail(2)) SWIG_fail;
35365 }
35366 {
35367 PyThreadState* __tstate = wxPyBeginAllowThreads();
35368 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35369
35370 wxPyEndAllowThreads(__tstate);
35371 if (PyErr_Occurred()) SWIG_fail;
35372 }
35373 {
35374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35375 }
35376 return resultobj;
35377 fail:
35378 return NULL;
35379 }
35380
35381
35382 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35383 PyObject *resultobj;
35384 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35385 int arg2 ;
35386 wxString *arg3 = 0 ;
35387 bool temp3 = false ;
35388 PyObject * obj0 = 0 ;
35389 PyObject * obj1 = 0 ;
35390 PyObject * obj2 = 0 ;
35391 char *kwnames[] = {
35392 (char *) "self",(char *) "id",(char *) "label", NULL
35393 };
35394
35395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35397 if (SWIG_arg_fail(1)) SWIG_fail;
35398 {
35399 arg2 = (int)(SWIG_As_int(obj1));
35400 if (SWIG_arg_fail(2)) SWIG_fail;
35401 }
35402 {
35403 arg3 = wxString_in_helper(obj2);
35404 if (arg3 == NULL) SWIG_fail;
35405 temp3 = true;
35406 }
35407 {
35408 PyThreadState* __tstate = wxPyBeginAllowThreads();
35409 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35410
35411 wxPyEndAllowThreads(__tstate);
35412 if (PyErr_Occurred()) SWIG_fail;
35413 }
35414 Py_INCREF(Py_None); resultobj = Py_None;
35415 {
35416 if (temp3)
35417 delete arg3;
35418 }
35419 return resultobj;
35420 fail:
35421 {
35422 if (temp3)
35423 delete arg3;
35424 }
35425 return NULL;
35426 }
35427
35428
35429 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35430 PyObject *resultobj;
35431 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35432 int arg2 ;
35433 wxString result;
35434 PyObject * obj0 = 0 ;
35435 PyObject * obj1 = 0 ;
35436 char *kwnames[] = {
35437 (char *) "self",(char *) "id", NULL
35438 };
35439
35440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35442 if (SWIG_arg_fail(1)) SWIG_fail;
35443 {
35444 arg2 = (int)(SWIG_As_int(obj1));
35445 if (SWIG_arg_fail(2)) SWIG_fail;
35446 }
35447 {
35448 PyThreadState* __tstate = wxPyBeginAllowThreads();
35449 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35450
35451 wxPyEndAllowThreads(__tstate);
35452 if (PyErr_Occurred()) SWIG_fail;
35453 }
35454 {
35455 #if wxUSE_UNICODE
35456 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35457 #else
35458 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35459 #endif
35460 }
35461 return resultobj;
35462 fail:
35463 return NULL;
35464 }
35465
35466
35467 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35468 PyObject *resultobj;
35469 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35470 int arg2 ;
35471 wxString *arg3 = 0 ;
35472 bool temp3 = false ;
35473 PyObject * obj0 = 0 ;
35474 PyObject * obj1 = 0 ;
35475 PyObject * obj2 = 0 ;
35476 char *kwnames[] = {
35477 (char *) "self",(char *) "id",(char *) "helpString", NULL
35478 };
35479
35480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35482 if (SWIG_arg_fail(1)) SWIG_fail;
35483 {
35484 arg2 = (int)(SWIG_As_int(obj1));
35485 if (SWIG_arg_fail(2)) SWIG_fail;
35486 }
35487 {
35488 arg3 = wxString_in_helper(obj2);
35489 if (arg3 == NULL) SWIG_fail;
35490 temp3 = true;
35491 }
35492 {
35493 PyThreadState* __tstate = wxPyBeginAllowThreads();
35494 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35495
35496 wxPyEndAllowThreads(__tstate);
35497 if (PyErr_Occurred()) SWIG_fail;
35498 }
35499 Py_INCREF(Py_None); resultobj = Py_None;
35500 {
35501 if (temp3)
35502 delete arg3;
35503 }
35504 return resultobj;
35505 fail:
35506 {
35507 if (temp3)
35508 delete arg3;
35509 }
35510 return NULL;
35511 }
35512
35513
35514 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35515 PyObject *resultobj;
35516 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35517 int arg2 ;
35518 wxString result;
35519 PyObject * obj0 = 0 ;
35520 PyObject * obj1 = 0 ;
35521 char *kwnames[] = {
35522 (char *) "self",(char *) "id", NULL
35523 };
35524
35525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35527 if (SWIG_arg_fail(1)) SWIG_fail;
35528 {
35529 arg2 = (int)(SWIG_As_int(obj1));
35530 if (SWIG_arg_fail(2)) SWIG_fail;
35531 }
35532 {
35533 PyThreadState* __tstate = wxPyBeginAllowThreads();
35534 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35535
35536 wxPyEndAllowThreads(__tstate);
35537 if (PyErr_Occurred()) SWIG_fail;
35538 }
35539 {
35540 #if wxUSE_UNICODE
35541 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35542 #else
35543 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35544 #endif
35545 }
35546 return resultobj;
35547 fail:
35548 return NULL;
35549 }
35550
35551
35552 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35553 PyObject *resultobj;
35554 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35555 wxFrame *result;
35556 PyObject * obj0 = 0 ;
35557 char *kwnames[] = {
35558 (char *) "self", NULL
35559 };
35560
35561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35563 if (SWIG_arg_fail(1)) SWIG_fail;
35564 {
35565 PyThreadState* __tstate = wxPyBeginAllowThreads();
35566 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35567
35568 wxPyEndAllowThreads(__tstate);
35569 if (PyErr_Occurred()) SWIG_fail;
35570 }
35571 {
35572 resultobj = wxPyMake_wxObject(result, 0);
35573 }
35574 return resultobj;
35575 fail:
35576 return NULL;
35577 }
35578
35579
35580 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35581 PyObject *resultobj;
35582 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35583 bool result;
35584 PyObject * obj0 = 0 ;
35585 char *kwnames[] = {
35586 (char *) "self", NULL
35587 };
35588
35589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35591 if (SWIG_arg_fail(1)) SWIG_fail;
35592 {
35593 PyThreadState* __tstate = wxPyBeginAllowThreads();
35594 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35595
35596 wxPyEndAllowThreads(__tstate);
35597 if (PyErr_Occurred()) SWIG_fail;
35598 }
35599 {
35600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35601 }
35602 return resultobj;
35603 fail:
35604 return NULL;
35605 }
35606
35607
35608 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35609 PyObject *resultobj;
35610 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35611 wxFrame *arg2 = (wxFrame *) 0 ;
35612 PyObject * obj0 = 0 ;
35613 PyObject * obj1 = 0 ;
35614 char *kwnames[] = {
35615 (char *) "self",(char *) "frame", NULL
35616 };
35617
35618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35620 if (SWIG_arg_fail(1)) SWIG_fail;
35621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35622 if (SWIG_arg_fail(2)) SWIG_fail;
35623 {
35624 PyThreadState* __tstate = wxPyBeginAllowThreads();
35625 (arg1)->Attach(arg2);
35626
35627 wxPyEndAllowThreads(__tstate);
35628 if (PyErr_Occurred()) SWIG_fail;
35629 }
35630 Py_INCREF(Py_None); resultobj = Py_None;
35631 return resultobj;
35632 fail:
35633 return NULL;
35634 }
35635
35636
35637 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35638 PyObject *resultobj;
35639 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35640 PyObject * obj0 = 0 ;
35641 char *kwnames[] = {
35642 (char *) "self", NULL
35643 };
35644
35645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35647 if (SWIG_arg_fail(1)) SWIG_fail;
35648 {
35649 PyThreadState* __tstate = wxPyBeginAllowThreads();
35650 (arg1)->Detach();
35651
35652 wxPyEndAllowThreads(__tstate);
35653 if (PyErr_Occurred()) SWIG_fail;
35654 }
35655 Py_INCREF(Py_None); resultobj = Py_None;
35656 return resultobj;
35657 fail:
35658 return NULL;
35659 }
35660
35661
35662 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35663 PyObject *obj;
35664 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35665 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35666 Py_INCREF(obj);
35667 return Py_BuildValue((char *)"");
35668 }
35669 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35670 PyObject *resultobj;
35671 wxMenu *arg1 = (wxMenu *) NULL ;
35672 int arg2 = (int) wxID_ANY ;
35673 wxString const &arg3_defvalue = wxPyEmptyString ;
35674 wxString *arg3 = (wxString *) &arg3_defvalue ;
35675 wxString const &arg4_defvalue = wxPyEmptyString ;
35676 wxString *arg4 = (wxString *) &arg4_defvalue ;
35677 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35678 wxMenu *arg6 = (wxMenu *) NULL ;
35679 wxMenuItem *result;
35680 bool temp3 = false ;
35681 bool temp4 = false ;
35682 PyObject * obj0 = 0 ;
35683 PyObject * obj1 = 0 ;
35684 PyObject * obj2 = 0 ;
35685 PyObject * obj3 = 0 ;
35686 PyObject * obj4 = 0 ;
35687 PyObject * obj5 = 0 ;
35688 char *kwnames[] = {
35689 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35690 };
35691
35692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35693 if (obj0) {
35694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35695 if (SWIG_arg_fail(1)) SWIG_fail;
35696 }
35697 if (obj1) {
35698 {
35699 arg2 = (int)(SWIG_As_int(obj1));
35700 if (SWIG_arg_fail(2)) SWIG_fail;
35701 }
35702 }
35703 if (obj2) {
35704 {
35705 arg3 = wxString_in_helper(obj2);
35706 if (arg3 == NULL) SWIG_fail;
35707 temp3 = true;
35708 }
35709 }
35710 if (obj3) {
35711 {
35712 arg4 = wxString_in_helper(obj3);
35713 if (arg4 == NULL) SWIG_fail;
35714 temp4 = true;
35715 }
35716 }
35717 if (obj4) {
35718 {
35719 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35720 if (SWIG_arg_fail(5)) SWIG_fail;
35721 }
35722 }
35723 if (obj5) {
35724 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35725 if (SWIG_arg_fail(6)) SWIG_fail;
35726 }
35727 {
35728 PyThreadState* __tstate = wxPyBeginAllowThreads();
35729 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35730
35731 wxPyEndAllowThreads(__tstate);
35732 if (PyErr_Occurred()) SWIG_fail;
35733 }
35734 {
35735 resultobj = wxPyMake_wxObject(result, 1);
35736 }
35737 {
35738 if (temp3)
35739 delete arg3;
35740 }
35741 {
35742 if (temp4)
35743 delete arg4;
35744 }
35745 return resultobj;
35746 fail:
35747 {
35748 if (temp3)
35749 delete arg3;
35750 }
35751 {
35752 if (temp4)
35753 delete arg4;
35754 }
35755 return NULL;
35756 }
35757
35758
35759 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35760 PyObject *resultobj;
35761 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35762 wxMenu *result;
35763 PyObject * obj0 = 0 ;
35764 char *kwnames[] = {
35765 (char *) "self", NULL
35766 };
35767
35768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35770 if (SWIG_arg_fail(1)) SWIG_fail;
35771 {
35772 PyThreadState* __tstate = wxPyBeginAllowThreads();
35773 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35774
35775 wxPyEndAllowThreads(__tstate);
35776 if (PyErr_Occurred()) SWIG_fail;
35777 }
35778 {
35779 resultobj = wxPyMake_wxObject(result, 0);
35780 }
35781 return resultobj;
35782 fail:
35783 return NULL;
35784 }
35785
35786
35787 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35788 PyObject *resultobj;
35789 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35790 wxMenu *arg2 = (wxMenu *) 0 ;
35791 PyObject * obj0 = 0 ;
35792 PyObject * obj1 = 0 ;
35793 char *kwnames[] = {
35794 (char *) "self",(char *) "menu", NULL
35795 };
35796
35797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35799 if (SWIG_arg_fail(1)) SWIG_fail;
35800 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35801 if (SWIG_arg_fail(2)) SWIG_fail;
35802 {
35803 PyThreadState* __tstate = wxPyBeginAllowThreads();
35804 (arg1)->SetMenu(arg2);
35805
35806 wxPyEndAllowThreads(__tstate);
35807 if (PyErr_Occurred()) SWIG_fail;
35808 }
35809 Py_INCREF(Py_None); resultobj = Py_None;
35810 return resultobj;
35811 fail:
35812 return NULL;
35813 }
35814
35815
35816 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35817 PyObject *resultobj;
35818 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35819 int arg2 ;
35820 PyObject * obj0 = 0 ;
35821 PyObject * obj1 = 0 ;
35822 char *kwnames[] = {
35823 (char *) "self",(char *) "id", NULL
35824 };
35825
35826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35828 if (SWIG_arg_fail(1)) SWIG_fail;
35829 {
35830 arg2 = (int)(SWIG_As_int(obj1));
35831 if (SWIG_arg_fail(2)) SWIG_fail;
35832 }
35833 {
35834 PyThreadState* __tstate = wxPyBeginAllowThreads();
35835 (arg1)->SetId(arg2);
35836
35837 wxPyEndAllowThreads(__tstate);
35838 if (PyErr_Occurred()) SWIG_fail;
35839 }
35840 Py_INCREF(Py_None); resultobj = Py_None;
35841 return resultobj;
35842 fail:
35843 return NULL;
35844 }
35845
35846
35847 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35848 PyObject *resultobj;
35849 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35850 int result;
35851 PyObject * obj0 = 0 ;
35852 char *kwnames[] = {
35853 (char *) "self", NULL
35854 };
35855
35856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35858 if (SWIG_arg_fail(1)) SWIG_fail;
35859 {
35860 PyThreadState* __tstate = wxPyBeginAllowThreads();
35861 result = (int)((wxMenuItem const *)arg1)->GetId();
35862
35863 wxPyEndAllowThreads(__tstate);
35864 if (PyErr_Occurred()) SWIG_fail;
35865 }
35866 {
35867 resultobj = SWIG_From_int((int)(result));
35868 }
35869 return resultobj;
35870 fail:
35871 return NULL;
35872 }
35873
35874
35875 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35876 PyObject *resultobj;
35877 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35878 bool result;
35879 PyObject * obj0 = 0 ;
35880 char *kwnames[] = {
35881 (char *) "self", NULL
35882 };
35883
35884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35886 if (SWIG_arg_fail(1)) SWIG_fail;
35887 {
35888 PyThreadState* __tstate = wxPyBeginAllowThreads();
35889 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35890
35891 wxPyEndAllowThreads(__tstate);
35892 if (PyErr_Occurred()) SWIG_fail;
35893 }
35894 {
35895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35896 }
35897 return resultobj;
35898 fail:
35899 return NULL;
35900 }
35901
35902
35903 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35904 PyObject *resultobj;
35905 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35906 wxString *arg2 = 0 ;
35907 bool temp2 = false ;
35908 PyObject * obj0 = 0 ;
35909 PyObject * obj1 = 0 ;
35910 char *kwnames[] = {
35911 (char *) "self",(char *) "str", NULL
35912 };
35913
35914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35916 if (SWIG_arg_fail(1)) SWIG_fail;
35917 {
35918 arg2 = wxString_in_helper(obj1);
35919 if (arg2 == NULL) SWIG_fail;
35920 temp2 = true;
35921 }
35922 {
35923 PyThreadState* __tstate = wxPyBeginAllowThreads();
35924 (arg1)->SetText((wxString const &)*arg2);
35925
35926 wxPyEndAllowThreads(__tstate);
35927 if (PyErr_Occurred()) SWIG_fail;
35928 }
35929 Py_INCREF(Py_None); resultobj = Py_None;
35930 {
35931 if (temp2)
35932 delete arg2;
35933 }
35934 return resultobj;
35935 fail:
35936 {
35937 if (temp2)
35938 delete arg2;
35939 }
35940 return NULL;
35941 }
35942
35943
35944 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35945 PyObject *resultobj;
35946 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35947 wxString result;
35948 PyObject * obj0 = 0 ;
35949 char *kwnames[] = {
35950 (char *) "self", NULL
35951 };
35952
35953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35955 if (SWIG_arg_fail(1)) SWIG_fail;
35956 {
35957 PyThreadState* __tstate = wxPyBeginAllowThreads();
35958 result = ((wxMenuItem const *)arg1)->GetLabel();
35959
35960 wxPyEndAllowThreads(__tstate);
35961 if (PyErr_Occurred()) SWIG_fail;
35962 }
35963 {
35964 #if wxUSE_UNICODE
35965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35966 #else
35967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35968 #endif
35969 }
35970 return resultobj;
35971 fail:
35972 return NULL;
35973 }
35974
35975
35976 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35977 PyObject *resultobj;
35978 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35979 wxString *result;
35980 PyObject * obj0 = 0 ;
35981 char *kwnames[] = {
35982 (char *) "self", NULL
35983 };
35984
35985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35987 if (SWIG_arg_fail(1)) SWIG_fail;
35988 {
35989 PyThreadState* __tstate = wxPyBeginAllowThreads();
35990 {
35991 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35992 result = (wxString *) &_result_ref;
35993 }
35994
35995 wxPyEndAllowThreads(__tstate);
35996 if (PyErr_Occurred()) SWIG_fail;
35997 }
35998 {
35999 #if wxUSE_UNICODE
36000 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36001 #else
36002 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36003 #endif
36004 }
36005 return resultobj;
36006 fail:
36007 return NULL;
36008 }
36009
36010
36011 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36012 PyObject *resultobj;
36013 wxString *arg1 = 0 ;
36014 wxString result;
36015 bool temp1 = false ;
36016 PyObject * obj0 = 0 ;
36017 char *kwnames[] = {
36018 (char *) "text", NULL
36019 };
36020
36021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36022 {
36023 arg1 = wxString_in_helper(obj0);
36024 if (arg1 == NULL) SWIG_fail;
36025 temp1 = true;
36026 }
36027 {
36028 PyThreadState* __tstate = wxPyBeginAllowThreads();
36029 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36030
36031 wxPyEndAllowThreads(__tstate);
36032 if (PyErr_Occurred()) SWIG_fail;
36033 }
36034 {
36035 #if wxUSE_UNICODE
36036 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36037 #else
36038 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36039 #endif
36040 }
36041 {
36042 if (temp1)
36043 delete arg1;
36044 }
36045 return resultobj;
36046 fail:
36047 {
36048 if (temp1)
36049 delete arg1;
36050 }
36051 return NULL;
36052 }
36053
36054
36055 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36056 PyObject *resultobj;
36057 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36058 wxItemKind result;
36059 PyObject * obj0 = 0 ;
36060 char *kwnames[] = {
36061 (char *) "self", NULL
36062 };
36063
36064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36066 if (SWIG_arg_fail(1)) SWIG_fail;
36067 {
36068 PyThreadState* __tstate = wxPyBeginAllowThreads();
36069 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36070
36071 wxPyEndAllowThreads(__tstate);
36072 if (PyErr_Occurred()) SWIG_fail;
36073 }
36074 resultobj = SWIG_From_int((result));
36075 return resultobj;
36076 fail:
36077 return NULL;
36078 }
36079
36080
36081 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36082 PyObject *resultobj;
36083 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36084 wxItemKind arg2 ;
36085 PyObject * obj0 = 0 ;
36086 PyObject * obj1 = 0 ;
36087 char *kwnames[] = {
36088 (char *) "self",(char *) "kind", NULL
36089 };
36090
36091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",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 {
36095 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36096 if (SWIG_arg_fail(2)) SWIG_fail;
36097 }
36098 {
36099 PyThreadState* __tstate = wxPyBeginAllowThreads();
36100 (arg1)->SetKind((wxItemKind )arg2);
36101
36102 wxPyEndAllowThreads(__tstate);
36103 if (PyErr_Occurred()) SWIG_fail;
36104 }
36105 Py_INCREF(Py_None); resultobj = Py_None;
36106 return resultobj;
36107 fail:
36108 return NULL;
36109 }
36110
36111
36112 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36113 PyObject *resultobj;
36114 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36115 bool arg2 ;
36116 PyObject * obj0 = 0 ;
36117 PyObject * obj1 = 0 ;
36118 char *kwnames[] = {
36119 (char *) "self",(char *) "checkable", NULL
36120 };
36121
36122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36124 if (SWIG_arg_fail(1)) SWIG_fail;
36125 {
36126 arg2 = (bool)(SWIG_As_bool(obj1));
36127 if (SWIG_arg_fail(2)) SWIG_fail;
36128 }
36129 {
36130 PyThreadState* __tstate = wxPyBeginAllowThreads();
36131 (arg1)->SetCheckable(arg2);
36132
36133 wxPyEndAllowThreads(__tstate);
36134 if (PyErr_Occurred()) SWIG_fail;
36135 }
36136 Py_INCREF(Py_None); resultobj = Py_None;
36137 return resultobj;
36138 fail:
36139 return NULL;
36140 }
36141
36142
36143 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36144 PyObject *resultobj;
36145 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36146 bool result;
36147 PyObject * obj0 = 0 ;
36148 char *kwnames[] = {
36149 (char *) "self", NULL
36150 };
36151
36152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36154 if (SWIG_arg_fail(1)) SWIG_fail;
36155 {
36156 PyThreadState* __tstate = wxPyBeginAllowThreads();
36157 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36158
36159 wxPyEndAllowThreads(__tstate);
36160 if (PyErr_Occurred()) SWIG_fail;
36161 }
36162 {
36163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36164 }
36165 return resultobj;
36166 fail:
36167 return NULL;
36168 }
36169
36170
36171 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36172 PyObject *resultobj;
36173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36174 bool result;
36175 PyObject * obj0 = 0 ;
36176 char *kwnames[] = {
36177 (char *) "self", NULL
36178 };
36179
36180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36182 if (SWIG_arg_fail(1)) SWIG_fail;
36183 {
36184 PyThreadState* __tstate = wxPyBeginAllowThreads();
36185 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36186
36187 wxPyEndAllowThreads(__tstate);
36188 if (PyErr_Occurred()) SWIG_fail;
36189 }
36190 {
36191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36192 }
36193 return resultobj;
36194 fail:
36195 return NULL;
36196 }
36197
36198
36199 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36200 PyObject *resultobj;
36201 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36202 wxMenu *arg2 = (wxMenu *) 0 ;
36203 PyObject * obj0 = 0 ;
36204 PyObject * obj1 = 0 ;
36205 char *kwnames[] = {
36206 (char *) "self",(char *) "menu", NULL
36207 };
36208
36209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36211 if (SWIG_arg_fail(1)) SWIG_fail;
36212 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36213 if (SWIG_arg_fail(2)) SWIG_fail;
36214 {
36215 PyThreadState* __tstate = wxPyBeginAllowThreads();
36216 (arg1)->SetSubMenu(arg2);
36217
36218 wxPyEndAllowThreads(__tstate);
36219 if (PyErr_Occurred()) SWIG_fail;
36220 }
36221 Py_INCREF(Py_None); resultobj = Py_None;
36222 return resultobj;
36223 fail:
36224 return NULL;
36225 }
36226
36227
36228 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36229 PyObject *resultobj;
36230 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36231 wxMenu *result;
36232 PyObject * obj0 = 0 ;
36233 char *kwnames[] = {
36234 (char *) "self", NULL
36235 };
36236
36237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36239 if (SWIG_arg_fail(1)) SWIG_fail;
36240 {
36241 PyThreadState* __tstate = wxPyBeginAllowThreads();
36242 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36243
36244 wxPyEndAllowThreads(__tstate);
36245 if (PyErr_Occurred()) SWIG_fail;
36246 }
36247 {
36248 resultobj = wxPyMake_wxObject(result, 0);
36249 }
36250 return resultobj;
36251 fail:
36252 return NULL;
36253 }
36254
36255
36256 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36257 PyObject *resultobj;
36258 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36259 bool arg2 = (bool) true ;
36260 PyObject * obj0 = 0 ;
36261 PyObject * obj1 = 0 ;
36262 char *kwnames[] = {
36263 (char *) "self",(char *) "enable", NULL
36264 };
36265
36266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36268 if (SWIG_arg_fail(1)) SWIG_fail;
36269 if (obj1) {
36270 {
36271 arg2 = (bool)(SWIG_As_bool(obj1));
36272 if (SWIG_arg_fail(2)) SWIG_fail;
36273 }
36274 }
36275 {
36276 PyThreadState* __tstate = wxPyBeginAllowThreads();
36277 (arg1)->Enable(arg2);
36278
36279 wxPyEndAllowThreads(__tstate);
36280 if (PyErr_Occurred()) SWIG_fail;
36281 }
36282 Py_INCREF(Py_None); resultobj = Py_None;
36283 return resultobj;
36284 fail:
36285 return NULL;
36286 }
36287
36288
36289 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36290 PyObject *resultobj;
36291 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36292 bool result;
36293 PyObject * obj0 = 0 ;
36294 char *kwnames[] = {
36295 (char *) "self", NULL
36296 };
36297
36298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36300 if (SWIG_arg_fail(1)) SWIG_fail;
36301 {
36302 PyThreadState* __tstate = wxPyBeginAllowThreads();
36303 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36304
36305 wxPyEndAllowThreads(__tstate);
36306 if (PyErr_Occurred()) SWIG_fail;
36307 }
36308 {
36309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36310 }
36311 return resultobj;
36312 fail:
36313 return NULL;
36314 }
36315
36316
36317 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36318 PyObject *resultobj;
36319 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36320 bool arg2 = (bool) true ;
36321 PyObject * obj0 = 0 ;
36322 PyObject * obj1 = 0 ;
36323 char *kwnames[] = {
36324 (char *) "self",(char *) "check", NULL
36325 };
36326
36327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36329 if (SWIG_arg_fail(1)) SWIG_fail;
36330 if (obj1) {
36331 {
36332 arg2 = (bool)(SWIG_As_bool(obj1));
36333 if (SWIG_arg_fail(2)) SWIG_fail;
36334 }
36335 }
36336 {
36337 PyThreadState* __tstate = wxPyBeginAllowThreads();
36338 (arg1)->Check(arg2);
36339
36340 wxPyEndAllowThreads(__tstate);
36341 if (PyErr_Occurred()) SWIG_fail;
36342 }
36343 Py_INCREF(Py_None); resultobj = Py_None;
36344 return resultobj;
36345 fail:
36346 return NULL;
36347 }
36348
36349
36350 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36351 PyObject *resultobj;
36352 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36353 bool result;
36354 PyObject * obj0 = 0 ;
36355 char *kwnames[] = {
36356 (char *) "self", NULL
36357 };
36358
36359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36361 if (SWIG_arg_fail(1)) SWIG_fail;
36362 {
36363 PyThreadState* __tstate = wxPyBeginAllowThreads();
36364 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36365
36366 wxPyEndAllowThreads(__tstate);
36367 if (PyErr_Occurred()) SWIG_fail;
36368 }
36369 {
36370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36371 }
36372 return resultobj;
36373 fail:
36374 return NULL;
36375 }
36376
36377
36378 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36379 PyObject *resultobj;
36380 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36381 PyObject * obj0 = 0 ;
36382 char *kwnames[] = {
36383 (char *) "self", NULL
36384 };
36385
36386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36388 if (SWIG_arg_fail(1)) SWIG_fail;
36389 {
36390 PyThreadState* __tstate = wxPyBeginAllowThreads();
36391 (arg1)->Toggle();
36392
36393 wxPyEndAllowThreads(__tstate);
36394 if (PyErr_Occurred()) SWIG_fail;
36395 }
36396 Py_INCREF(Py_None); resultobj = Py_None;
36397 return resultobj;
36398 fail:
36399 return NULL;
36400 }
36401
36402
36403 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36404 PyObject *resultobj;
36405 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36406 wxString *arg2 = 0 ;
36407 bool temp2 = false ;
36408 PyObject * obj0 = 0 ;
36409 PyObject * obj1 = 0 ;
36410 char *kwnames[] = {
36411 (char *) "self",(char *) "str", NULL
36412 };
36413
36414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36416 if (SWIG_arg_fail(1)) SWIG_fail;
36417 {
36418 arg2 = wxString_in_helper(obj1);
36419 if (arg2 == NULL) SWIG_fail;
36420 temp2 = true;
36421 }
36422 {
36423 PyThreadState* __tstate = wxPyBeginAllowThreads();
36424 (arg1)->SetHelp((wxString const &)*arg2);
36425
36426 wxPyEndAllowThreads(__tstate);
36427 if (PyErr_Occurred()) SWIG_fail;
36428 }
36429 Py_INCREF(Py_None); resultobj = Py_None;
36430 {
36431 if (temp2)
36432 delete arg2;
36433 }
36434 return resultobj;
36435 fail:
36436 {
36437 if (temp2)
36438 delete arg2;
36439 }
36440 return NULL;
36441 }
36442
36443
36444 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36445 PyObject *resultobj;
36446 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36447 wxString *result;
36448 PyObject * obj0 = 0 ;
36449 char *kwnames[] = {
36450 (char *) "self", NULL
36451 };
36452
36453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36455 if (SWIG_arg_fail(1)) SWIG_fail;
36456 {
36457 PyThreadState* __tstate = wxPyBeginAllowThreads();
36458 {
36459 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36460 result = (wxString *) &_result_ref;
36461 }
36462
36463 wxPyEndAllowThreads(__tstate);
36464 if (PyErr_Occurred()) SWIG_fail;
36465 }
36466 {
36467 #if wxUSE_UNICODE
36468 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36469 #else
36470 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36471 #endif
36472 }
36473 return resultobj;
36474 fail:
36475 return NULL;
36476 }
36477
36478
36479 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36480 PyObject *resultobj;
36481 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36482 wxAcceleratorEntry *result;
36483 PyObject * obj0 = 0 ;
36484 char *kwnames[] = {
36485 (char *) "self", NULL
36486 };
36487
36488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36490 if (SWIG_arg_fail(1)) SWIG_fail;
36491 {
36492 PyThreadState* __tstate = wxPyBeginAllowThreads();
36493 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36494
36495 wxPyEndAllowThreads(__tstate);
36496 if (PyErr_Occurred()) SWIG_fail;
36497 }
36498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36499 return resultobj;
36500 fail:
36501 return NULL;
36502 }
36503
36504
36505 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36506 PyObject *resultobj;
36507 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36508 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36509 PyObject * obj0 = 0 ;
36510 PyObject * obj1 = 0 ;
36511 char *kwnames[] = {
36512 (char *) "self",(char *) "accel", NULL
36513 };
36514
36515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36517 if (SWIG_arg_fail(1)) SWIG_fail;
36518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36519 if (SWIG_arg_fail(2)) SWIG_fail;
36520 {
36521 PyThreadState* __tstate = wxPyBeginAllowThreads();
36522 (arg1)->SetAccel(arg2);
36523
36524 wxPyEndAllowThreads(__tstate);
36525 if (PyErr_Occurred()) SWIG_fail;
36526 }
36527 Py_INCREF(Py_None); resultobj = Py_None;
36528 return resultobj;
36529 fail:
36530 return NULL;
36531 }
36532
36533
36534 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36535 PyObject *resultobj;
36536 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36537 wxFont *arg2 = 0 ;
36538 PyObject * obj0 = 0 ;
36539 PyObject * obj1 = 0 ;
36540 char *kwnames[] = {
36541 (char *) "self",(char *) "font", NULL
36542 };
36543
36544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36546 if (SWIG_arg_fail(1)) SWIG_fail;
36547 {
36548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36549 if (SWIG_arg_fail(2)) SWIG_fail;
36550 if (arg2 == NULL) {
36551 SWIG_null_ref("wxFont");
36552 }
36553 if (SWIG_arg_fail(2)) SWIG_fail;
36554 }
36555 {
36556 PyThreadState* __tstate = wxPyBeginAllowThreads();
36557 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36558
36559 wxPyEndAllowThreads(__tstate);
36560 if (PyErr_Occurred()) SWIG_fail;
36561 }
36562 Py_INCREF(Py_None); resultobj = Py_None;
36563 return resultobj;
36564 fail:
36565 return NULL;
36566 }
36567
36568
36569 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36570 PyObject *resultobj;
36571 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36572 wxFont result;
36573 PyObject * obj0 = 0 ;
36574 char *kwnames[] = {
36575 (char *) "self", NULL
36576 };
36577
36578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36580 if (SWIG_arg_fail(1)) SWIG_fail;
36581 {
36582 PyThreadState* __tstate = wxPyBeginAllowThreads();
36583 result = wxMenuItem_GetFont(arg1);
36584
36585 wxPyEndAllowThreads(__tstate);
36586 if (PyErr_Occurred()) SWIG_fail;
36587 }
36588 {
36589 wxFont * resultptr;
36590 resultptr = new wxFont((wxFont &)(result));
36591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36592 }
36593 return resultobj;
36594 fail:
36595 return NULL;
36596 }
36597
36598
36599 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36600 PyObject *resultobj;
36601 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36602 wxColour *arg2 = 0 ;
36603 wxColour temp2 ;
36604 PyObject * obj0 = 0 ;
36605 PyObject * obj1 = 0 ;
36606 char *kwnames[] = {
36607 (char *) "self",(char *) "colText", NULL
36608 };
36609
36610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36612 if (SWIG_arg_fail(1)) SWIG_fail;
36613 {
36614 arg2 = &temp2;
36615 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36616 }
36617 {
36618 PyThreadState* __tstate = wxPyBeginAllowThreads();
36619 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36620
36621 wxPyEndAllowThreads(__tstate);
36622 if (PyErr_Occurred()) SWIG_fail;
36623 }
36624 Py_INCREF(Py_None); resultobj = Py_None;
36625 return resultobj;
36626 fail:
36627 return NULL;
36628 }
36629
36630
36631 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36632 PyObject *resultobj;
36633 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36634 wxColour result;
36635 PyObject * obj0 = 0 ;
36636 char *kwnames[] = {
36637 (char *) "self", NULL
36638 };
36639
36640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36642 if (SWIG_arg_fail(1)) SWIG_fail;
36643 {
36644 PyThreadState* __tstate = wxPyBeginAllowThreads();
36645 result = wxMenuItem_GetTextColour(arg1);
36646
36647 wxPyEndAllowThreads(__tstate);
36648 if (PyErr_Occurred()) SWIG_fail;
36649 }
36650 {
36651 wxColour * resultptr;
36652 resultptr = new wxColour((wxColour &)(result));
36653 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36654 }
36655 return resultobj;
36656 fail:
36657 return NULL;
36658 }
36659
36660
36661 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36662 PyObject *resultobj;
36663 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36664 wxColour *arg2 = 0 ;
36665 wxColour temp2 ;
36666 PyObject * obj0 = 0 ;
36667 PyObject * obj1 = 0 ;
36668 char *kwnames[] = {
36669 (char *) "self",(char *) "colBack", NULL
36670 };
36671
36672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36674 if (SWIG_arg_fail(1)) SWIG_fail;
36675 {
36676 arg2 = &temp2;
36677 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36678 }
36679 {
36680 PyThreadState* __tstate = wxPyBeginAllowThreads();
36681 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36682
36683 wxPyEndAllowThreads(__tstate);
36684 if (PyErr_Occurred()) SWIG_fail;
36685 }
36686 Py_INCREF(Py_None); resultobj = Py_None;
36687 return resultobj;
36688 fail:
36689 return NULL;
36690 }
36691
36692
36693 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36694 PyObject *resultobj;
36695 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36696 wxColour result;
36697 PyObject * obj0 = 0 ;
36698 char *kwnames[] = {
36699 (char *) "self", NULL
36700 };
36701
36702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36704 if (SWIG_arg_fail(1)) SWIG_fail;
36705 {
36706 PyThreadState* __tstate = wxPyBeginAllowThreads();
36707 result = wxMenuItem_GetBackgroundColour(arg1);
36708
36709 wxPyEndAllowThreads(__tstate);
36710 if (PyErr_Occurred()) SWIG_fail;
36711 }
36712 {
36713 wxColour * resultptr;
36714 resultptr = new wxColour((wxColour &)(result));
36715 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36716 }
36717 return resultobj;
36718 fail:
36719 return NULL;
36720 }
36721
36722
36723 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36724 PyObject *resultobj;
36725 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36726 wxBitmap *arg2 = 0 ;
36727 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36728 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36729 PyObject * obj0 = 0 ;
36730 PyObject * obj1 = 0 ;
36731 PyObject * obj2 = 0 ;
36732 char *kwnames[] = {
36733 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36734 };
36735
36736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36738 if (SWIG_arg_fail(1)) SWIG_fail;
36739 {
36740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36741 if (SWIG_arg_fail(2)) SWIG_fail;
36742 if (arg2 == NULL) {
36743 SWIG_null_ref("wxBitmap");
36744 }
36745 if (SWIG_arg_fail(2)) SWIG_fail;
36746 }
36747 if (obj2) {
36748 {
36749 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36750 if (SWIG_arg_fail(3)) SWIG_fail;
36751 if (arg3 == NULL) {
36752 SWIG_null_ref("wxBitmap");
36753 }
36754 if (SWIG_arg_fail(3)) SWIG_fail;
36755 }
36756 }
36757 {
36758 PyThreadState* __tstate = wxPyBeginAllowThreads();
36759 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
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_SetDisabledBitmap(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 *) "bmpDisabled", NULL
36779 };
36780
36781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",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 wxMenuItem_SetDisabledBitmap(arg1,(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_GetDisabledBitmap(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_GetDisabledBitmap",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 = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
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 *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36839 PyObject *resultobj;
36840 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36841 int arg2 ;
36842 PyObject * obj0 = 0 ;
36843 PyObject * obj1 = 0 ;
36844 char *kwnames[] = {
36845 (char *) "self",(char *) "nWidth", NULL
36846 };
36847
36848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36850 if (SWIG_arg_fail(1)) SWIG_fail;
36851 {
36852 arg2 = (int)(SWIG_As_int(obj1));
36853 if (SWIG_arg_fail(2)) SWIG_fail;
36854 }
36855 {
36856 PyThreadState* __tstate = wxPyBeginAllowThreads();
36857 wxMenuItem_SetMarginWidth(arg1,arg2);
36858
36859 wxPyEndAllowThreads(__tstate);
36860 if (PyErr_Occurred()) SWIG_fail;
36861 }
36862 Py_INCREF(Py_None); resultobj = Py_None;
36863 return resultobj;
36864 fail:
36865 return NULL;
36866 }
36867
36868
36869 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36870 PyObject *resultobj;
36871 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36872 int result;
36873 PyObject * obj0 = 0 ;
36874 char *kwnames[] = {
36875 (char *) "self", NULL
36876 };
36877
36878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36880 if (SWIG_arg_fail(1)) SWIG_fail;
36881 {
36882 PyThreadState* __tstate = wxPyBeginAllowThreads();
36883 result = (int)wxMenuItem_GetMarginWidth(arg1);
36884
36885 wxPyEndAllowThreads(__tstate);
36886 if (PyErr_Occurred()) SWIG_fail;
36887 }
36888 {
36889 resultobj = SWIG_From_int((int)(result));
36890 }
36891 return resultobj;
36892 fail:
36893 return NULL;
36894 }
36895
36896
36897 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36898 PyObject *resultobj;
36899 int result;
36900 char *kwnames[] = {
36901 NULL
36902 };
36903
36904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36905 {
36906 PyThreadState* __tstate = wxPyBeginAllowThreads();
36907 result = (int)MenuItem_GetDefaultMarginWidth();
36908
36909 wxPyEndAllowThreads(__tstate);
36910 if (PyErr_Occurred()) SWIG_fail;
36911 }
36912 {
36913 resultobj = SWIG_From_int((int)(result));
36914 }
36915 return resultobj;
36916 fail:
36917 return NULL;
36918 }
36919
36920
36921 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36922 PyObject *resultobj;
36923 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36924 bool result;
36925 PyObject * obj0 = 0 ;
36926 char *kwnames[] = {
36927 (char *) "self", NULL
36928 };
36929
36930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36932 if (SWIG_arg_fail(1)) SWIG_fail;
36933 {
36934 PyThreadState* __tstate = wxPyBeginAllowThreads();
36935 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
36936
36937 wxPyEndAllowThreads(__tstate);
36938 if (PyErr_Occurred()) SWIG_fail;
36939 }
36940 {
36941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36942 }
36943 return resultobj;
36944 fail:
36945 return NULL;
36946 }
36947
36948
36949 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36950 PyObject *resultobj;
36951 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36952 bool arg2 = (bool) true ;
36953 PyObject * obj0 = 0 ;
36954 PyObject * obj1 = 0 ;
36955 char *kwnames[] = {
36956 (char *) "self",(char *) "ownerDrawn", NULL
36957 };
36958
36959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36961 if (SWIG_arg_fail(1)) SWIG_fail;
36962 if (obj1) {
36963 {
36964 arg2 = (bool)(SWIG_As_bool(obj1));
36965 if (SWIG_arg_fail(2)) SWIG_fail;
36966 }
36967 }
36968 {
36969 PyThreadState* __tstate = wxPyBeginAllowThreads();
36970 wxMenuItem_SetOwnerDrawn(arg1,arg2);
36971
36972 wxPyEndAllowThreads(__tstate);
36973 if (PyErr_Occurred()) SWIG_fail;
36974 }
36975 Py_INCREF(Py_None); resultobj = Py_None;
36976 return resultobj;
36977 fail:
36978 return NULL;
36979 }
36980
36981
36982 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36983 PyObject *resultobj;
36984 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36985 PyObject * obj0 = 0 ;
36986 char *kwnames[] = {
36987 (char *) "self", NULL
36988 };
36989
36990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36992 if (SWIG_arg_fail(1)) SWIG_fail;
36993 {
36994 PyThreadState* __tstate = wxPyBeginAllowThreads();
36995 wxMenuItem_ResetOwnerDrawn(arg1);
36996
36997 wxPyEndAllowThreads(__tstate);
36998 if (PyErr_Occurred()) SWIG_fail;
36999 }
37000 Py_INCREF(Py_None); resultobj = Py_None;
37001 return resultobj;
37002 fail:
37003 return NULL;
37004 }
37005
37006
37007 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37008 PyObject *resultobj;
37009 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37010 wxBitmap *arg2 = 0 ;
37011 PyObject * obj0 = 0 ;
37012 PyObject * obj1 = 0 ;
37013 char *kwnames[] = {
37014 (char *) "self",(char *) "bitmap", NULL
37015 };
37016
37017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37019 if (SWIG_arg_fail(1)) SWIG_fail;
37020 {
37021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37022 if (SWIG_arg_fail(2)) SWIG_fail;
37023 if (arg2 == NULL) {
37024 SWIG_null_ref("wxBitmap");
37025 }
37026 if (SWIG_arg_fail(2)) SWIG_fail;
37027 }
37028 {
37029 PyThreadState* __tstate = wxPyBeginAllowThreads();
37030 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37031
37032 wxPyEndAllowThreads(__tstate);
37033 if (PyErr_Occurred()) SWIG_fail;
37034 }
37035 Py_INCREF(Py_None); resultobj = Py_None;
37036 return resultobj;
37037 fail:
37038 return NULL;
37039 }
37040
37041
37042 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37043 PyObject *resultobj;
37044 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37045 wxBitmap *result;
37046 PyObject * obj0 = 0 ;
37047 char *kwnames[] = {
37048 (char *) "self", NULL
37049 };
37050
37051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37053 if (SWIG_arg_fail(1)) SWIG_fail;
37054 {
37055 PyThreadState* __tstate = wxPyBeginAllowThreads();
37056 {
37057 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37058 result = (wxBitmap *) &_result_ref;
37059 }
37060
37061 wxPyEndAllowThreads(__tstate);
37062 if (PyErr_Occurred()) SWIG_fail;
37063 }
37064 {
37065 wxBitmap* resultptr = new wxBitmap(*result);
37066 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37067 }
37068 return resultobj;
37069 fail:
37070 return NULL;
37071 }
37072
37073
37074 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37075 PyObject *obj;
37076 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37077 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37078 Py_INCREF(obj);
37079 return Py_BuildValue((char *)"");
37080 }
37081 static int _wrap_ControlNameStr_set(PyObject *) {
37082 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37083 return 1;
37084 }
37085
37086
37087 static PyObject *_wrap_ControlNameStr_get(void) {
37088 PyObject *pyobj;
37089
37090 {
37091 #if wxUSE_UNICODE
37092 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37093 #else
37094 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37095 #endif
37096 }
37097 return pyobj;
37098 }
37099
37100
37101 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37102 PyObject *resultobj;
37103 wxWindow *arg1 = (wxWindow *) 0 ;
37104 int arg2 = (int) -1 ;
37105 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37106 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37107 wxSize const &arg4_defvalue = wxDefaultSize ;
37108 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37109 long arg5 = (long) 0 ;
37110 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37111 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37112 wxString const &arg7_defvalue = wxPyControlNameStr ;
37113 wxString *arg7 = (wxString *) &arg7_defvalue ;
37114 wxControl *result;
37115 wxPoint temp3 ;
37116 wxSize temp4 ;
37117 bool temp7 = false ;
37118 PyObject * obj0 = 0 ;
37119 PyObject * obj1 = 0 ;
37120 PyObject * obj2 = 0 ;
37121 PyObject * obj3 = 0 ;
37122 PyObject * obj4 = 0 ;
37123 PyObject * obj5 = 0 ;
37124 PyObject * obj6 = 0 ;
37125 char *kwnames[] = {
37126 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37127 };
37128
37129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37131 if (SWIG_arg_fail(1)) SWIG_fail;
37132 if (obj1) {
37133 {
37134 arg2 = (int)(SWIG_As_int(obj1));
37135 if (SWIG_arg_fail(2)) SWIG_fail;
37136 }
37137 }
37138 if (obj2) {
37139 {
37140 arg3 = &temp3;
37141 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37142 }
37143 }
37144 if (obj3) {
37145 {
37146 arg4 = &temp4;
37147 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37148 }
37149 }
37150 if (obj4) {
37151 {
37152 arg5 = (long)(SWIG_As_long(obj4));
37153 if (SWIG_arg_fail(5)) SWIG_fail;
37154 }
37155 }
37156 if (obj5) {
37157 {
37158 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37159 if (SWIG_arg_fail(6)) SWIG_fail;
37160 if (arg6 == NULL) {
37161 SWIG_null_ref("wxValidator");
37162 }
37163 if (SWIG_arg_fail(6)) SWIG_fail;
37164 }
37165 }
37166 if (obj6) {
37167 {
37168 arg7 = wxString_in_helper(obj6);
37169 if (arg7 == NULL) SWIG_fail;
37170 temp7 = true;
37171 }
37172 }
37173 {
37174 if (!wxPyCheckForApp()) SWIG_fail;
37175 PyThreadState* __tstate = wxPyBeginAllowThreads();
37176 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37177
37178 wxPyEndAllowThreads(__tstate);
37179 if (PyErr_Occurred()) SWIG_fail;
37180 }
37181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37182 {
37183 if (temp7)
37184 delete arg7;
37185 }
37186 return resultobj;
37187 fail:
37188 {
37189 if (temp7)
37190 delete arg7;
37191 }
37192 return NULL;
37193 }
37194
37195
37196 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37197 PyObject *resultobj;
37198 wxControl *result;
37199 char *kwnames[] = {
37200 NULL
37201 };
37202
37203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37204 {
37205 if (!wxPyCheckForApp()) SWIG_fail;
37206 PyThreadState* __tstate = wxPyBeginAllowThreads();
37207 result = (wxControl *)new wxControl();
37208
37209 wxPyEndAllowThreads(__tstate);
37210 if (PyErr_Occurred()) SWIG_fail;
37211 }
37212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37213 return resultobj;
37214 fail:
37215 return NULL;
37216 }
37217
37218
37219 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37220 PyObject *resultobj;
37221 wxControl *arg1 = (wxControl *) 0 ;
37222 wxWindow *arg2 = (wxWindow *) 0 ;
37223 int arg3 = (int) -1 ;
37224 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37225 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37226 wxSize const &arg5_defvalue = wxDefaultSize ;
37227 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37228 long arg6 = (long) 0 ;
37229 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37230 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37231 wxString const &arg8_defvalue = wxPyControlNameStr ;
37232 wxString *arg8 = (wxString *) &arg8_defvalue ;
37233 bool result;
37234 wxPoint temp4 ;
37235 wxSize temp5 ;
37236 bool temp8 = false ;
37237 PyObject * obj0 = 0 ;
37238 PyObject * obj1 = 0 ;
37239 PyObject * obj2 = 0 ;
37240 PyObject * obj3 = 0 ;
37241 PyObject * obj4 = 0 ;
37242 PyObject * obj5 = 0 ;
37243 PyObject * obj6 = 0 ;
37244 PyObject * obj7 = 0 ;
37245 char *kwnames[] = {
37246 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37247 };
37248
37249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37251 if (SWIG_arg_fail(1)) SWIG_fail;
37252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37253 if (SWIG_arg_fail(2)) SWIG_fail;
37254 if (obj2) {
37255 {
37256 arg3 = (int)(SWIG_As_int(obj2));
37257 if (SWIG_arg_fail(3)) SWIG_fail;
37258 }
37259 }
37260 if (obj3) {
37261 {
37262 arg4 = &temp4;
37263 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37264 }
37265 }
37266 if (obj4) {
37267 {
37268 arg5 = &temp5;
37269 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37270 }
37271 }
37272 if (obj5) {
37273 {
37274 arg6 = (long)(SWIG_As_long(obj5));
37275 if (SWIG_arg_fail(6)) SWIG_fail;
37276 }
37277 }
37278 if (obj6) {
37279 {
37280 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37281 if (SWIG_arg_fail(7)) SWIG_fail;
37282 if (arg7 == NULL) {
37283 SWIG_null_ref("wxValidator");
37284 }
37285 if (SWIG_arg_fail(7)) SWIG_fail;
37286 }
37287 }
37288 if (obj7) {
37289 {
37290 arg8 = wxString_in_helper(obj7);
37291 if (arg8 == NULL) SWIG_fail;
37292 temp8 = true;
37293 }
37294 }
37295 {
37296 PyThreadState* __tstate = wxPyBeginAllowThreads();
37297 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37298
37299 wxPyEndAllowThreads(__tstate);
37300 if (PyErr_Occurred()) SWIG_fail;
37301 }
37302 {
37303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37304 }
37305 {
37306 if (temp8)
37307 delete arg8;
37308 }
37309 return resultobj;
37310 fail:
37311 {
37312 if (temp8)
37313 delete arg8;
37314 }
37315 return NULL;
37316 }
37317
37318
37319 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37320 PyObject *resultobj;
37321 wxControl *arg1 = (wxControl *) 0 ;
37322 wxCommandEvent *arg2 = 0 ;
37323 PyObject * obj0 = 0 ;
37324 PyObject * obj1 = 0 ;
37325 char *kwnames[] = {
37326 (char *) "self",(char *) "event", NULL
37327 };
37328
37329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37331 if (SWIG_arg_fail(1)) SWIG_fail;
37332 {
37333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37334 if (SWIG_arg_fail(2)) SWIG_fail;
37335 if (arg2 == NULL) {
37336 SWIG_null_ref("wxCommandEvent");
37337 }
37338 if (SWIG_arg_fail(2)) SWIG_fail;
37339 }
37340 {
37341 PyThreadState* __tstate = wxPyBeginAllowThreads();
37342 (arg1)->Command(*arg2);
37343
37344 wxPyEndAllowThreads(__tstate);
37345 if (PyErr_Occurred()) SWIG_fail;
37346 }
37347 Py_INCREF(Py_None); resultobj = Py_None;
37348 return resultobj;
37349 fail:
37350 return NULL;
37351 }
37352
37353
37354 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37355 PyObject *resultobj;
37356 wxControl *arg1 = (wxControl *) 0 ;
37357 wxString result;
37358 PyObject * obj0 = 0 ;
37359 char *kwnames[] = {
37360 (char *) "self", NULL
37361 };
37362
37363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37365 if (SWIG_arg_fail(1)) SWIG_fail;
37366 {
37367 PyThreadState* __tstate = wxPyBeginAllowThreads();
37368 result = (arg1)->GetLabel();
37369
37370 wxPyEndAllowThreads(__tstate);
37371 if (PyErr_Occurred()) SWIG_fail;
37372 }
37373 {
37374 #if wxUSE_UNICODE
37375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37376 #else
37377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37378 #endif
37379 }
37380 return resultobj;
37381 fail:
37382 return NULL;
37383 }
37384
37385
37386 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37387 PyObject *resultobj;
37388 wxControl *arg1 = (wxControl *) 0 ;
37389 wxString *arg2 = 0 ;
37390 bool temp2 = false ;
37391 PyObject * obj0 = 0 ;
37392 PyObject * obj1 = 0 ;
37393 char *kwnames[] = {
37394 (char *) "self",(char *) "label", NULL
37395 };
37396
37397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37399 if (SWIG_arg_fail(1)) SWIG_fail;
37400 {
37401 arg2 = wxString_in_helper(obj1);
37402 if (arg2 == NULL) SWIG_fail;
37403 temp2 = true;
37404 }
37405 {
37406 PyThreadState* __tstate = wxPyBeginAllowThreads();
37407 (arg1)->SetLabel((wxString const &)*arg2);
37408
37409 wxPyEndAllowThreads(__tstate);
37410 if (PyErr_Occurred()) SWIG_fail;
37411 }
37412 Py_INCREF(Py_None); resultobj = Py_None;
37413 {
37414 if (temp2)
37415 delete arg2;
37416 }
37417 return resultobj;
37418 fail:
37419 {
37420 if (temp2)
37421 delete arg2;
37422 }
37423 return NULL;
37424 }
37425
37426
37427 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37428 PyObject *resultobj;
37429 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37430 wxVisualAttributes result;
37431 PyObject * obj0 = 0 ;
37432 char *kwnames[] = {
37433 (char *) "variant", NULL
37434 };
37435
37436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37437 if (obj0) {
37438 {
37439 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37440 if (SWIG_arg_fail(1)) SWIG_fail;
37441 }
37442 }
37443 {
37444 if (!wxPyCheckForApp()) SWIG_fail;
37445 PyThreadState* __tstate = wxPyBeginAllowThreads();
37446 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37447
37448 wxPyEndAllowThreads(__tstate);
37449 if (PyErr_Occurred()) SWIG_fail;
37450 }
37451 {
37452 wxVisualAttributes * resultptr;
37453 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37454 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37455 }
37456 return resultobj;
37457 fail:
37458 return NULL;
37459 }
37460
37461
37462 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37463 PyObject *obj;
37464 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37465 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37466 Py_INCREF(obj);
37467 return Py_BuildValue((char *)"");
37468 }
37469 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37470 PyObject *resultobj;
37471 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37472 wxString *arg2 = 0 ;
37473 PyObject *arg3 = (PyObject *) NULL ;
37474 int result;
37475 bool temp2 = false ;
37476 PyObject * obj0 = 0 ;
37477 PyObject * obj1 = 0 ;
37478 PyObject * obj2 = 0 ;
37479 char *kwnames[] = {
37480 (char *) "self",(char *) "item",(char *) "clientData", NULL
37481 };
37482
37483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37485 if (SWIG_arg_fail(1)) SWIG_fail;
37486 {
37487 arg2 = wxString_in_helper(obj1);
37488 if (arg2 == NULL) SWIG_fail;
37489 temp2 = true;
37490 }
37491 if (obj2) {
37492 arg3 = obj2;
37493 }
37494 {
37495 PyThreadState* __tstate = wxPyBeginAllowThreads();
37496 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37497
37498 wxPyEndAllowThreads(__tstate);
37499 if (PyErr_Occurred()) SWIG_fail;
37500 }
37501 {
37502 resultobj = SWIG_From_int((int)(result));
37503 }
37504 {
37505 if (temp2)
37506 delete arg2;
37507 }
37508 return resultobj;
37509 fail:
37510 {
37511 if (temp2)
37512 delete arg2;
37513 }
37514 return NULL;
37515 }
37516
37517
37518 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37519 PyObject *resultobj;
37520 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37521 wxArrayString *arg2 = 0 ;
37522 bool temp2 = false ;
37523 PyObject * obj0 = 0 ;
37524 PyObject * obj1 = 0 ;
37525 char *kwnames[] = {
37526 (char *) "self",(char *) "strings", NULL
37527 };
37528
37529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37531 if (SWIG_arg_fail(1)) SWIG_fail;
37532 {
37533 if (! PySequence_Check(obj1)) {
37534 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37535 SWIG_fail;
37536 }
37537 arg2 = new wxArrayString;
37538 temp2 = true;
37539 int i, len=PySequence_Length(obj1);
37540 for (i=0; i<len; i++) {
37541 PyObject* item = PySequence_GetItem(obj1, i);
37542 #if wxUSE_UNICODE
37543 PyObject* str = PyObject_Unicode(item);
37544 #else
37545 PyObject* str = PyObject_Str(item);
37546 #endif
37547 if (PyErr_Occurred()) SWIG_fail;
37548 arg2->Add(Py2wxString(str));
37549 Py_DECREF(item);
37550 Py_DECREF(str);
37551 }
37552 }
37553 {
37554 PyThreadState* __tstate = wxPyBeginAllowThreads();
37555 (arg1)->Append((wxArrayString const &)*arg2);
37556
37557 wxPyEndAllowThreads(__tstate);
37558 if (PyErr_Occurred()) SWIG_fail;
37559 }
37560 Py_INCREF(Py_None); resultobj = Py_None;
37561 {
37562 if (temp2) delete arg2;
37563 }
37564 return resultobj;
37565 fail:
37566 {
37567 if (temp2) delete arg2;
37568 }
37569 return NULL;
37570 }
37571
37572
37573 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37574 PyObject *resultobj;
37575 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37576 wxString *arg2 = 0 ;
37577 int arg3 ;
37578 PyObject *arg4 = (PyObject *) NULL ;
37579 int result;
37580 bool temp2 = false ;
37581 PyObject * obj0 = 0 ;
37582 PyObject * obj1 = 0 ;
37583 PyObject * obj2 = 0 ;
37584 PyObject * obj3 = 0 ;
37585 char *kwnames[] = {
37586 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37587 };
37588
37589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37591 if (SWIG_arg_fail(1)) SWIG_fail;
37592 {
37593 arg2 = wxString_in_helper(obj1);
37594 if (arg2 == NULL) SWIG_fail;
37595 temp2 = true;
37596 }
37597 {
37598 arg3 = (int)(SWIG_As_int(obj2));
37599 if (SWIG_arg_fail(3)) SWIG_fail;
37600 }
37601 if (obj3) {
37602 arg4 = obj3;
37603 }
37604 {
37605 PyThreadState* __tstate = wxPyBeginAllowThreads();
37606 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37607
37608 wxPyEndAllowThreads(__tstate);
37609 if (PyErr_Occurred()) SWIG_fail;
37610 }
37611 {
37612 resultobj = SWIG_From_int((int)(result));
37613 }
37614 {
37615 if (temp2)
37616 delete arg2;
37617 }
37618 return resultobj;
37619 fail:
37620 {
37621 if (temp2)
37622 delete arg2;
37623 }
37624 return NULL;
37625 }
37626
37627
37628 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37629 PyObject *resultobj;
37630 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37631 PyObject * obj0 = 0 ;
37632 char *kwnames[] = {
37633 (char *) "self", NULL
37634 };
37635
37636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37638 if (SWIG_arg_fail(1)) SWIG_fail;
37639 {
37640 PyThreadState* __tstate = wxPyBeginAllowThreads();
37641 (arg1)->Clear();
37642
37643 wxPyEndAllowThreads(__tstate);
37644 if (PyErr_Occurred()) SWIG_fail;
37645 }
37646 Py_INCREF(Py_None); resultobj = Py_None;
37647 return resultobj;
37648 fail:
37649 return NULL;
37650 }
37651
37652
37653 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37654 PyObject *resultobj;
37655 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37656 int arg2 ;
37657 PyObject * obj0 = 0 ;
37658 PyObject * obj1 = 0 ;
37659 char *kwnames[] = {
37660 (char *) "self",(char *) "n", NULL
37661 };
37662
37663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37665 if (SWIG_arg_fail(1)) SWIG_fail;
37666 {
37667 arg2 = (int)(SWIG_As_int(obj1));
37668 if (SWIG_arg_fail(2)) SWIG_fail;
37669 }
37670 {
37671 PyThreadState* __tstate = wxPyBeginAllowThreads();
37672 (arg1)->Delete(arg2);
37673
37674 wxPyEndAllowThreads(__tstate);
37675 if (PyErr_Occurred()) SWIG_fail;
37676 }
37677 Py_INCREF(Py_None); resultobj = Py_None;
37678 return resultobj;
37679 fail:
37680 return NULL;
37681 }
37682
37683
37684 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37685 PyObject *resultobj;
37686 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37687 int arg2 ;
37688 PyObject *result;
37689 PyObject * obj0 = 0 ;
37690 PyObject * obj1 = 0 ;
37691 char *kwnames[] = {
37692 (char *) "self",(char *) "n", NULL
37693 };
37694
37695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",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 = (int)(SWIG_As_int(obj1));
37700 if (SWIG_arg_fail(2)) SWIG_fail;
37701 }
37702 {
37703 PyThreadState* __tstate = wxPyBeginAllowThreads();
37704 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37705
37706 wxPyEndAllowThreads(__tstate);
37707 if (PyErr_Occurred()) SWIG_fail;
37708 }
37709 resultobj = result;
37710 return resultobj;
37711 fail:
37712 return NULL;
37713 }
37714
37715
37716 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37717 PyObject *resultobj;
37718 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37719 int arg2 ;
37720 PyObject *arg3 = (PyObject *) 0 ;
37721 PyObject * obj0 = 0 ;
37722 PyObject * obj1 = 0 ;
37723 PyObject * obj2 = 0 ;
37724 char *kwnames[] = {
37725 (char *) "self",(char *) "n",(char *) "clientData", NULL
37726 };
37727
37728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37730 if (SWIG_arg_fail(1)) SWIG_fail;
37731 {
37732 arg2 = (int)(SWIG_As_int(obj1));
37733 if (SWIG_arg_fail(2)) SWIG_fail;
37734 }
37735 arg3 = obj2;
37736 {
37737 PyThreadState* __tstate = wxPyBeginAllowThreads();
37738 wxItemContainer_SetClientData(arg1,arg2,arg3);
37739
37740 wxPyEndAllowThreads(__tstate);
37741 if (PyErr_Occurred()) SWIG_fail;
37742 }
37743 Py_INCREF(Py_None); resultobj = Py_None;
37744 return resultobj;
37745 fail:
37746 return NULL;
37747 }
37748
37749
37750 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37751 PyObject *resultobj;
37752 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37753 int result;
37754 PyObject * obj0 = 0 ;
37755 char *kwnames[] = {
37756 (char *) "self", NULL
37757 };
37758
37759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37761 if (SWIG_arg_fail(1)) SWIG_fail;
37762 {
37763 PyThreadState* __tstate = wxPyBeginAllowThreads();
37764 result = (int)((wxItemContainer const *)arg1)->GetCount();
37765
37766 wxPyEndAllowThreads(__tstate);
37767 if (PyErr_Occurred()) SWIG_fail;
37768 }
37769 {
37770 resultobj = SWIG_From_int((int)(result));
37771 }
37772 return resultobj;
37773 fail:
37774 return NULL;
37775 }
37776
37777
37778 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37779 PyObject *resultobj;
37780 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37781 bool result;
37782 PyObject * obj0 = 0 ;
37783 char *kwnames[] = {
37784 (char *) "self", NULL
37785 };
37786
37787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37789 if (SWIG_arg_fail(1)) SWIG_fail;
37790 {
37791 PyThreadState* __tstate = wxPyBeginAllowThreads();
37792 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37793
37794 wxPyEndAllowThreads(__tstate);
37795 if (PyErr_Occurred()) SWIG_fail;
37796 }
37797 {
37798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37799 }
37800 return resultobj;
37801 fail:
37802 return NULL;
37803 }
37804
37805
37806 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37807 PyObject *resultobj;
37808 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37809 int arg2 ;
37810 wxString result;
37811 PyObject * obj0 = 0 ;
37812 PyObject * obj1 = 0 ;
37813 char *kwnames[] = {
37814 (char *) "self",(char *) "n", NULL
37815 };
37816
37817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37819 if (SWIG_arg_fail(1)) SWIG_fail;
37820 {
37821 arg2 = (int)(SWIG_As_int(obj1));
37822 if (SWIG_arg_fail(2)) SWIG_fail;
37823 }
37824 {
37825 PyThreadState* __tstate = wxPyBeginAllowThreads();
37826 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37827
37828 wxPyEndAllowThreads(__tstate);
37829 if (PyErr_Occurred()) SWIG_fail;
37830 }
37831 {
37832 #if wxUSE_UNICODE
37833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37834 #else
37835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37836 #endif
37837 }
37838 return resultobj;
37839 fail:
37840 return NULL;
37841 }
37842
37843
37844 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37845 PyObject *resultobj;
37846 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37847 wxArrayString result;
37848 PyObject * obj0 = 0 ;
37849 char *kwnames[] = {
37850 (char *) "self", NULL
37851 };
37852
37853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37855 if (SWIG_arg_fail(1)) SWIG_fail;
37856 {
37857 PyThreadState* __tstate = wxPyBeginAllowThreads();
37858 result = ((wxItemContainer const *)arg1)->GetStrings();
37859
37860 wxPyEndAllowThreads(__tstate);
37861 if (PyErr_Occurred()) SWIG_fail;
37862 }
37863 {
37864 resultobj = wxArrayString2PyList_helper(result);
37865 }
37866 return resultobj;
37867 fail:
37868 return NULL;
37869 }
37870
37871
37872 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37873 PyObject *resultobj;
37874 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37875 int arg2 ;
37876 wxString *arg3 = 0 ;
37877 bool temp3 = false ;
37878 PyObject * obj0 = 0 ;
37879 PyObject * obj1 = 0 ;
37880 PyObject * obj2 = 0 ;
37881 char *kwnames[] = {
37882 (char *) "self",(char *) "n",(char *) "s", NULL
37883 };
37884
37885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37887 if (SWIG_arg_fail(1)) SWIG_fail;
37888 {
37889 arg2 = (int)(SWIG_As_int(obj1));
37890 if (SWIG_arg_fail(2)) SWIG_fail;
37891 }
37892 {
37893 arg3 = wxString_in_helper(obj2);
37894 if (arg3 == NULL) SWIG_fail;
37895 temp3 = true;
37896 }
37897 {
37898 PyThreadState* __tstate = wxPyBeginAllowThreads();
37899 (arg1)->SetString(arg2,(wxString const &)*arg3);
37900
37901 wxPyEndAllowThreads(__tstate);
37902 if (PyErr_Occurred()) SWIG_fail;
37903 }
37904 Py_INCREF(Py_None); resultobj = Py_None;
37905 {
37906 if (temp3)
37907 delete arg3;
37908 }
37909 return resultobj;
37910 fail:
37911 {
37912 if (temp3)
37913 delete arg3;
37914 }
37915 return NULL;
37916 }
37917
37918
37919 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37920 PyObject *resultobj;
37921 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37922 wxString *arg2 = 0 ;
37923 int result;
37924 bool temp2 = false ;
37925 PyObject * obj0 = 0 ;
37926 PyObject * obj1 = 0 ;
37927 char *kwnames[] = {
37928 (char *) "self",(char *) "s", NULL
37929 };
37930
37931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37933 if (SWIG_arg_fail(1)) SWIG_fail;
37934 {
37935 arg2 = wxString_in_helper(obj1);
37936 if (arg2 == NULL) SWIG_fail;
37937 temp2 = true;
37938 }
37939 {
37940 PyThreadState* __tstate = wxPyBeginAllowThreads();
37941 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37942
37943 wxPyEndAllowThreads(__tstate);
37944 if (PyErr_Occurred()) SWIG_fail;
37945 }
37946 {
37947 resultobj = SWIG_From_int((int)(result));
37948 }
37949 {
37950 if (temp2)
37951 delete arg2;
37952 }
37953 return resultobj;
37954 fail:
37955 {
37956 if (temp2)
37957 delete arg2;
37958 }
37959 return NULL;
37960 }
37961
37962
37963 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37964 PyObject *resultobj;
37965 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37966 int arg2 ;
37967 PyObject * obj0 = 0 ;
37968 PyObject * obj1 = 0 ;
37969 char *kwnames[] = {
37970 (char *) "self",(char *) "n", NULL
37971 };
37972
37973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
37974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37975 if (SWIG_arg_fail(1)) SWIG_fail;
37976 {
37977 arg2 = (int)(SWIG_As_int(obj1));
37978 if (SWIG_arg_fail(2)) SWIG_fail;
37979 }
37980 {
37981 PyThreadState* __tstate = wxPyBeginAllowThreads();
37982 (arg1)->SetSelection(arg2);
37983
37984 wxPyEndAllowThreads(__tstate);
37985 if (PyErr_Occurred()) SWIG_fail;
37986 }
37987 Py_INCREF(Py_None); resultobj = Py_None;
37988 return resultobj;
37989 fail:
37990 return NULL;
37991 }
37992
37993
37994 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37995 PyObject *resultobj;
37996 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37997 int result;
37998 PyObject * obj0 = 0 ;
37999 char *kwnames[] = {
38000 (char *) "self", NULL
38001 };
38002
38003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38005 if (SWIG_arg_fail(1)) SWIG_fail;
38006 {
38007 PyThreadState* __tstate = wxPyBeginAllowThreads();
38008 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38009
38010 wxPyEndAllowThreads(__tstate);
38011 if (PyErr_Occurred()) SWIG_fail;
38012 }
38013 {
38014 resultobj = SWIG_From_int((int)(result));
38015 }
38016 return resultobj;
38017 fail:
38018 return NULL;
38019 }
38020
38021
38022 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38023 PyObject *resultobj;
38024 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38025 wxString *arg2 = 0 ;
38026 bool result;
38027 bool temp2 = false ;
38028 PyObject * obj0 = 0 ;
38029 PyObject * obj1 = 0 ;
38030 char *kwnames[] = {
38031 (char *) "self",(char *) "s", NULL
38032 };
38033
38034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38036 if (SWIG_arg_fail(1)) SWIG_fail;
38037 {
38038 arg2 = wxString_in_helper(obj1);
38039 if (arg2 == NULL) SWIG_fail;
38040 temp2 = true;
38041 }
38042 {
38043 PyThreadState* __tstate = wxPyBeginAllowThreads();
38044 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38045
38046 wxPyEndAllowThreads(__tstate);
38047 if (PyErr_Occurred()) SWIG_fail;
38048 }
38049 {
38050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38051 }
38052 {
38053 if (temp2)
38054 delete arg2;
38055 }
38056 return resultobj;
38057 fail:
38058 {
38059 if (temp2)
38060 delete arg2;
38061 }
38062 return NULL;
38063 }
38064
38065
38066 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38067 PyObject *resultobj;
38068 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38069 wxString result;
38070 PyObject * obj0 = 0 ;
38071 char *kwnames[] = {
38072 (char *) "self", NULL
38073 };
38074
38075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38077 if (SWIG_arg_fail(1)) SWIG_fail;
38078 {
38079 PyThreadState* __tstate = wxPyBeginAllowThreads();
38080 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38081
38082 wxPyEndAllowThreads(__tstate);
38083 if (PyErr_Occurred()) SWIG_fail;
38084 }
38085 {
38086 #if wxUSE_UNICODE
38087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38088 #else
38089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38090 #endif
38091 }
38092 return resultobj;
38093 fail:
38094 return NULL;
38095 }
38096
38097
38098 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38099 PyObject *resultobj;
38100 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38101 int arg2 ;
38102 PyObject * obj0 = 0 ;
38103 PyObject * obj1 = 0 ;
38104 char *kwnames[] = {
38105 (char *) "self",(char *) "n", NULL
38106 };
38107
38108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38110 if (SWIG_arg_fail(1)) SWIG_fail;
38111 {
38112 arg2 = (int)(SWIG_As_int(obj1));
38113 if (SWIG_arg_fail(2)) SWIG_fail;
38114 }
38115 {
38116 PyThreadState* __tstate = wxPyBeginAllowThreads();
38117 (arg1)->Select(arg2);
38118
38119 wxPyEndAllowThreads(__tstate);
38120 if (PyErr_Occurred()) SWIG_fail;
38121 }
38122 Py_INCREF(Py_None); resultobj = Py_None;
38123 return resultobj;
38124 fail:
38125 return NULL;
38126 }
38127
38128
38129 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38130 PyObject *obj;
38131 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38132 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38133 Py_INCREF(obj);
38134 return Py_BuildValue((char *)"");
38135 }
38136 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38137 PyObject *obj;
38138 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38139 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38140 Py_INCREF(obj);
38141 return Py_BuildValue((char *)"");
38142 }
38143 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38144 PyObject *resultobj;
38145 wxSizerItem *result;
38146 char *kwnames[] = {
38147 NULL
38148 };
38149
38150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38151 {
38152 PyThreadState* __tstate = wxPyBeginAllowThreads();
38153 result = (wxSizerItem *)new wxSizerItem();
38154
38155 wxPyEndAllowThreads(__tstate);
38156 if (PyErr_Occurred()) SWIG_fail;
38157 }
38158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38159 return resultobj;
38160 fail:
38161 return NULL;
38162 }
38163
38164
38165 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38166 PyObject *resultobj;
38167 wxWindow *arg1 = (wxWindow *) 0 ;
38168 int arg2 ;
38169 int arg3 ;
38170 int arg4 ;
38171 PyObject *arg5 = (PyObject *) NULL ;
38172 wxSizerItem *result;
38173 PyObject * obj0 = 0 ;
38174 PyObject * obj1 = 0 ;
38175 PyObject * obj2 = 0 ;
38176 PyObject * obj3 = 0 ;
38177 PyObject * obj4 = 0 ;
38178 char *kwnames[] = {
38179 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38180 };
38181
38182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38184 if (SWIG_arg_fail(1)) SWIG_fail;
38185 {
38186 arg2 = (int)(SWIG_As_int(obj1));
38187 if (SWIG_arg_fail(2)) SWIG_fail;
38188 }
38189 {
38190 arg3 = (int)(SWIG_As_int(obj2));
38191 if (SWIG_arg_fail(3)) SWIG_fail;
38192 }
38193 {
38194 arg4 = (int)(SWIG_As_int(obj3));
38195 if (SWIG_arg_fail(4)) SWIG_fail;
38196 }
38197 if (obj4) {
38198 arg5 = obj4;
38199 }
38200 {
38201 PyThreadState* __tstate = wxPyBeginAllowThreads();
38202 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38203
38204 wxPyEndAllowThreads(__tstate);
38205 if (PyErr_Occurred()) SWIG_fail;
38206 }
38207 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38208 return resultobj;
38209 fail:
38210 return NULL;
38211 }
38212
38213
38214 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38215 PyObject *resultobj;
38216 int arg1 ;
38217 int arg2 ;
38218 int arg3 ;
38219 int arg4 ;
38220 int arg5 ;
38221 PyObject *arg6 = (PyObject *) NULL ;
38222 wxSizerItem *result;
38223 PyObject * obj0 = 0 ;
38224 PyObject * obj1 = 0 ;
38225 PyObject * obj2 = 0 ;
38226 PyObject * obj3 = 0 ;
38227 PyObject * obj4 = 0 ;
38228 PyObject * obj5 = 0 ;
38229 char *kwnames[] = {
38230 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38231 };
38232
38233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38234 {
38235 arg1 = (int)(SWIG_As_int(obj0));
38236 if (SWIG_arg_fail(1)) SWIG_fail;
38237 }
38238 {
38239 arg2 = (int)(SWIG_As_int(obj1));
38240 if (SWIG_arg_fail(2)) SWIG_fail;
38241 }
38242 {
38243 arg3 = (int)(SWIG_As_int(obj2));
38244 if (SWIG_arg_fail(3)) SWIG_fail;
38245 }
38246 {
38247 arg4 = (int)(SWIG_As_int(obj3));
38248 if (SWIG_arg_fail(4)) SWIG_fail;
38249 }
38250 {
38251 arg5 = (int)(SWIG_As_int(obj4));
38252 if (SWIG_arg_fail(5)) SWIG_fail;
38253 }
38254 if (obj5) {
38255 arg6 = obj5;
38256 }
38257 {
38258 PyThreadState* __tstate = wxPyBeginAllowThreads();
38259 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38260
38261 wxPyEndAllowThreads(__tstate);
38262 if (PyErr_Occurred()) SWIG_fail;
38263 }
38264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38265 return resultobj;
38266 fail:
38267 return NULL;
38268 }
38269
38270
38271 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38272 PyObject *resultobj;
38273 wxSizer *arg1 = (wxSizer *) 0 ;
38274 int arg2 ;
38275 int arg3 ;
38276 int arg4 ;
38277 PyObject *arg5 = (PyObject *) NULL ;
38278 wxSizerItem *result;
38279 PyObject * obj0 = 0 ;
38280 PyObject * obj1 = 0 ;
38281 PyObject * obj2 = 0 ;
38282 PyObject * obj3 = 0 ;
38283 PyObject * obj4 = 0 ;
38284 char *kwnames[] = {
38285 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38286 };
38287
38288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38290 if (SWIG_arg_fail(1)) SWIG_fail;
38291 {
38292 arg2 = (int)(SWIG_As_int(obj1));
38293 if (SWIG_arg_fail(2)) SWIG_fail;
38294 }
38295 {
38296 arg3 = (int)(SWIG_As_int(obj2));
38297 if (SWIG_arg_fail(3)) SWIG_fail;
38298 }
38299 {
38300 arg4 = (int)(SWIG_As_int(obj3));
38301 if (SWIG_arg_fail(4)) SWIG_fail;
38302 }
38303 if (obj4) {
38304 arg5 = obj4;
38305 }
38306 {
38307 PyThreadState* __tstate = wxPyBeginAllowThreads();
38308 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38309
38310 wxPyEndAllowThreads(__tstate);
38311 if (PyErr_Occurred()) SWIG_fail;
38312 }
38313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38314 return resultobj;
38315 fail:
38316 return NULL;
38317 }
38318
38319
38320 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38321 PyObject *resultobj;
38322 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38323 PyObject * obj0 = 0 ;
38324 char *kwnames[] = {
38325 (char *) "self", NULL
38326 };
38327
38328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38330 if (SWIG_arg_fail(1)) SWIG_fail;
38331 {
38332 PyThreadState* __tstate = wxPyBeginAllowThreads();
38333 (arg1)->DeleteWindows();
38334
38335 wxPyEndAllowThreads(__tstate);
38336 if (PyErr_Occurred()) SWIG_fail;
38337 }
38338 Py_INCREF(Py_None); resultobj = Py_None;
38339 return resultobj;
38340 fail:
38341 return NULL;
38342 }
38343
38344
38345 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38346 PyObject *resultobj;
38347 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38348 PyObject * obj0 = 0 ;
38349 char *kwnames[] = {
38350 (char *) "self", NULL
38351 };
38352
38353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38355 if (SWIG_arg_fail(1)) SWIG_fail;
38356 {
38357 PyThreadState* __tstate = wxPyBeginAllowThreads();
38358 (arg1)->DetachSizer();
38359
38360 wxPyEndAllowThreads(__tstate);
38361 if (PyErr_Occurred()) SWIG_fail;
38362 }
38363 Py_INCREF(Py_None); resultobj = Py_None;
38364 return resultobj;
38365 fail:
38366 return NULL;
38367 }
38368
38369
38370 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38371 PyObject *resultobj;
38372 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38373 wxSize result;
38374 PyObject * obj0 = 0 ;
38375 char *kwnames[] = {
38376 (char *) "self", NULL
38377 };
38378
38379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38381 if (SWIG_arg_fail(1)) SWIG_fail;
38382 {
38383 PyThreadState* __tstate = wxPyBeginAllowThreads();
38384 result = (arg1)->GetSize();
38385
38386 wxPyEndAllowThreads(__tstate);
38387 if (PyErr_Occurred()) SWIG_fail;
38388 }
38389 {
38390 wxSize * resultptr;
38391 resultptr = new wxSize((wxSize &)(result));
38392 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38393 }
38394 return resultobj;
38395 fail:
38396 return NULL;
38397 }
38398
38399
38400 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38401 PyObject *resultobj;
38402 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38403 wxSize result;
38404 PyObject * obj0 = 0 ;
38405 char *kwnames[] = {
38406 (char *) "self", NULL
38407 };
38408
38409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38411 if (SWIG_arg_fail(1)) SWIG_fail;
38412 {
38413 PyThreadState* __tstate = wxPyBeginAllowThreads();
38414 result = (arg1)->CalcMin();
38415
38416 wxPyEndAllowThreads(__tstate);
38417 if (PyErr_Occurred()) SWIG_fail;
38418 }
38419 {
38420 wxSize * resultptr;
38421 resultptr = new wxSize((wxSize &)(result));
38422 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38423 }
38424 return resultobj;
38425 fail:
38426 return NULL;
38427 }
38428
38429
38430 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38431 PyObject *resultobj;
38432 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38433 wxPoint arg2 ;
38434 wxSize arg3 ;
38435 PyObject * obj0 = 0 ;
38436 PyObject * obj1 = 0 ;
38437 PyObject * obj2 = 0 ;
38438 char *kwnames[] = {
38439 (char *) "self",(char *) "pos",(char *) "size", NULL
38440 };
38441
38442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38444 if (SWIG_arg_fail(1)) SWIG_fail;
38445 {
38446 wxPoint * argp;
38447 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38448 if (SWIG_arg_fail(2)) SWIG_fail;
38449 if (argp == NULL) {
38450 SWIG_null_ref("wxPoint");
38451 }
38452 if (SWIG_arg_fail(2)) SWIG_fail;
38453 arg2 = *argp;
38454 }
38455 {
38456 wxSize * argp;
38457 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38458 if (SWIG_arg_fail(3)) SWIG_fail;
38459 if (argp == NULL) {
38460 SWIG_null_ref("wxSize");
38461 }
38462 if (SWIG_arg_fail(3)) SWIG_fail;
38463 arg3 = *argp;
38464 }
38465 {
38466 PyThreadState* __tstate = wxPyBeginAllowThreads();
38467 (arg1)->SetDimension(arg2,arg3);
38468
38469 wxPyEndAllowThreads(__tstate);
38470 if (PyErr_Occurred()) SWIG_fail;
38471 }
38472 Py_INCREF(Py_None); resultobj = Py_None;
38473 return resultobj;
38474 fail:
38475 return NULL;
38476 }
38477
38478
38479 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38480 PyObject *resultobj;
38481 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38482 wxSize result;
38483 PyObject * obj0 = 0 ;
38484 char *kwnames[] = {
38485 (char *) "self", NULL
38486 };
38487
38488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38490 if (SWIG_arg_fail(1)) SWIG_fail;
38491 {
38492 PyThreadState* __tstate = wxPyBeginAllowThreads();
38493 result = (arg1)->GetMinSize();
38494
38495 wxPyEndAllowThreads(__tstate);
38496 if (PyErr_Occurred()) SWIG_fail;
38497 }
38498 {
38499 wxSize * resultptr;
38500 resultptr = new wxSize((wxSize &)(result));
38501 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38502 }
38503 return resultobj;
38504 fail:
38505 return NULL;
38506 }
38507
38508
38509 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38510 PyObject *resultobj;
38511 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38512 wxSize result;
38513 PyObject * obj0 = 0 ;
38514 char *kwnames[] = {
38515 (char *) "self", NULL
38516 };
38517
38518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38520 if (SWIG_arg_fail(1)) SWIG_fail;
38521 {
38522 PyThreadState* __tstate = wxPyBeginAllowThreads();
38523 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38524
38525 wxPyEndAllowThreads(__tstate);
38526 if (PyErr_Occurred()) SWIG_fail;
38527 }
38528 {
38529 wxSize * resultptr;
38530 resultptr = new wxSize((wxSize &)(result));
38531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38532 }
38533 return resultobj;
38534 fail:
38535 return NULL;
38536 }
38537
38538
38539 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38540 PyObject *resultobj;
38541 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38542 int arg2 ;
38543 int arg3 ;
38544 PyObject * obj0 = 0 ;
38545 PyObject * obj1 = 0 ;
38546 PyObject * obj2 = 0 ;
38547 char *kwnames[] = {
38548 (char *) "self",(char *) "x",(char *) "y", NULL
38549 };
38550
38551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38553 if (SWIG_arg_fail(1)) SWIG_fail;
38554 {
38555 arg2 = (int)(SWIG_As_int(obj1));
38556 if (SWIG_arg_fail(2)) SWIG_fail;
38557 }
38558 {
38559 arg3 = (int)(SWIG_As_int(obj2));
38560 if (SWIG_arg_fail(3)) SWIG_fail;
38561 }
38562 {
38563 PyThreadState* __tstate = wxPyBeginAllowThreads();
38564 (arg1)->SetInitSize(arg2,arg3);
38565
38566 wxPyEndAllowThreads(__tstate);
38567 if (PyErr_Occurred()) SWIG_fail;
38568 }
38569 Py_INCREF(Py_None); resultobj = Py_None;
38570 return resultobj;
38571 fail:
38572 return NULL;
38573 }
38574
38575
38576 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38577 PyObject *resultobj;
38578 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38579 int arg2 ;
38580 int arg3 ;
38581 PyObject * obj0 = 0 ;
38582 PyObject * obj1 = 0 ;
38583 PyObject * obj2 = 0 ;
38584 char *kwnames[] = {
38585 (char *) "self",(char *) "width",(char *) "height", NULL
38586 };
38587
38588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38590 if (SWIG_arg_fail(1)) SWIG_fail;
38591 {
38592 arg2 = (int)(SWIG_As_int(obj1));
38593 if (SWIG_arg_fail(2)) SWIG_fail;
38594 }
38595 {
38596 arg3 = (int)(SWIG_As_int(obj2));
38597 if (SWIG_arg_fail(3)) SWIG_fail;
38598 }
38599 {
38600 PyThreadState* __tstate = wxPyBeginAllowThreads();
38601 (arg1)->SetRatio(arg2,arg3);
38602
38603 wxPyEndAllowThreads(__tstate);
38604 if (PyErr_Occurred()) SWIG_fail;
38605 }
38606 Py_INCREF(Py_None); resultobj = Py_None;
38607 return resultobj;
38608 fail:
38609 return NULL;
38610 }
38611
38612
38613 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38614 PyObject *resultobj;
38615 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38616 wxSize *arg2 = 0 ;
38617 wxSize temp2 ;
38618 PyObject * obj0 = 0 ;
38619 PyObject * obj1 = 0 ;
38620 char *kwnames[] = {
38621 (char *) "self",(char *) "size", NULL
38622 };
38623
38624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38626 if (SWIG_arg_fail(1)) SWIG_fail;
38627 {
38628 arg2 = &temp2;
38629 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38630 }
38631 {
38632 PyThreadState* __tstate = wxPyBeginAllowThreads();
38633 (arg1)->SetRatio((wxSize const &)*arg2);
38634
38635 wxPyEndAllowThreads(__tstate);
38636 if (PyErr_Occurred()) SWIG_fail;
38637 }
38638 Py_INCREF(Py_None); resultobj = Py_None;
38639 return resultobj;
38640 fail:
38641 return NULL;
38642 }
38643
38644
38645 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38646 PyObject *resultobj;
38647 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38648 float arg2 ;
38649 PyObject * obj0 = 0 ;
38650 PyObject * obj1 = 0 ;
38651 char *kwnames[] = {
38652 (char *) "self",(char *) "ratio", NULL
38653 };
38654
38655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38657 if (SWIG_arg_fail(1)) SWIG_fail;
38658 {
38659 arg2 = (float)(SWIG_As_float(obj1));
38660 if (SWIG_arg_fail(2)) SWIG_fail;
38661 }
38662 {
38663 PyThreadState* __tstate = wxPyBeginAllowThreads();
38664 (arg1)->SetRatio(arg2);
38665
38666 wxPyEndAllowThreads(__tstate);
38667 if (PyErr_Occurred()) SWIG_fail;
38668 }
38669 Py_INCREF(Py_None); resultobj = Py_None;
38670 return resultobj;
38671 fail:
38672 return NULL;
38673 }
38674
38675
38676 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38677 PyObject *resultobj;
38678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38679 float result;
38680 PyObject * obj0 = 0 ;
38681 char *kwnames[] = {
38682 (char *) "self", NULL
38683 };
38684
38685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38687 if (SWIG_arg_fail(1)) SWIG_fail;
38688 {
38689 PyThreadState* __tstate = wxPyBeginAllowThreads();
38690 result = (float)(arg1)->GetRatio();
38691
38692 wxPyEndAllowThreads(__tstate);
38693 if (PyErr_Occurred()) SWIG_fail;
38694 }
38695 {
38696 resultobj = SWIG_From_float((float)(result));
38697 }
38698 return resultobj;
38699 fail:
38700 return NULL;
38701 }
38702
38703
38704 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38705 PyObject *resultobj;
38706 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38707 wxRect result;
38708 PyObject * obj0 = 0 ;
38709 char *kwnames[] = {
38710 (char *) "self", NULL
38711 };
38712
38713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38715 if (SWIG_arg_fail(1)) SWIG_fail;
38716 {
38717 PyThreadState* __tstate = wxPyBeginAllowThreads();
38718 result = (arg1)->GetRect();
38719
38720 wxPyEndAllowThreads(__tstate);
38721 if (PyErr_Occurred()) SWIG_fail;
38722 }
38723 {
38724 wxRect * resultptr;
38725 resultptr = new wxRect((wxRect &)(result));
38726 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38727 }
38728 return resultobj;
38729 fail:
38730 return NULL;
38731 }
38732
38733
38734 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38735 PyObject *resultobj;
38736 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38737 bool result;
38738 PyObject * obj0 = 0 ;
38739 char *kwnames[] = {
38740 (char *) "self", NULL
38741 };
38742
38743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38745 if (SWIG_arg_fail(1)) SWIG_fail;
38746 {
38747 PyThreadState* __tstate = wxPyBeginAllowThreads();
38748 result = (bool)(arg1)->IsWindow();
38749
38750 wxPyEndAllowThreads(__tstate);
38751 if (PyErr_Occurred()) SWIG_fail;
38752 }
38753 {
38754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38755 }
38756 return resultobj;
38757 fail:
38758 return NULL;
38759 }
38760
38761
38762 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38763 PyObject *resultobj;
38764 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38765 bool result;
38766 PyObject * obj0 = 0 ;
38767 char *kwnames[] = {
38768 (char *) "self", NULL
38769 };
38770
38771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38773 if (SWIG_arg_fail(1)) SWIG_fail;
38774 {
38775 PyThreadState* __tstate = wxPyBeginAllowThreads();
38776 result = (bool)(arg1)->IsSizer();
38777
38778 wxPyEndAllowThreads(__tstate);
38779 if (PyErr_Occurred()) SWIG_fail;
38780 }
38781 {
38782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38783 }
38784 return resultobj;
38785 fail:
38786 return NULL;
38787 }
38788
38789
38790 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38791 PyObject *resultobj;
38792 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38793 bool result;
38794 PyObject * obj0 = 0 ;
38795 char *kwnames[] = {
38796 (char *) "self", NULL
38797 };
38798
38799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38801 if (SWIG_arg_fail(1)) SWIG_fail;
38802 {
38803 PyThreadState* __tstate = wxPyBeginAllowThreads();
38804 result = (bool)(arg1)->IsSpacer();
38805
38806 wxPyEndAllowThreads(__tstate);
38807 if (PyErr_Occurred()) SWIG_fail;
38808 }
38809 {
38810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38811 }
38812 return resultobj;
38813 fail:
38814 return NULL;
38815 }
38816
38817
38818 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38819 PyObject *resultobj;
38820 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38821 int arg2 ;
38822 PyObject * obj0 = 0 ;
38823 PyObject * obj1 = 0 ;
38824 char *kwnames[] = {
38825 (char *) "self",(char *) "proportion", NULL
38826 };
38827
38828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38830 if (SWIG_arg_fail(1)) SWIG_fail;
38831 {
38832 arg2 = (int)(SWIG_As_int(obj1));
38833 if (SWIG_arg_fail(2)) SWIG_fail;
38834 }
38835 {
38836 PyThreadState* __tstate = wxPyBeginAllowThreads();
38837 (arg1)->SetProportion(arg2);
38838
38839 wxPyEndAllowThreads(__tstate);
38840 if (PyErr_Occurred()) SWIG_fail;
38841 }
38842 Py_INCREF(Py_None); resultobj = Py_None;
38843 return resultobj;
38844 fail:
38845 return NULL;
38846 }
38847
38848
38849 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38850 PyObject *resultobj;
38851 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38852 int result;
38853 PyObject * obj0 = 0 ;
38854 char *kwnames[] = {
38855 (char *) "self", NULL
38856 };
38857
38858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38860 if (SWIG_arg_fail(1)) SWIG_fail;
38861 {
38862 PyThreadState* __tstate = wxPyBeginAllowThreads();
38863 result = (int)(arg1)->GetProportion();
38864
38865 wxPyEndAllowThreads(__tstate);
38866 if (PyErr_Occurred()) SWIG_fail;
38867 }
38868 {
38869 resultobj = SWIG_From_int((int)(result));
38870 }
38871 return resultobj;
38872 fail:
38873 return NULL;
38874 }
38875
38876
38877 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38878 PyObject *resultobj;
38879 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38880 int arg2 ;
38881 PyObject * obj0 = 0 ;
38882 PyObject * obj1 = 0 ;
38883 char *kwnames[] = {
38884 (char *) "self",(char *) "flag", NULL
38885 };
38886
38887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
38892 if (SWIG_arg_fail(2)) SWIG_fail;
38893 }
38894 {
38895 PyThreadState* __tstate = wxPyBeginAllowThreads();
38896 (arg1)->SetFlag(arg2);
38897
38898 wxPyEndAllowThreads(__tstate);
38899 if (PyErr_Occurred()) SWIG_fail;
38900 }
38901 Py_INCREF(Py_None); resultobj = Py_None;
38902 return resultobj;
38903 fail:
38904 return NULL;
38905 }
38906
38907
38908 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38909 PyObject *resultobj;
38910 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38911 int result;
38912 PyObject * obj0 = 0 ;
38913 char *kwnames[] = {
38914 (char *) "self", NULL
38915 };
38916
38917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38919 if (SWIG_arg_fail(1)) SWIG_fail;
38920 {
38921 PyThreadState* __tstate = wxPyBeginAllowThreads();
38922 result = (int)(arg1)->GetFlag();
38923
38924 wxPyEndAllowThreads(__tstate);
38925 if (PyErr_Occurred()) SWIG_fail;
38926 }
38927 {
38928 resultobj = SWIG_From_int((int)(result));
38929 }
38930 return resultobj;
38931 fail:
38932 return NULL;
38933 }
38934
38935
38936 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38937 PyObject *resultobj;
38938 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38939 int arg2 ;
38940 PyObject * obj0 = 0 ;
38941 PyObject * obj1 = 0 ;
38942 char *kwnames[] = {
38943 (char *) "self",(char *) "border", NULL
38944 };
38945
38946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38948 if (SWIG_arg_fail(1)) SWIG_fail;
38949 {
38950 arg2 = (int)(SWIG_As_int(obj1));
38951 if (SWIG_arg_fail(2)) SWIG_fail;
38952 }
38953 {
38954 PyThreadState* __tstate = wxPyBeginAllowThreads();
38955 (arg1)->SetBorder(arg2);
38956
38957 wxPyEndAllowThreads(__tstate);
38958 if (PyErr_Occurred()) SWIG_fail;
38959 }
38960 Py_INCREF(Py_None); resultobj = Py_None;
38961 return resultobj;
38962 fail:
38963 return NULL;
38964 }
38965
38966
38967 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38968 PyObject *resultobj;
38969 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38970 int result;
38971 PyObject * obj0 = 0 ;
38972 char *kwnames[] = {
38973 (char *) "self", NULL
38974 };
38975
38976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38978 if (SWIG_arg_fail(1)) SWIG_fail;
38979 {
38980 PyThreadState* __tstate = wxPyBeginAllowThreads();
38981 result = (int)(arg1)->GetBorder();
38982
38983 wxPyEndAllowThreads(__tstate);
38984 if (PyErr_Occurred()) SWIG_fail;
38985 }
38986 {
38987 resultobj = SWIG_From_int((int)(result));
38988 }
38989 return resultobj;
38990 fail:
38991 return NULL;
38992 }
38993
38994
38995 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38996 PyObject *resultobj;
38997 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38998 wxWindow *result;
38999 PyObject * obj0 = 0 ;
39000 char *kwnames[] = {
39001 (char *) "self", NULL
39002 };
39003
39004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39006 if (SWIG_arg_fail(1)) SWIG_fail;
39007 {
39008 PyThreadState* __tstate = wxPyBeginAllowThreads();
39009 result = (wxWindow *)(arg1)->GetWindow();
39010
39011 wxPyEndAllowThreads(__tstate);
39012 if (PyErr_Occurred()) SWIG_fail;
39013 }
39014 {
39015 resultobj = wxPyMake_wxObject(result, 0);
39016 }
39017 return resultobj;
39018 fail:
39019 return NULL;
39020 }
39021
39022
39023 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39024 PyObject *resultobj;
39025 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39026 wxWindow *arg2 = (wxWindow *) 0 ;
39027 PyObject * obj0 = 0 ;
39028 PyObject * obj1 = 0 ;
39029 char *kwnames[] = {
39030 (char *) "self",(char *) "window", NULL
39031 };
39032
39033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39035 if (SWIG_arg_fail(1)) SWIG_fail;
39036 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39037 if (SWIG_arg_fail(2)) SWIG_fail;
39038 {
39039 PyThreadState* __tstate = wxPyBeginAllowThreads();
39040 (arg1)->SetWindow(arg2);
39041
39042 wxPyEndAllowThreads(__tstate);
39043 if (PyErr_Occurred()) SWIG_fail;
39044 }
39045 Py_INCREF(Py_None); resultobj = Py_None;
39046 return resultobj;
39047 fail:
39048 return NULL;
39049 }
39050
39051
39052 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39053 PyObject *resultobj;
39054 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39055 wxSizer *result;
39056 PyObject * obj0 = 0 ;
39057 char *kwnames[] = {
39058 (char *) "self", NULL
39059 };
39060
39061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39063 if (SWIG_arg_fail(1)) SWIG_fail;
39064 {
39065 PyThreadState* __tstate = wxPyBeginAllowThreads();
39066 result = (wxSizer *)(arg1)->GetSizer();
39067
39068 wxPyEndAllowThreads(__tstate);
39069 if (PyErr_Occurred()) SWIG_fail;
39070 }
39071 {
39072 resultobj = wxPyMake_wxSizer(result, 0);
39073 }
39074 return resultobj;
39075 fail:
39076 return NULL;
39077 }
39078
39079
39080 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39081 PyObject *resultobj;
39082 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39083 wxSizer *arg2 = (wxSizer *) 0 ;
39084 PyObject * obj0 = 0 ;
39085 PyObject * obj1 = 0 ;
39086 char *kwnames[] = {
39087 (char *) "self",(char *) "sizer", NULL
39088 };
39089
39090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39092 if (SWIG_arg_fail(1)) SWIG_fail;
39093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39094 if (SWIG_arg_fail(2)) SWIG_fail;
39095 {
39096 PyThreadState* __tstate = wxPyBeginAllowThreads();
39097 (arg1)->SetSizer(arg2);
39098
39099 wxPyEndAllowThreads(__tstate);
39100 if (PyErr_Occurred()) SWIG_fail;
39101 }
39102 Py_INCREF(Py_None); resultobj = Py_None;
39103 return resultobj;
39104 fail:
39105 return NULL;
39106 }
39107
39108
39109 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39110 PyObject *resultobj;
39111 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39112 wxSize *result;
39113 PyObject * obj0 = 0 ;
39114 char *kwnames[] = {
39115 (char *) "self", NULL
39116 };
39117
39118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39120 if (SWIG_arg_fail(1)) SWIG_fail;
39121 {
39122 PyThreadState* __tstate = wxPyBeginAllowThreads();
39123 {
39124 wxSize const &_result_ref = (arg1)->GetSpacer();
39125 result = (wxSize *) &_result_ref;
39126 }
39127
39128 wxPyEndAllowThreads(__tstate);
39129 if (PyErr_Occurred()) SWIG_fail;
39130 }
39131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39132 return resultobj;
39133 fail:
39134 return NULL;
39135 }
39136
39137
39138 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39139 PyObject *resultobj;
39140 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39141 wxSize *arg2 = 0 ;
39142 wxSize temp2 ;
39143 PyObject * obj0 = 0 ;
39144 PyObject * obj1 = 0 ;
39145 char *kwnames[] = {
39146 (char *) "self",(char *) "size", NULL
39147 };
39148
39149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39151 if (SWIG_arg_fail(1)) SWIG_fail;
39152 {
39153 arg2 = &temp2;
39154 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39155 }
39156 {
39157 PyThreadState* __tstate = wxPyBeginAllowThreads();
39158 (arg1)->SetSpacer((wxSize const &)*arg2);
39159
39160 wxPyEndAllowThreads(__tstate);
39161 if (PyErr_Occurred()) SWIG_fail;
39162 }
39163 Py_INCREF(Py_None); resultobj = Py_None;
39164 return resultobj;
39165 fail:
39166 return NULL;
39167 }
39168
39169
39170 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39171 PyObject *resultobj;
39172 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39173 bool arg2 ;
39174 PyObject * obj0 = 0 ;
39175 PyObject * obj1 = 0 ;
39176 char *kwnames[] = {
39177 (char *) "self",(char *) "show", NULL
39178 };
39179
39180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39182 if (SWIG_arg_fail(1)) SWIG_fail;
39183 {
39184 arg2 = (bool)(SWIG_As_bool(obj1));
39185 if (SWIG_arg_fail(2)) SWIG_fail;
39186 }
39187 {
39188 PyThreadState* __tstate = wxPyBeginAllowThreads();
39189 (arg1)->Show(arg2);
39190
39191 wxPyEndAllowThreads(__tstate);
39192 if (PyErr_Occurred()) SWIG_fail;
39193 }
39194 Py_INCREF(Py_None); resultobj = Py_None;
39195 return resultobj;
39196 fail:
39197 return NULL;
39198 }
39199
39200
39201 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39202 PyObject *resultobj;
39203 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39204 bool result;
39205 PyObject * obj0 = 0 ;
39206 char *kwnames[] = {
39207 (char *) "self", NULL
39208 };
39209
39210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39212 if (SWIG_arg_fail(1)) SWIG_fail;
39213 {
39214 PyThreadState* __tstate = wxPyBeginAllowThreads();
39215 result = (bool)(arg1)->IsShown();
39216
39217 wxPyEndAllowThreads(__tstate);
39218 if (PyErr_Occurred()) SWIG_fail;
39219 }
39220 {
39221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39222 }
39223 return resultobj;
39224 fail:
39225 return NULL;
39226 }
39227
39228
39229 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39230 PyObject *resultobj;
39231 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39232 wxPoint result;
39233 PyObject * obj0 = 0 ;
39234 char *kwnames[] = {
39235 (char *) "self", NULL
39236 };
39237
39238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39240 if (SWIG_arg_fail(1)) SWIG_fail;
39241 {
39242 PyThreadState* __tstate = wxPyBeginAllowThreads();
39243 result = (arg1)->GetPosition();
39244
39245 wxPyEndAllowThreads(__tstate);
39246 if (PyErr_Occurred()) SWIG_fail;
39247 }
39248 {
39249 wxPoint * resultptr;
39250 resultptr = new wxPoint((wxPoint &)(result));
39251 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39252 }
39253 return resultobj;
39254 fail:
39255 return NULL;
39256 }
39257
39258
39259 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39260 PyObject *resultobj;
39261 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39262 PyObject *result;
39263 PyObject * obj0 = 0 ;
39264 char *kwnames[] = {
39265 (char *) "self", NULL
39266 };
39267
39268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39270 if (SWIG_arg_fail(1)) SWIG_fail;
39271 {
39272 PyThreadState* __tstate = wxPyBeginAllowThreads();
39273 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39274
39275 wxPyEndAllowThreads(__tstate);
39276 if (PyErr_Occurred()) SWIG_fail;
39277 }
39278 resultobj = result;
39279 return resultobj;
39280 fail:
39281 return NULL;
39282 }
39283
39284
39285 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39286 PyObject *obj;
39287 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39288 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39289 Py_INCREF(obj);
39290 return Py_BuildValue((char *)"");
39291 }
39292 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39293 PyObject *resultobj;
39294 wxSizer *arg1 = (wxSizer *) 0 ;
39295 PyObject *arg2 = (PyObject *) 0 ;
39296 PyObject * obj0 = 0 ;
39297 PyObject * obj1 = 0 ;
39298 char *kwnames[] = {
39299 (char *) "self",(char *) "_self", NULL
39300 };
39301
39302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39304 if (SWIG_arg_fail(1)) SWIG_fail;
39305 arg2 = obj1;
39306 {
39307 PyThreadState* __tstate = wxPyBeginAllowThreads();
39308 wxSizer__setOORInfo(arg1,arg2);
39309
39310 wxPyEndAllowThreads(__tstate);
39311 if (PyErr_Occurred()) SWIG_fail;
39312 }
39313 Py_INCREF(Py_None); resultobj = Py_None;
39314 return resultobj;
39315 fail:
39316 return NULL;
39317 }
39318
39319
39320 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39321 PyObject *resultobj;
39322 wxSizer *arg1 = (wxSizer *) 0 ;
39323 PyObject *arg2 = (PyObject *) 0 ;
39324 int arg3 = (int) 0 ;
39325 int arg4 = (int) 0 ;
39326 int arg5 = (int) 0 ;
39327 PyObject *arg6 = (PyObject *) NULL ;
39328 wxSizerItem *result;
39329 PyObject * obj0 = 0 ;
39330 PyObject * obj1 = 0 ;
39331 PyObject * obj2 = 0 ;
39332 PyObject * obj3 = 0 ;
39333 PyObject * obj4 = 0 ;
39334 PyObject * obj5 = 0 ;
39335 char *kwnames[] = {
39336 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39337 };
39338
39339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39341 if (SWIG_arg_fail(1)) SWIG_fail;
39342 arg2 = obj1;
39343 if (obj2) {
39344 {
39345 arg3 = (int)(SWIG_As_int(obj2));
39346 if (SWIG_arg_fail(3)) SWIG_fail;
39347 }
39348 }
39349 if (obj3) {
39350 {
39351 arg4 = (int)(SWIG_As_int(obj3));
39352 if (SWIG_arg_fail(4)) SWIG_fail;
39353 }
39354 }
39355 if (obj4) {
39356 {
39357 arg5 = (int)(SWIG_As_int(obj4));
39358 if (SWIG_arg_fail(5)) SWIG_fail;
39359 }
39360 }
39361 if (obj5) {
39362 arg6 = obj5;
39363 }
39364 {
39365 PyThreadState* __tstate = wxPyBeginAllowThreads();
39366 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39367
39368 wxPyEndAllowThreads(__tstate);
39369 if (PyErr_Occurred()) SWIG_fail;
39370 }
39371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39372 return resultobj;
39373 fail:
39374 return NULL;
39375 }
39376
39377
39378 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39379 PyObject *resultobj;
39380 wxSizer *arg1 = (wxSizer *) 0 ;
39381 int arg2 ;
39382 PyObject *arg3 = (PyObject *) 0 ;
39383 int arg4 = (int) 0 ;
39384 int arg5 = (int) 0 ;
39385 int arg6 = (int) 0 ;
39386 PyObject *arg7 = (PyObject *) NULL ;
39387 wxSizerItem *result;
39388 PyObject * obj0 = 0 ;
39389 PyObject * obj1 = 0 ;
39390 PyObject * obj2 = 0 ;
39391 PyObject * obj3 = 0 ;
39392 PyObject * obj4 = 0 ;
39393 PyObject * obj5 = 0 ;
39394 PyObject * obj6 = 0 ;
39395 char *kwnames[] = {
39396 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39397 };
39398
39399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39401 if (SWIG_arg_fail(1)) SWIG_fail;
39402 {
39403 arg2 = (int)(SWIG_As_int(obj1));
39404 if (SWIG_arg_fail(2)) SWIG_fail;
39405 }
39406 arg3 = obj2;
39407 if (obj3) {
39408 {
39409 arg4 = (int)(SWIG_As_int(obj3));
39410 if (SWIG_arg_fail(4)) SWIG_fail;
39411 }
39412 }
39413 if (obj4) {
39414 {
39415 arg5 = (int)(SWIG_As_int(obj4));
39416 if (SWIG_arg_fail(5)) SWIG_fail;
39417 }
39418 }
39419 if (obj5) {
39420 {
39421 arg6 = (int)(SWIG_As_int(obj5));
39422 if (SWIG_arg_fail(6)) SWIG_fail;
39423 }
39424 }
39425 if (obj6) {
39426 arg7 = obj6;
39427 }
39428 {
39429 PyThreadState* __tstate = wxPyBeginAllowThreads();
39430 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39431
39432 wxPyEndAllowThreads(__tstate);
39433 if (PyErr_Occurred()) SWIG_fail;
39434 }
39435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39436 return resultobj;
39437 fail:
39438 return NULL;
39439 }
39440
39441
39442 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39443 PyObject *resultobj;
39444 wxSizer *arg1 = (wxSizer *) 0 ;
39445 PyObject *arg2 = (PyObject *) 0 ;
39446 int arg3 = (int) 0 ;
39447 int arg4 = (int) 0 ;
39448 int arg5 = (int) 0 ;
39449 PyObject *arg6 = (PyObject *) NULL ;
39450 wxSizerItem *result;
39451 PyObject * obj0 = 0 ;
39452 PyObject * obj1 = 0 ;
39453 PyObject * obj2 = 0 ;
39454 PyObject * obj3 = 0 ;
39455 PyObject * obj4 = 0 ;
39456 PyObject * obj5 = 0 ;
39457 char *kwnames[] = {
39458 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39459 };
39460
39461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39463 if (SWIG_arg_fail(1)) SWIG_fail;
39464 arg2 = obj1;
39465 if (obj2) {
39466 {
39467 arg3 = (int)(SWIG_As_int(obj2));
39468 if (SWIG_arg_fail(3)) SWIG_fail;
39469 }
39470 }
39471 if (obj3) {
39472 {
39473 arg4 = (int)(SWIG_As_int(obj3));
39474 if (SWIG_arg_fail(4)) SWIG_fail;
39475 }
39476 }
39477 if (obj4) {
39478 {
39479 arg5 = (int)(SWIG_As_int(obj4));
39480 if (SWIG_arg_fail(5)) SWIG_fail;
39481 }
39482 }
39483 if (obj5) {
39484 arg6 = obj5;
39485 }
39486 {
39487 PyThreadState* __tstate = wxPyBeginAllowThreads();
39488 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39489
39490 wxPyEndAllowThreads(__tstate);
39491 if (PyErr_Occurred()) SWIG_fail;
39492 }
39493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39494 return resultobj;
39495 fail:
39496 return NULL;
39497 }
39498
39499
39500 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39501 PyObject *resultobj;
39502 wxSizer *arg1 = (wxSizer *) 0 ;
39503 PyObject *arg2 = (PyObject *) 0 ;
39504 bool result;
39505 PyObject * obj0 = 0 ;
39506 PyObject * obj1 = 0 ;
39507 char *kwnames[] = {
39508 (char *) "self",(char *) "item", NULL
39509 };
39510
39511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39513 if (SWIG_arg_fail(1)) SWIG_fail;
39514 arg2 = obj1;
39515 {
39516 PyThreadState* __tstate = wxPyBeginAllowThreads();
39517 result = (bool)wxSizer_Remove(arg1,arg2);
39518
39519 wxPyEndAllowThreads(__tstate);
39520 if (PyErr_Occurred()) SWIG_fail;
39521 }
39522 {
39523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39524 }
39525 return resultobj;
39526 fail:
39527 return NULL;
39528 }
39529
39530
39531 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39532 PyObject *resultobj;
39533 wxSizer *arg1 = (wxSizer *) 0 ;
39534 PyObject *arg2 = (PyObject *) 0 ;
39535 bool result;
39536 PyObject * obj0 = 0 ;
39537 PyObject * obj1 = 0 ;
39538 char *kwnames[] = {
39539 (char *) "self",(char *) "item", NULL
39540 };
39541
39542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39544 if (SWIG_arg_fail(1)) SWIG_fail;
39545 arg2 = obj1;
39546 {
39547 PyThreadState* __tstate = wxPyBeginAllowThreads();
39548 result = (bool)wxSizer_Detach(arg1,arg2);
39549
39550 wxPyEndAllowThreads(__tstate);
39551 if (PyErr_Occurred()) SWIG_fail;
39552 }
39553 {
39554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39555 }
39556 return resultobj;
39557 fail:
39558 return NULL;
39559 }
39560
39561
39562 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39563 PyObject *resultobj;
39564 wxSizer *arg1 = (wxSizer *) 0 ;
39565 PyObject *arg2 = (PyObject *) 0 ;
39566 wxSizerItem *result;
39567 PyObject * obj0 = 0 ;
39568 PyObject * obj1 = 0 ;
39569 char *kwnames[] = {
39570 (char *) "self",(char *) "item", NULL
39571 };
39572
39573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39575 if (SWIG_arg_fail(1)) SWIG_fail;
39576 arg2 = obj1;
39577 {
39578 PyThreadState* __tstate = wxPyBeginAllowThreads();
39579 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39580
39581 wxPyEndAllowThreads(__tstate);
39582 if (PyErr_Occurred()) SWIG_fail;
39583 }
39584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39585 return resultobj;
39586 fail:
39587 return NULL;
39588 }
39589
39590
39591 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39592 PyObject *resultobj;
39593 wxSizer *arg1 = (wxSizer *) 0 ;
39594 PyObject *arg2 = (PyObject *) 0 ;
39595 wxSize *arg3 = 0 ;
39596 wxSize temp3 ;
39597 PyObject * obj0 = 0 ;
39598 PyObject * obj1 = 0 ;
39599 PyObject * obj2 = 0 ;
39600 char *kwnames[] = {
39601 (char *) "self",(char *) "item",(char *) "size", NULL
39602 };
39603
39604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39606 if (SWIG_arg_fail(1)) SWIG_fail;
39607 arg2 = obj1;
39608 {
39609 arg3 = &temp3;
39610 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39611 }
39612 {
39613 PyThreadState* __tstate = wxPyBeginAllowThreads();
39614 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39615
39616 wxPyEndAllowThreads(__tstate);
39617 if (PyErr_Occurred()) SWIG_fail;
39618 }
39619 Py_INCREF(Py_None); resultobj = Py_None;
39620 return resultobj;
39621 fail:
39622 return NULL;
39623 }
39624
39625
39626 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39627 PyObject *resultobj;
39628 wxSizer *arg1 = (wxSizer *) 0 ;
39629 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39630 wxSizerItem *result;
39631 PyObject * obj0 = 0 ;
39632 PyObject * obj1 = 0 ;
39633 char *kwnames[] = {
39634 (char *) "self",(char *) "item", NULL
39635 };
39636
39637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39639 if (SWIG_arg_fail(1)) SWIG_fail;
39640 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39641 if (SWIG_arg_fail(2)) SWIG_fail;
39642 {
39643 PyThreadState* __tstate = wxPyBeginAllowThreads();
39644 result = (wxSizerItem *)(arg1)->Add(arg2);
39645
39646 wxPyEndAllowThreads(__tstate);
39647 if (PyErr_Occurred()) SWIG_fail;
39648 }
39649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39650 return resultobj;
39651 fail:
39652 return NULL;
39653 }
39654
39655
39656 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39657 PyObject *resultobj;
39658 wxSizer *arg1 = (wxSizer *) 0 ;
39659 size_t arg2 ;
39660 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39661 wxSizerItem *result;
39662 PyObject * obj0 = 0 ;
39663 PyObject * obj1 = 0 ;
39664 PyObject * obj2 = 0 ;
39665 char *kwnames[] = {
39666 (char *) "self",(char *) "index",(char *) "item", NULL
39667 };
39668
39669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39671 if (SWIG_arg_fail(1)) SWIG_fail;
39672 {
39673 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39674 if (SWIG_arg_fail(2)) SWIG_fail;
39675 }
39676 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39677 if (SWIG_arg_fail(3)) SWIG_fail;
39678 {
39679 PyThreadState* __tstate = wxPyBeginAllowThreads();
39680 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39681
39682 wxPyEndAllowThreads(__tstate);
39683 if (PyErr_Occurred()) SWIG_fail;
39684 }
39685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39686 return resultobj;
39687 fail:
39688 return NULL;
39689 }
39690
39691
39692 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39693 PyObject *resultobj;
39694 wxSizer *arg1 = (wxSizer *) 0 ;
39695 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39696 wxSizerItem *result;
39697 PyObject * obj0 = 0 ;
39698 PyObject * obj1 = 0 ;
39699 char *kwnames[] = {
39700 (char *) "self",(char *) "item", NULL
39701 };
39702
39703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39705 if (SWIG_arg_fail(1)) SWIG_fail;
39706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39707 if (SWIG_arg_fail(2)) SWIG_fail;
39708 {
39709 PyThreadState* __tstate = wxPyBeginAllowThreads();
39710 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39711
39712 wxPyEndAllowThreads(__tstate);
39713 if (PyErr_Occurred()) SWIG_fail;
39714 }
39715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39716 return resultobj;
39717 fail:
39718 return NULL;
39719 }
39720
39721
39722 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39723 PyObject *resultobj;
39724 wxSizer *arg1 = (wxSizer *) 0 ;
39725 int arg2 ;
39726 int arg3 ;
39727 int arg4 ;
39728 int arg5 ;
39729 PyObject * obj0 = 0 ;
39730 PyObject * obj1 = 0 ;
39731 PyObject * obj2 = 0 ;
39732 PyObject * obj3 = 0 ;
39733 PyObject * obj4 = 0 ;
39734 char *kwnames[] = {
39735 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39736 };
39737
39738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39740 if (SWIG_arg_fail(1)) SWIG_fail;
39741 {
39742 arg2 = (int)(SWIG_As_int(obj1));
39743 if (SWIG_arg_fail(2)) SWIG_fail;
39744 }
39745 {
39746 arg3 = (int)(SWIG_As_int(obj2));
39747 if (SWIG_arg_fail(3)) SWIG_fail;
39748 }
39749 {
39750 arg4 = (int)(SWIG_As_int(obj3));
39751 if (SWIG_arg_fail(4)) SWIG_fail;
39752 }
39753 {
39754 arg5 = (int)(SWIG_As_int(obj4));
39755 if (SWIG_arg_fail(5)) SWIG_fail;
39756 }
39757 {
39758 PyThreadState* __tstate = wxPyBeginAllowThreads();
39759 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39760
39761 wxPyEndAllowThreads(__tstate);
39762 if (PyErr_Occurred()) SWIG_fail;
39763 }
39764 Py_INCREF(Py_None); resultobj = Py_None;
39765 return resultobj;
39766 fail:
39767 return NULL;
39768 }
39769
39770
39771 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39772 PyObject *resultobj;
39773 wxSizer *arg1 = (wxSizer *) 0 ;
39774 wxSize *arg2 = 0 ;
39775 wxSize temp2 ;
39776 PyObject * obj0 = 0 ;
39777 PyObject * obj1 = 0 ;
39778 char *kwnames[] = {
39779 (char *) "self",(char *) "size", NULL
39780 };
39781
39782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39784 if (SWIG_arg_fail(1)) SWIG_fail;
39785 {
39786 arg2 = &temp2;
39787 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39788 }
39789 {
39790 PyThreadState* __tstate = wxPyBeginAllowThreads();
39791 (arg1)->SetMinSize((wxSize const &)*arg2);
39792
39793 wxPyEndAllowThreads(__tstate);
39794 if (PyErr_Occurred()) SWIG_fail;
39795 }
39796 Py_INCREF(Py_None); resultobj = Py_None;
39797 return resultobj;
39798 fail:
39799 return NULL;
39800 }
39801
39802
39803 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39804 PyObject *resultobj;
39805 wxSizer *arg1 = (wxSizer *) 0 ;
39806 wxSize result;
39807 PyObject * obj0 = 0 ;
39808 char *kwnames[] = {
39809 (char *) "self", NULL
39810 };
39811
39812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39814 if (SWIG_arg_fail(1)) SWIG_fail;
39815 {
39816 PyThreadState* __tstate = wxPyBeginAllowThreads();
39817 result = (arg1)->GetSize();
39818
39819 wxPyEndAllowThreads(__tstate);
39820 if (PyErr_Occurred()) SWIG_fail;
39821 }
39822 {
39823 wxSize * resultptr;
39824 resultptr = new wxSize((wxSize &)(result));
39825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39826 }
39827 return resultobj;
39828 fail:
39829 return NULL;
39830 }
39831
39832
39833 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39834 PyObject *resultobj;
39835 wxSizer *arg1 = (wxSizer *) 0 ;
39836 wxPoint result;
39837 PyObject * obj0 = 0 ;
39838 char *kwnames[] = {
39839 (char *) "self", NULL
39840 };
39841
39842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39844 if (SWIG_arg_fail(1)) SWIG_fail;
39845 {
39846 PyThreadState* __tstate = wxPyBeginAllowThreads();
39847 result = (arg1)->GetPosition();
39848
39849 wxPyEndAllowThreads(__tstate);
39850 if (PyErr_Occurred()) SWIG_fail;
39851 }
39852 {
39853 wxPoint * resultptr;
39854 resultptr = new wxPoint((wxPoint &)(result));
39855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39856 }
39857 return resultobj;
39858 fail:
39859 return NULL;
39860 }
39861
39862
39863 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39864 PyObject *resultobj;
39865 wxSizer *arg1 = (wxSizer *) 0 ;
39866 wxSize result;
39867 PyObject * obj0 = 0 ;
39868 char *kwnames[] = {
39869 (char *) "self", NULL
39870 };
39871
39872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39874 if (SWIG_arg_fail(1)) SWIG_fail;
39875 {
39876 PyThreadState* __tstate = wxPyBeginAllowThreads();
39877 result = (arg1)->GetMinSize();
39878
39879 wxPyEndAllowThreads(__tstate);
39880 if (PyErr_Occurred()) SWIG_fail;
39881 }
39882 {
39883 wxSize * resultptr;
39884 resultptr = new wxSize((wxSize &)(result));
39885 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39886 }
39887 return resultobj;
39888 fail:
39889 return NULL;
39890 }
39891
39892
39893 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39894 PyObject *resultobj;
39895 wxSizer *arg1 = (wxSizer *) 0 ;
39896 PyObject * obj0 = 0 ;
39897 char *kwnames[] = {
39898 (char *) "self", NULL
39899 };
39900
39901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39903 if (SWIG_arg_fail(1)) SWIG_fail;
39904 {
39905 PyThreadState* __tstate = wxPyBeginAllowThreads();
39906 (arg1)->RecalcSizes();
39907
39908 wxPyEndAllowThreads(__tstate);
39909 if (PyErr_Occurred()) SWIG_fail;
39910 }
39911 Py_INCREF(Py_None); resultobj = Py_None;
39912 return resultobj;
39913 fail:
39914 return NULL;
39915 }
39916
39917
39918 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39919 PyObject *resultobj;
39920 wxSizer *arg1 = (wxSizer *) 0 ;
39921 wxSize result;
39922 PyObject * obj0 = 0 ;
39923 char *kwnames[] = {
39924 (char *) "self", NULL
39925 };
39926
39927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39929 if (SWIG_arg_fail(1)) SWIG_fail;
39930 {
39931 PyThreadState* __tstate = wxPyBeginAllowThreads();
39932 result = (arg1)->CalcMin();
39933
39934 wxPyEndAllowThreads(__tstate);
39935 if (PyErr_Occurred()) SWIG_fail;
39936 }
39937 {
39938 wxSize * resultptr;
39939 resultptr = new wxSize((wxSize &)(result));
39940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39941 }
39942 return resultobj;
39943 fail:
39944 return NULL;
39945 }
39946
39947
39948 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39949 PyObject *resultobj;
39950 wxSizer *arg1 = (wxSizer *) 0 ;
39951 PyObject * obj0 = 0 ;
39952 char *kwnames[] = {
39953 (char *) "self", NULL
39954 };
39955
39956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39958 if (SWIG_arg_fail(1)) SWIG_fail;
39959 {
39960 PyThreadState* __tstate = wxPyBeginAllowThreads();
39961 (arg1)->Layout();
39962
39963 wxPyEndAllowThreads(__tstate);
39964 if (PyErr_Occurred()) SWIG_fail;
39965 }
39966 Py_INCREF(Py_None); resultobj = Py_None;
39967 return resultobj;
39968 fail:
39969 return NULL;
39970 }
39971
39972
39973 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39974 PyObject *resultobj;
39975 wxSizer *arg1 = (wxSizer *) 0 ;
39976 wxWindow *arg2 = (wxWindow *) 0 ;
39977 wxSize result;
39978 PyObject * obj0 = 0 ;
39979 PyObject * obj1 = 0 ;
39980 char *kwnames[] = {
39981 (char *) "self",(char *) "window", NULL
39982 };
39983
39984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39986 if (SWIG_arg_fail(1)) SWIG_fail;
39987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39988 if (SWIG_arg_fail(2)) SWIG_fail;
39989 {
39990 PyThreadState* __tstate = wxPyBeginAllowThreads();
39991 result = (arg1)->Fit(arg2);
39992
39993 wxPyEndAllowThreads(__tstate);
39994 if (PyErr_Occurred()) SWIG_fail;
39995 }
39996 {
39997 wxSize * resultptr;
39998 resultptr = new wxSize((wxSize &)(result));
39999 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40000 }
40001 return resultobj;
40002 fail:
40003 return NULL;
40004 }
40005
40006
40007 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40008 PyObject *resultobj;
40009 wxSizer *arg1 = (wxSizer *) 0 ;
40010 wxWindow *arg2 = (wxWindow *) 0 ;
40011 PyObject * obj0 = 0 ;
40012 PyObject * obj1 = 0 ;
40013 char *kwnames[] = {
40014 (char *) "self",(char *) "window", NULL
40015 };
40016
40017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40019 if (SWIG_arg_fail(1)) SWIG_fail;
40020 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40021 if (SWIG_arg_fail(2)) SWIG_fail;
40022 {
40023 PyThreadState* __tstate = wxPyBeginAllowThreads();
40024 (arg1)->FitInside(arg2);
40025
40026 wxPyEndAllowThreads(__tstate);
40027 if (PyErr_Occurred()) SWIG_fail;
40028 }
40029 Py_INCREF(Py_None); resultobj = Py_None;
40030 return resultobj;
40031 fail:
40032 return NULL;
40033 }
40034
40035
40036 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40037 PyObject *resultobj;
40038 wxSizer *arg1 = (wxSizer *) 0 ;
40039 wxWindow *arg2 = (wxWindow *) 0 ;
40040 PyObject * obj0 = 0 ;
40041 PyObject * obj1 = 0 ;
40042 char *kwnames[] = {
40043 (char *) "self",(char *) "window", NULL
40044 };
40045
40046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40048 if (SWIG_arg_fail(1)) SWIG_fail;
40049 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40050 if (SWIG_arg_fail(2)) SWIG_fail;
40051 {
40052 PyThreadState* __tstate = wxPyBeginAllowThreads();
40053 (arg1)->SetSizeHints(arg2);
40054
40055 wxPyEndAllowThreads(__tstate);
40056 if (PyErr_Occurred()) SWIG_fail;
40057 }
40058 Py_INCREF(Py_None); resultobj = Py_None;
40059 return resultobj;
40060 fail:
40061 return NULL;
40062 }
40063
40064
40065 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40066 PyObject *resultobj;
40067 wxSizer *arg1 = (wxSizer *) 0 ;
40068 wxWindow *arg2 = (wxWindow *) 0 ;
40069 PyObject * obj0 = 0 ;
40070 PyObject * obj1 = 0 ;
40071 char *kwnames[] = {
40072 (char *) "self",(char *) "window", NULL
40073 };
40074
40075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40077 if (SWIG_arg_fail(1)) SWIG_fail;
40078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40079 if (SWIG_arg_fail(2)) SWIG_fail;
40080 {
40081 PyThreadState* __tstate = wxPyBeginAllowThreads();
40082 (arg1)->SetVirtualSizeHints(arg2);
40083
40084 wxPyEndAllowThreads(__tstate);
40085 if (PyErr_Occurred()) SWIG_fail;
40086 }
40087 Py_INCREF(Py_None); resultobj = Py_None;
40088 return resultobj;
40089 fail:
40090 return NULL;
40091 }
40092
40093
40094 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40095 PyObject *resultobj;
40096 wxSizer *arg1 = (wxSizer *) 0 ;
40097 bool arg2 = (bool) false ;
40098 PyObject * obj0 = 0 ;
40099 PyObject * obj1 = 0 ;
40100 char *kwnames[] = {
40101 (char *) "self",(char *) "deleteWindows", NULL
40102 };
40103
40104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40106 if (SWIG_arg_fail(1)) SWIG_fail;
40107 if (obj1) {
40108 {
40109 arg2 = (bool)(SWIG_As_bool(obj1));
40110 if (SWIG_arg_fail(2)) SWIG_fail;
40111 }
40112 }
40113 {
40114 PyThreadState* __tstate = wxPyBeginAllowThreads();
40115 (arg1)->Clear(arg2);
40116
40117 wxPyEndAllowThreads(__tstate);
40118 if (PyErr_Occurred()) SWIG_fail;
40119 }
40120 Py_INCREF(Py_None); resultobj = Py_None;
40121 return resultobj;
40122 fail:
40123 return NULL;
40124 }
40125
40126
40127 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40128 PyObject *resultobj;
40129 wxSizer *arg1 = (wxSizer *) 0 ;
40130 PyObject * obj0 = 0 ;
40131 char *kwnames[] = {
40132 (char *) "self", NULL
40133 };
40134
40135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40137 if (SWIG_arg_fail(1)) SWIG_fail;
40138 {
40139 PyThreadState* __tstate = wxPyBeginAllowThreads();
40140 (arg1)->DeleteWindows();
40141
40142 wxPyEndAllowThreads(__tstate);
40143 if (PyErr_Occurred()) SWIG_fail;
40144 }
40145 Py_INCREF(Py_None); resultobj = Py_None;
40146 return resultobj;
40147 fail:
40148 return NULL;
40149 }
40150
40151
40152 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40153 PyObject *resultobj;
40154 wxSizer *arg1 = (wxSizer *) 0 ;
40155 PyObject *result;
40156 PyObject * obj0 = 0 ;
40157 char *kwnames[] = {
40158 (char *) "self", NULL
40159 };
40160
40161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40163 if (SWIG_arg_fail(1)) SWIG_fail;
40164 {
40165 PyThreadState* __tstate = wxPyBeginAllowThreads();
40166 result = (PyObject *)wxSizer_GetChildren(arg1);
40167
40168 wxPyEndAllowThreads(__tstate);
40169 if (PyErr_Occurred()) SWIG_fail;
40170 }
40171 resultobj = result;
40172 return resultobj;
40173 fail:
40174 return NULL;
40175 }
40176
40177
40178 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40179 PyObject *resultobj;
40180 wxSizer *arg1 = (wxSizer *) 0 ;
40181 PyObject *arg2 = (PyObject *) 0 ;
40182 bool arg3 = (bool) true ;
40183 bool arg4 = (bool) false ;
40184 bool result;
40185 PyObject * obj0 = 0 ;
40186 PyObject * obj1 = 0 ;
40187 PyObject * obj2 = 0 ;
40188 PyObject * obj3 = 0 ;
40189 char *kwnames[] = {
40190 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40191 };
40192
40193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40195 if (SWIG_arg_fail(1)) SWIG_fail;
40196 arg2 = obj1;
40197 if (obj2) {
40198 {
40199 arg3 = (bool)(SWIG_As_bool(obj2));
40200 if (SWIG_arg_fail(3)) SWIG_fail;
40201 }
40202 }
40203 if (obj3) {
40204 {
40205 arg4 = (bool)(SWIG_As_bool(obj3));
40206 if (SWIG_arg_fail(4)) SWIG_fail;
40207 }
40208 }
40209 {
40210 PyThreadState* __tstate = wxPyBeginAllowThreads();
40211 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40212
40213 wxPyEndAllowThreads(__tstate);
40214 if (PyErr_Occurred()) SWIG_fail;
40215 }
40216 {
40217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40218 }
40219 return resultobj;
40220 fail:
40221 return NULL;
40222 }
40223
40224
40225 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40226 PyObject *resultobj;
40227 wxSizer *arg1 = (wxSizer *) 0 ;
40228 PyObject *arg2 = (PyObject *) 0 ;
40229 bool result;
40230 PyObject * obj0 = 0 ;
40231 PyObject * obj1 = 0 ;
40232 char *kwnames[] = {
40233 (char *) "self",(char *) "item", NULL
40234 };
40235
40236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40238 if (SWIG_arg_fail(1)) SWIG_fail;
40239 arg2 = obj1;
40240 {
40241 PyThreadState* __tstate = wxPyBeginAllowThreads();
40242 result = (bool)wxSizer_IsShown(arg1,arg2);
40243
40244 wxPyEndAllowThreads(__tstate);
40245 if (PyErr_Occurred()) SWIG_fail;
40246 }
40247 {
40248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40249 }
40250 return resultobj;
40251 fail:
40252 return NULL;
40253 }
40254
40255
40256 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40257 PyObject *resultobj;
40258 wxSizer *arg1 = (wxSizer *) 0 ;
40259 bool arg2 ;
40260 PyObject * obj0 = 0 ;
40261 PyObject * obj1 = 0 ;
40262 char *kwnames[] = {
40263 (char *) "self",(char *) "show", NULL
40264 };
40265
40266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40268 if (SWIG_arg_fail(1)) SWIG_fail;
40269 {
40270 arg2 = (bool)(SWIG_As_bool(obj1));
40271 if (SWIG_arg_fail(2)) SWIG_fail;
40272 }
40273 {
40274 PyThreadState* __tstate = wxPyBeginAllowThreads();
40275 (arg1)->ShowItems(arg2);
40276
40277 wxPyEndAllowThreads(__tstate);
40278 if (PyErr_Occurred()) SWIG_fail;
40279 }
40280 Py_INCREF(Py_None); resultobj = Py_None;
40281 return resultobj;
40282 fail:
40283 return NULL;
40284 }
40285
40286
40287 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40288 PyObject *obj;
40289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40290 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40291 Py_INCREF(obj);
40292 return Py_BuildValue((char *)"");
40293 }
40294 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40295 PyObject *resultobj;
40296 wxPySizer *result;
40297 char *kwnames[] = {
40298 NULL
40299 };
40300
40301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40302 {
40303 PyThreadState* __tstate = wxPyBeginAllowThreads();
40304 result = (wxPySizer *)new wxPySizer();
40305
40306 wxPyEndAllowThreads(__tstate);
40307 if (PyErr_Occurred()) SWIG_fail;
40308 }
40309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40310 return resultobj;
40311 fail:
40312 return NULL;
40313 }
40314
40315
40316 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40317 PyObject *resultobj;
40318 wxPySizer *arg1 = (wxPySizer *) 0 ;
40319 PyObject *arg2 = (PyObject *) 0 ;
40320 PyObject *arg3 = (PyObject *) 0 ;
40321 PyObject * obj0 = 0 ;
40322 PyObject * obj1 = 0 ;
40323 PyObject * obj2 = 0 ;
40324 char *kwnames[] = {
40325 (char *) "self",(char *) "self",(char *) "_class", NULL
40326 };
40327
40328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40330 if (SWIG_arg_fail(1)) SWIG_fail;
40331 arg2 = obj1;
40332 arg3 = obj2;
40333 {
40334 PyThreadState* __tstate = wxPyBeginAllowThreads();
40335 (arg1)->_setCallbackInfo(arg2,arg3);
40336
40337 wxPyEndAllowThreads(__tstate);
40338 if (PyErr_Occurred()) SWIG_fail;
40339 }
40340 Py_INCREF(Py_None); resultobj = Py_None;
40341 return resultobj;
40342 fail:
40343 return NULL;
40344 }
40345
40346
40347 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40348 PyObject *obj;
40349 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40350 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40351 Py_INCREF(obj);
40352 return Py_BuildValue((char *)"");
40353 }
40354 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40355 PyObject *resultobj;
40356 int arg1 = (int) wxHORIZONTAL ;
40357 wxBoxSizer *result;
40358 PyObject * obj0 = 0 ;
40359 char *kwnames[] = {
40360 (char *) "orient", NULL
40361 };
40362
40363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40364 if (obj0) {
40365 {
40366 arg1 = (int)(SWIG_As_int(obj0));
40367 if (SWIG_arg_fail(1)) SWIG_fail;
40368 }
40369 }
40370 {
40371 PyThreadState* __tstate = wxPyBeginAllowThreads();
40372 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40373
40374 wxPyEndAllowThreads(__tstate);
40375 if (PyErr_Occurred()) SWIG_fail;
40376 }
40377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40378 return resultobj;
40379 fail:
40380 return NULL;
40381 }
40382
40383
40384 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40385 PyObject *resultobj;
40386 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40387 int result;
40388 PyObject * obj0 = 0 ;
40389 char *kwnames[] = {
40390 (char *) "self", NULL
40391 };
40392
40393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40395 if (SWIG_arg_fail(1)) SWIG_fail;
40396 {
40397 PyThreadState* __tstate = wxPyBeginAllowThreads();
40398 result = (int)(arg1)->GetOrientation();
40399
40400 wxPyEndAllowThreads(__tstate);
40401 if (PyErr_Occurred()) SWIG_fail;
40402 }
40403 {
40404 resultobj = SWIG_From_int((int)(result));
40405 }
40406 return resultobj;
40407 fail:
40408 return NULL;
40409 }
40410
40411
40412 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40413 PyObject *resultobj;
40414 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40415 int arg2 ;
40416 PyObject * obj0 = 0 ;
40417 PyObject * obj1 = 0 ;
40418 char *kwnames[] = {
40419 (char *) "self",(char *) "orient", NULL
40420 };
40421
40422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40424 if (SWIG_arg_fail(1)) SWIG_fail;
40425 {
40426 arg2 = (int)(SWIG_As_int(obj1));
40427 if (SWIG_arg_fail(2)) SWIG_fail;
40428 }
40429 {
40430 PyThreadState* __tstate = wxPyBeginAllowThreads();
40431 (arg1)->SetOrientation(arg2);
40432
40433 wxPyEndAllowThreads(__tstate);
40434 if (PyErr_Occurred()) SWIG_fail;
40435 }
40436 Py_INCREF(Py_None); resultobj = Py_None;
40437 return resultobj;
40438 fail:
40439 return NULL;
40440 }
40441
40442
40443 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40444 PyObject *obj;
40445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40446 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40447 Py_INCREF(obj);
40448 return Py_BuildValue((char *)"");
40449 }
40450 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40451 PyObject *resultobj;
40452 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40453 int arg2 = (int) wxHORIZONTAL ;
40454 wxStaticBoxSizer *result;
40455 PyObject * obj0 = 0 ;
40456 PyObject * obj1 = 0 ;
40457 char *kwnames[] = {
40458 (char *) "box",(char *) "orient", NULL
40459 };
40460
40461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40463 if (SWIG_arg_fail(1)) SWIG_fail;
40464 if (obj1) {
40465 {
40466 arg2 = (int)(SWIG_As_int(obj1));
40467 if (SWIG_arg_fail(2)) SWIG_fail;
40468 }
40469 }
40470 {
40471 PyThreadState* __tstate = wxPyBeginAllowThreads();
40472 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40473
40474 wxPyEndAllowThreads(__tstate);
40475 if (PyErr_Occurred()) SWIG_fail;
40476 }
40477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40478 return resultobj;
40479 fail:
40480 return NULL;
40481 }
40482
40483
40484 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40485 PyObject *resultobj;
40486 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40487 wxStaticBox *result;
40488 PyObject * obj0 = 0 ;
40489 char *kwnames[] = {
40490 (char *) "self", NULL
40491 };
40492
40493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40495 if (SWIG_arg_fail(1)) SWIG_fail;
40496 {
40497 PyThreadState* __tstate = wxPyBeginAllowThreads();
40498 result = (wxStaticBox *)(arg1)->GetStaticBox();
40499
40500 wxPyEndAllowThreads(__tstate);
40501 if (PyErr_Occurred()) SWIG_fail;
40502 }
40503 {
40504 resultobj = wxPyMake_wxObject(result, 0);
40505 }
40506 return resultobj;
40507 fail:
40508 return NULL;
40509 }
40510
40511
40512 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40513 PyObject *obj;
40514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40515 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40516 Py_INCREF(obj);
40517 return Py_BuildValue((char *)"");
40518 }
40519 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40520 PyObject *resultobj;
40521 int arg1 = (int) 1 ;
40522 int arg2 = (int) 0 ;
40523 int arg3 = (int) 0 ;
40524 int arg4 = (int) 0 ;
40525 wxGridSizer *result;
40526 PyObject * obj0 = 0 ;
40527 PyObject * obj1 = 0 ;
40528 PyObject * obj2 = 0 ;
40529 PyObject * obj3 = 0 ;
40530 char *kwnames[] = {
40531 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40532 };
40533
40534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40535 if (obj0) {
40536 {
40537 arg1 = (int)(SWIG_As_int(obj0));
40538 if (SWIG_arg_fail(1)) SWIG_fail;
40539 }
40540 }
40541 if (obj1) {
40542 {
40543 arg2 = (int)(SWIG_As_int(obj1));
40544 if (SWIG_arg_fail(2)) SWIG_fail;
40545 }
40546 }
40547 if (obj2) {
40548 {
40549 arg3 = (int)(SWIG_As_int(obj2));
40550 if (SWIG_arg_fail(3)) SWIG_fail;
40551 }
40552 }
40553 if (obj3) {
40554 {
40555 arg4 = (int)(SWIG_As_int(obj3));
40556 if (SWIG_arg_fail(4)) SWIG_fail;
40557 }
40558 }
40559 {
40560 PyThreadState* __tstate = wxPyBeginAllowThreads();
40561 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40562
40563 wxPyEndAllowThreads(__tstate);
40564 if (PyErr_Occurred()) SWIG_fail;
40565 }
40566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40567 return resultobj;
40568 fail:
40569 return NULL;
40570 }
40571
40572
40573 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40574 PyObject *resultobj;
40575 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40576 int arg2 ;
40577 PyObject * obj0 = 0 ;
40578 PyObject * obj1 = 0 ;
40579 char *kwnames[] = {
40580 (char *) "self",(char *) "cols", NULL
40581 };
40582
40583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40585 if (SWIG_arg_fail(1)) SWIG_fail;
40586 {
40587 arg2 = (int)(SWIG_As_int(obj1));
40588 if (SWIG_arg_fail(2)) SWIG_fail;
40589 }
40590 {
40591 PyThreadState* __tstate = wxPyBeginAllowThreads();
40592 (arg1)->SetCols(arg2);
40593
40594 wxPyEndAllowThreads(__tstate);
40595 if (PyErr_Occurred()) SWIG_fail;
40596 }
40597 Py_INCREF(Py_None); resultobj = Py_None;
40598 return resultobj;
40599 fail:
40600 return NULL;
40601 }
40602
40603
40604 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40605 PyObject *resultobj;
40606 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40607 int arg2 ;
40608 PyObject * obj0 = 0 ;
40609 PyObject * obj1 = 0 ;
40610 char *kwnames[] = {
40611 (char *) "self",(char *) "rows", NULL
40612 };
40613
40614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40616 if (SWIG_arg_fail(1)) SWIG_fail;
40617 {
40618 arg2 = (int)(SWIG_As_int(obj1));
40619 if (SWIG_arg_fail(2)) SWIG_fail;
40620 }
40621 {
40622 PyThreadState* __tstate = wxPyBeginAllowThreads();
40623 (arg1)->SetRows(arg2);
40624
40625 wxPyEndAllowThreads(__tstate);
40626 if (PyErr_Occurred()) SWIG_fail;
40627 }
40628 Py_INCREF(Py_None); resultobj = Py_None;
40629 return resultobj;
40630 fail:
40631 return NULL;
40632 }
40633
40634
40635 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40636 PyObject *resultobj;
40637 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40638 int arg2 ;
40639 PyObject * obj0 = 0 ;
40640 PyObject * obj1 = 0 ;
40641 char *kwnames[] = {
40642 (char *) "self",(char *) "gap", NULL
40643 };
40644
40645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40647 if (SWIG_arg_fail(1)) SWIG_fail;
40648 {
40649 arg2 = (int)(SWIG_As_int(obj1));
40650 if (SWIG_arg_fail(2)) SWIG_fail;
40651 }
40652 {
40653 PyThreadState* __tstate = wxPyBeginAllowThreads();
40654 (arg1)->SetVGap(arg2);
40655
40656 wxPyEndAllowThreads(__tstate);
40657 if (PyErr_Occurred()) SWIG_fail;
40658 }
40659 Py_INCREF(Py_None); resultobj = Py_None;
40660 return resultobj;
40661 fail:
40662 return NULL;
40663 }
40664
40665
40666 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40667 PyObject *resultobj;
40668 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40669 int arg2 ;
40670 PyObject * obj0 = 0 ;
40671 PyObject * obj1 = 0 ;
40672 char *kwnames[] = {
40673 (char *) "self",(char *) "gap", NULL
40674 };
40675
40676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40678 if (SWIG_arg_fail(1)) SWIG_fail;
40679 {
40680 arg2 = (int)(SWIG_As_int(obj1));
40681 if (SWIG_arg_fail(2)) SWIG_fail;
40682 }
40683 {
40684 PyThreadState* __tstate = wxPyBeginAllowThreads();
40685 (arg1)->SetHGap(arg2);
40686
40687 wxPyEndAllowThreads(__tstate);
40688 if (PyErr_Occurred()) SWIG_fail;
40689 }
40690 Py_INCREF(Py_None); resultobj = Py_None;
40691 return resultobj;
40692 fail:
40693 return NULL;
40694 }
40695
40696
40697 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40698 PyObject *resultobj;
40699 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40700 int result;
40701 PyObject * obj0 = 0 ;
40702 char *kwnames[] = {
40703 (char *) "self", NULL
40704 };
40705
40706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40708 if (SWIG_arg_fail(1)) SWIG_fail;
40709 {
40710 PyThreadState* __tstate = wxPyBeginAllowThreads();
40711 result = (int)(arg1)->GetCols();
40712
40713 wxPyEndAllowThreads(__tstate);
40714 if (PyErr_Occurred()) SWIG_fail;
40715 }
40716 {
40717 resultobj = SWIG_From_int((int)(result));
40718 }
40719 return resultobj;
40720 fail:
40721 return NULL;
40722 }
40723
40724
40725 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40726 PyObject *resultobj;
40727 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40728 int result;
40729 PyObject * obj0 = 0 ;
40730 char *kwnames[] = {
40731 (char *) "self", NULL
40732 };
40733
40734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40736 if (SWIG_arg_fail(1)) SWIG_fail;
40737 {
40738 PyThreadState* __tstate = wxPyBeginAllowThreads();
40739 result = (int)(arg1)->GetRows();
40740
40741 wxPyEndAllowThreads(__tstate);
40742 if (PyErr_Occurred()) SWIG_fail;
40743 }
40744 {
40745 resultobj = SWIG_From_int((int)(result));
40746 }
40747 return resultobj;
40748 fail:
40749 return NULL;
40750 }
40751
40752
40753 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40754 PyObject *resultobj;
40755 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40756 int result;
40757 PyObject * obj0 = 0 ;
40758 char *kwnames[] = {
40759 (char *) "self", NULL
40760 };
40761
40762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40764 if (SWIG_arg_fail(1)) SWIG_fail;
40765 {
40766 PyThreadState* __tstate = wxPyBeginAllowThreads();
40767 result = (int)(arg1)->GetVGap();
40768
40769 wxPyEndAllowThreads(__tstate);
40770 if (PyErr_Occurred()) SWIG_fail;
40771 }
40772 {
40773 resultobj = SWIG_From_int((int)(result));
40774 }
40775 return resultobj;
40776 fail:
40777 return NULL;
40778 }
40779
40780
40781 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40782 PyObject *resultobj;
40783 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40784 int result;
40785 PyObject * obj0 = 0 ;
40786 char *kwnames[] = {
40787 (char *) "self", NULL
40788 };
40789
40790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40792 if (SWIG_arg_fail(1)) SWIG_fail;
40793 {
40794 PyThreadState* __tstate = wxPyBeginAllowThreads();
40795 result = (int)(arg1)->GetHGap();
40796
40797 wxPyEndAllowThreads(__tstate);
40798 if (PyErr_Occurred()) SWIG_fail;
40799 }
40800 {
40801 resultobj = SWIG_From_int((int)(result));
40802 }
40803 return resultobj;
40804 fail:
40805 return NULL;
40806 }
40807
40808
40809 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40810 PyObject *obj;
40811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40812 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40813 Py_INCREF(obj);
40814 return Py_BuildValue((char *)"");
40815 }
40816 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40817 PyObject *resultobj;
40818 int arg1 = (int) 1 ;
40819 int arg2 = (int) 0 ;
40820 int arg3 = (int) 0 ;
40821 int arg4 = (int) 0 ;
40822 wxFlexGridSizer *result;
40823 PyObject * obj0 = 0 ;
40824 PyObject * obj1 = 0 ;
40825 PyObject * obj2 = 0 ;
40826 PyObject * obj3 = 0 ;
40827 char *kwnames[] = {
40828 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40829 };
40830
40831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40832 if (obj0) {
40833 {
40834 arg1 = (int)(SWIG_As_int(obj0));
40835 if (SWIG_arg_fail(1)) SWIG_fail;
40836 }
40837 }
40838 if (obj1) {
40839 {
40840 arg2 = (int)(SWIG_As_int(obj1));
40841 if (SWIG_arg_fail(2)) SWIG_fail;
40842 }
40843 }
40844 if (obj2) {
40845 {
40846 arg3 = (int)(SWIG_As_int(obj2));
40847 if (SWIG_arg_fail(3)) SWIG_fail;
40848 }
40849 }
40850 if (obj3) {
40851 {
40852 arg4 = (int)(SWIG_As_int(obj3));
40853 if (SWIG_arg_fail(4)) SWIG_fail;
40854 }
40855 }
40856 {
40857 PyThreadState* __tstate = wxPyBeginAllowThreads();
40858 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40859
40860 wxPyEndAllowThreads(__tstate);
40861 if (PyErr_Occurred()) SWIG_fail;
40862 }
40863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40864 return resultobj;
40865 fail:
40866 return NULL;
40867 }
40868
40869
40870 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40871 PyObject *resultobj;
40872 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40873 size_t arg2 ;
40874 int arg3 = (int) 0 ;
40875 PyObject * obj0 = 0 ;
40876 PyObject * obj1 = 0 ;
40877 PyObject * obj2 = 0 ;
40878 char *kwnames[] = {
40879 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40880 };
40881
40882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40884 if (SWIG_arg_fail(1)) SWIG_fail;
40885 {
40886 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40887 if (SWIG_arg_fail(2)) SWIG_fail;
40888 }
40889 if (obj2) {
40890 {
40891 arg3 = (int)(SWIG_As_int(obj2));
40892 if (SWIG_arg_fail(3)) SWIG_fail;
40893 }
40894 }
40895 {
40896 PyThreadState* __tstate = wxPyBeginAllowThreads();
40897 (arg1)->AddGrowableRow(arg2,arg3);
40898
40899 wxPyEndAllowThreads(__tstate);
40900 if (PyErr_Occurred()) SWIG_fail;
40901 }
40902 Py_INCREF(Py_None); resultobj = Py_None;
40903 return resultobj;
40904 fail:
40905 return NULL;
40906 }
40907
40908
40909 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40910 PyObject *resultobj;
40911 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40912 size_t arg2 ;
40913 PyObject * obj0 = 0 ;
40914 PyObject * obj1 = 0 ;
40915 char *kwnames[] = {
40916 (char *) "self",(char *) "idx", NULL
40917 };
40918
40919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40921 if (SWIG_arg_fail(1)) SWIG_fail;
40922 {
40923 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40924 if (SWIG_arg_fail(2)) SWIG_fail;
40925 }
40926 {
40927 PyThreadState* __tstate = wxPyBeginAllowThreads();
40928 (arg1)->RemoveGrowableRow(arg2);
40929
40930 wxPyEndAllowThreads(__tstate);
40931 if (PyErr_Occurred()) SWIG_fail;
40932 }
40933 Py_INCREF(Py_None); resultobj = Py_None;
40934 return resultobj;
40935 fail:
40936 return NULL;
40937 }
40938
40939
40940 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40941 PyObject *resultobj;
40942 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40943 size_t arg2 ;
40944 int arg3 = (int) 0 ;
40945 PyObject * obj0 = 0 ;
40946 PyObject * obj1 = 0 ;
40947 PyObject * obj2 = 0 ;
40948 char *kwnames[] = {
40949 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40950 };
40951
40952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40954 if (SWIG_arg_fail(1)) SWIG_fail;
40955 {
40956 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40957 if (SWIG_arg_fail(2)) SWIG_fail;
40958 }
40959 if (obj2) {
40960 {
40961 arg3 = (int)(SWIG_As_int(obj2));
40962 if (SWIG_arg_fail(3)) SWIG_fail;
40963 }
40964 }
40965 {
40966 PyThreadState* __tstate = wxPyBeginAllowThreads();
40967 (arg1)->AddGrowableCol(arg2,arg3);
40968
40969 wxPyEndAllowThreads(__tstate);
40970 if (PyErr_Occurred()) SWIG_fail;
40971 }
40972 Py_INCREF(Py_None); resultobj = Py_None;
40973 return resultobj;
40974 fail:
40975 return NULL;
40976 }
40977
40978
40979 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40980 PyObject *resultobj;
40981 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40982 size_t arg2 ;
40983 PyObject * obj0 = 0 ;
40984 PyObject * obj1 = 0 ;
40985 char *kwnames[] = {
40986 (char *) "self",(char *) "idx", NULL
40987 };
40988
40989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40991 if (SWIG_arg_fail(1)) SWIG_fail;
40992 {
40993 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40994 if (SWIG_arg_fail(2)) SWIG_fail;
40995 }
40996 {
40997 PyThreadState* __tstate = wxPyBeginAllowThreads();
40998 (arg1)->RemoveGrowableCol(arg2);
40999
41000 wxPyEndAllowThreads(__tstate);
41001 if (PyErr_Occurred()) SWIG_fail;
41002 }
41003 Py_INCREF(Py_None); resultobj = Py_None;
41004 return resultobj;
41005 fail:
41006 return NULL;
41007 }
41008
41009
41010 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41011 PyObject *resultobj;
41012 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41013 int arg2 ;
41014 PyObject * obj0 = 0 ;
41015 PyObject * obj1 = 0 ;
41016 char *kwnames[] = {
41017 (char *) "self",(char *) "direction", NULL
41018 };
41019
41020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41022 if (SWIG_arg_fail(1)) SWIG_fail;
41023 {
41024 arg2 = (int)(SWIG_As_int(obj1));
41025 if (SWIG_arg_fail(2)) SWIG_fail;
41026 }
41027 {
41028 PyThreadState* __tstate = wxPyBeginAllowThreads();
41029 (arg1)->SetFlexibleDirection(arg2);
41030
41031 wxPyEndAllowThreads(__tstate);
41032 if (PyErr_Occurred()) SWIG_fail;
41033 }
41034 Py_INCREF(Py_None); resultobj = Py_None;
41035 return resultobj;
41036 fail:
41037 return NULL;
41038 }
41039
41040
41041 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41042 PyObject *resultobj;
41043 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41044 int result;
41045 PyObject * obj0 = 0 ;
41046 char *kwnames[] = {
41047 (char *) "self", NULL
41048 };
41049
41050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41052 if (SWIG_arg_fail(1)) SWIG_fail;
41053 {
41054 PyThreadState* __tstate = wxPyBeginAllowThreads();
41055 result = (int)(arg1)->GetFlexibleDirection();
41056
41057 wxPyEndAllowThreads(__tstate);
41058 if (PyErr_Occurred()) SWIG_fail;
41059 }
41060 {
41061 resultobj = SWIG_From_int((int)(result));
41062 }
41063 return resultobj;
41064 fail:
41065 return NULL;
41066 }
41067
41068
41069 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41070 PyObject *resultobj;
41071 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41072 wxFlexSizerGrowMode arg2 ;
41073 PyObject * obj0 = 0 ;
41074 PyObject * obj1 = 0 ;
41075 char *kwnames[] = {
41076 (char *) "self",(char *) "mode", NULL
41077 };
41078
41079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41081 if (SWIG_arg_fail(1)) SWIG_fail;
41082 {
41083 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41084 if (SWIG_arg_fail(2)) SWIG_fail;
41085 }
41086 {
41087 PyThreadState* __tstate = wxPyBeginAllowThreads();
41088 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41089
41090 wxPyEndAllowThreads(__tstate);
41091 if (PyErr_Occurred()) SWIG_fail;
41092 }
41093 Py_INCREF(Py_None); resultobj = Py_None;
41094 return resultobj;
41095 fail:
41096 return NULL;
41097 }
41098
41099
41100 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41101 PyObject *resultobj;
41102 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41103 wxFlexSizerGrowMode result;
41104 PyObject * obj0 = 0 ;
41105 char *kwnames[] = {
41106 (char *) "self", NULL
41107 };
41108
41109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41111 if (SWIG_arg_fail(1)) SWIG_fail;
41112 {
41113 PyThreadState* __tstate = wxPyBeginAllowThreads();
41114 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41115
41116 wxPyEndAllowThreads(__tstate);
41117 if (PyErr_Occurred()) SWIG_fail;
41118 }
41119 resultobj = SWIG_From_int((result));
41120 return resultobj;
41121 fail:
41122 return NULL;
41123 }
41124
41125
41126 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41127 PyObject *resultobj;
41128 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41129 wxArrayInt *result;
41130 PyObject * obj0 = 0 ;
41131 char *kwnames[] = {
41132 (char *) "self", NULL
41133 };
41134
41135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41137 if (SWIG_arg_fail(1)) SWIG_fail;
41138 {
41139 PyThreadState* __tstate = wxPyBeginAllowThreads();
41140 {
41141 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41142 result = (wxArrayInt *) &_result_ref;
41143 }
41144
41145 wxPyEndAllowThreads(__tstate);
41146 if (PyErr_Occurred()) SWIG_fail;
41147 }
41148 {
41149 resultobj = PyList_New(0);
41150 size_t idx;
41151 for (idx = 0; idx < result->GetCount(); idx += 1) {
41152 PyObject* val = PyInt_FromLong( result->Item(idx) );
41153 PyList_Append(resultobj, val);
41154 Py_DECREF(val);
41155 }
41156 }
41157 return resultobj;
41158 fail:
41159 return NULL;
41160 }
41161
41162
41163 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41164 PyObject *resultobj;
41165 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41166 wxArrayInt *result;
41167 PyObject * obj0 = 0 ;
41168 char *kwnames[] = {
41169 (char *) "self", NULL
41170 };
41171
41172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41174 if (SWIG_arg_fail(1)) SWIG_fail;
41175 {
41176 PyThreadState* __tstate = wxPyBeginAllowThreads();
41177 {
41178 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41179 result = (wxArrayInt *) &_result_ref;
41180 }
41181
41182 wxPyEndAllowThreads(__tstate);
41183 if (PyErr_Occurred()) SWIG_fail;
41184 }
41185 {
41186 resultobj = PyList_New(0);
41187 size_t idx;
41188 for (idx = 0; idx < result->GetCount(); idx += 1) {
41189 PyObject* val = PyInt_FromLong( result->Item(idx) );
41190 PyList_Append(resultobj, val);
41191 Py_DECREF(val);
41192 }
41193 }
41194 return resultobj;
41195 fail:
41196 return NULL;
41197 }
41198
41199
41200 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41201 PyObject *obj;
41202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41203 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41204 Py_INCREF(obj);
41205 return Py_BuildValue((char *)"");
41206 }
41207 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41208 PyObject *resultobj;
41209 wxStdDialogButtonSizer *result;
41210 char *kwnames[] = {
41211 NULL
41212 };
41213
41214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41215 {
41216 PyThreadState* __tstate = wxPyBeginAllowThreads();
41217 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41218
41219 wxPyEndAllowThreads(__tstate);
41220 if (PyErr_Occurred()) SWIG_fail;
41221 }
41222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41223 return resultobj;
41224 fail:
41225 return NULL;
41226 }
41227
41228
41229 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41230 PyObject *resultobj;
41231 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41232 wxButton *arg2 = (wxButton *) 0 ;
41233 PyObject * obj0 = 0 ;
41234 PyObject * obj1 = 0 ;
41235 char *kwnames[] = {
41236 (char *) "self",(char *) "button", NULL
41237 };
41238
41239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41241 if (SWIG_arg_fail(1)) SWIG_fail;
41242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41243 if (SWIG_arg_fail(2)) SWIG_fail;
41244 {
41245 PyThreadState* __tstate = wxPyBeginAllowThreads();
41246 (arg1)->AddButton(arg2);
41247
41248 wxPyEndAllowThreads(__tstate);
41249 if (PyErr_Occurred()) SWIG_fail;
41250 }
41251 Py_INCREF(Py_None); resultobj = Py_None;
41252 return resultobj;
41253 fail:
41254 return NULL;
41255 }
41256
41257
41258 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41259 PyObject *resultobj;
41260 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41261 PyObject * obj0 = 0 ;
41262 char *kwnames[] = {
41263 (char *) "self", NULL
41264 };
41265
41266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41268 if (SWIG_arg_fail(1)) SWIG_fail;
41269 {
41270 PyThreadState* __tstate = wxPyBeginAllowThreads();
41271 (arg1)->Realize();
41272
41273 wxPyEndAllowThreads(__tstate);
41274 if (PyErr_Occurred()) SWIG_fail;
41275 }
41276 Py_INCREF(Py_None); resultobj = Py_None;
41277 return resultobj;
41278 fail:
41279 return NULL;
41280 }
41281
41282
41283 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41284 PyObject *resultobj;
41285 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41286 wxButton *arg2 = (wxButton *) 0 ;
41287 PyObject * obj0 = 0 ;
41288 PyObject * obj1 = 0 ;
41289 char *kwnames[] = {
41290 (char *) "self",(char *) "button", NULL
41291 };
41292
41293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41295 if (SWIG_arg_fail(1)) SWIG_fail;
41296 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41297 if (SWIG_arg_fail(2)) SWIG_fail;
41298 {
41299 PyThreadState* __tstate = wxPyBeginAllowThreads();
41300 (arg1)->SetAffirmativeButton(arg2);
41301
41302 wxPyEndAllowThreads(__tstate);
41303 if (PyErr_Occurred()) SWIG_fail;
41304 }
41305 Py_INCREF(Py_None); resultobj = Py_None;
41306 return resultobj;
41307 fail:
41308 return NULL;
41309 }
41310
41311
41312 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41313 PyObject *resultobj;
41314 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41315 wxButton *arg2 = (wxButton *) 0 ;
41316 PyObject * obj0 = 0 ;
41317 PyObject * obj1 = 0 ;
41318 char *kwnames[] = {
41319 (char *) "self",(char *) "button", NULL
41320 };
41321
41322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41324 if (SWIG_arg_fail(1)) SWIG_fail;
41325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41326 if (SWIG_arg_fail(2)) SWIG_fail;
41327 {
41328 PyThreadState* __tstate = wxPyBeginAllowThreads();
41329 (arg1)->SetNegativeButton(arg2);
41330
41331 wxPyEndAllowThreads(__tstate);
41332 if (PyErr_Occurred()) SWIG_fail;
41333 }
41334 Py_INCREF(Py_None); resultobj = Py_None;
41335 return resultobj;
41336 fail:
41337 return NULL;
41338 }
41339
41340
41341 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41342 PyObject *resultobj;
41343 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41344 wxButton *arg2 = (wxButton *) 0 ;
41345 PyObject * obj0 = 0 ;
41346 PyObject * obj1 = 0 ;
41347 char *kwnames[] = {
41348 (char *) "self",(char *) "button", NULL
41349 };
41350
41351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41353 if (SWIG_arg_fail(1)) SWIG_fail;
41354 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41355 if (SWIG_arg_fail(2)) SWIG_fail;
41356 {
41357 PyThreadState* __tstate = wxPyBeginAllowThreads();
41358 (arg1)->SetCancelButton(arg2);
41359
41360 wxPyEndAllowThreads(__tstate);
41361 if (PyErr_Occurred()) SWIG_fail;
41362 }
41363 Py_INCREF(Py_None); resultobj = Py_None;
41364 return resultobj;
41365 fail:
41366 return NULL;
41367 }
41368
41369
41370 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41371 PyObject *resultobj;
41372 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41373 wxButton *result;
41374 PyObject * obj0 = 0 ;
41375 char *kwnames[] = {
41376 (char *) "self", NULL
41377 };
41378
41379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41381 if (SWIG_arg_fail(1)) SWIG_fail;
41382 {
41383 PyThreadState* __tstate = wxPyBeginAllowThreads();
41384 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41385
41386 wxPyEndAllowThreads(__tstate);
41387 if (PyErr_Occurred()) SWIG_fail;
41388 }
41389 {
41390 resultobj = wxPyMake_wxObject(result, 0);
41391 }
41392 return resultobj;
41393 fail:
41394 return NULL;
41395 }
41396
41397
41398 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41399 PyObject *resultobj;
41400 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41401 wxButton *result;
41402 PyObject * obj0 = 0 ;
41403 char *kwnames[] = {
41404 (char *) "self", NULL
41405 };
41406
41407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41409 if (SWIG_arg_fail(1)) SWIG_fail;
41410 {
41411 PyThreadState* __tstate = wxPyBeginAllowThreads();
41412 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41413
41414 wxPyEndAllowThreads(__tstate);
41415 if (PyErr_Occurred()) SWIG_fail;
41416 }
41417 {
41418 resultobj = wxPyMake_wxObject(result, 0);
41419 }
41420 return resultobj;
41421 fail:
41422 return NULL;
41423 }
41424
41425
41426 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41427 PyObject *resultobj;
41428 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41429 wxButton *result;
41430 PyObject * obj0 = 0 ;
41431 char *kwnames[] = {
41432 (char *) "self", NULL
41433 };
41434
41435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41437 if (SWIG_arg_fail(1)) SWIG_fail;
41438 {
41439 PyThreadState* __tstate = wxPyBeginAllowThreads();
41440 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41441
41442 wxPyEndAllowThreads(__tstate);
41443 if (PyErr_Occurred()) SWIG_fail;
41444 }
41445 {
41446 resultobj = wxPyMake_wxObject(result, 0);
41447 }
41448 return resultobj;
41449 fail:
41450 return NULL;
41451 }
41452
41453
41454 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41455 PyObject *resultobj;
41456 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41457 wxButton *result;
41458 PyObject * obj0 = 0 ;
41459 char *kwnames[] = {
41460 (char *) "self", NULL
41461 };
41462
41463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41465 if (SWIG_arg_fail(1)) SWIG_fail;
41466 {
41467 PyThreadState* __tstate = wxPyBeginAllowThreads();
41468 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41469
41470 wxPyEndAllowThreads(__tstate);
41471 if (PyErr_Occurred()) SWIG_fail;
41472 }
41473 {
41474 resultobj = wxPyMake_wxObject(result, 0);
41475 }
41476 return resultobj;
41477 fail:
41478 return NULL;
41479 }
41480
41481
41482 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41483 PyObject *resultobj;
41484 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41485 wxButton *result;
41486 PyObject * obj0 = 0 ;
41487 char *kwnames[] = {
41488 (char *) "self", NULL
41489 };
41490
41491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41493 if (SWIG_arg_fail(1)) SWIG_fail;
41494 {
41495 PyThreadState* __tstate = wxPyBeginAllowThreads();
41496 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41497
41498 wxPyEndAllowThreads(__tstate);
41499 if (PyErr_Occurred()) SWIG_fail;
41500 }
41501 {
41502 resultobj = wxPyMake_wxObject(result, 0);
41503 }
41504 return resultobj;
41505 fail:
41506 return NULL;
41507 }
41508
41509
41510 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41511 PyObject *obj;
41512 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41513 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41514 Py_INCREF(obj);
41515 return Py_BuildValue((char *)"");
41516 }
41517 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41518 PyObject *resultobj;
41519 int arg1 = (int) 0 ;
41520 int arg2 = (int) 0 ;
41521 wxGBPosition *result;
41522 PyObject * obj0 = 0 ;
41523 PyObject * obj1 = 0 ;
41524 char *kwnames[] = {
41525 (char *) "row",(char *) "col", NULL
41526 };
41527
41528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41529 if (obj0) {
41530 {
41531 arg1 = (int)(SWIG_As_int(obj0));
41532 if (SWIG_arg_fail(1)) SWIG_fail;
41533 }
41534 }
41535 if (obj1) {
41536 {
41537 arg2 = (int)(SWIG_As_int(obj1));
41538 if (SWIG_arg_fail(2)) SWIG_fail;
41539 }
41540 }
41541 {
41542 PyThreadState* __tstate = wxPyBeginAllowThreads();
41543 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41544
41545 wxPyEndAllowThreads(__tstate);
41546 if (PyErr_Occurred()) SWIG_fail;
41547 }
41548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41549 return resultobj;
41550 fail:
41551 return NULL;
41552 }
41553
41554
41555 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41556 PyObject *resultobj;
41557 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41558 int result;
41559 PyObject * obj0 = 0 ;
41560 char *kwnames[] = {
41561 (char *) "self", NULL
41562 };
41563
41564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41566 if (SWIG_arg_fail(1)) SWIG_fail;
41567 {
41568 PyThreadState* __tstate = wxPyBeginAllowThreads();
41569 result = (int)((wxGBPosition const *)arg1)->GetRow();
41570
41571 wxPyEndAllowThreads(__tstate);
41572 if (PyErr_Occurred()) SWIG_fail;
41573 }
41574 {
41575 resultobj = SWIG_From_int((int)(result));
41576 }
41577 return resultobj;
41578 fail:
41579 return NULL;
41580 }
41581
41582
41583 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41584 PyObject *resultobj;
41585 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41586 int result;
41587 PyObject * obj0 = 0 ;
41588 char *kwnames[] = {
41589 (char *) "self", NULL
41590 };
41591
41592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41594 if (SWIG_arg_fail(1)) SWIG_fail;
41595 {
41596 PyThreadState* __tstate = wxPyBeginAllowThreads();
41597 result = (int)((wxGBPosition const *)arg1)->GetCol();
41598
41599 wxPyEndAllowThreads(__tstate);
41600 if (PyErr_Occurred()) SWIG_fail;
41601 }
41602 {
41603 resultobj = SWIG_From_int((int)(result));
41604 }
41605 return resultobj;
41606 fail:
41607 return NULL;
41608 }
41609
41610
41611 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41612 PyObject *resultobj;
41613 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41614 int arg2 ;
41615 PyObject * obj0 = 0 ;
41616 PyObject * obj1 = 0 ;
41617 char *kwnames[] = {
41618 (char *) "self",(char *) "row", NULL
41619 };
41620
41621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41623 if (SWIG_arg_fail(1)) SWIG_fail;
41624 {
41625 arg2 = (int)(SWIG_As_int(obj1));
41626 if (SWIG_arg_fail(2)) SWIG_fail;
41627 }
41628 {
41629 PyThreadState* __tstate = wxPyBeginAllowThreads();
41630 (arg1)->SetRow(arg2);
41631
41632 wxPyEndAllowThreads(__tstate);
41633 if (PyErr_Occurred()) SWIG_fail;
41634 }
41635 Py_INCREF(Py_None); resultobj = Py_None;
41636 return resultobj;
41637 fail:
41638 return NULL;
41639 }
41640
41641
41642 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41643 PyObject *resultobj;
41644 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41645 int arg2 ;
41646 PyObject * obj0 = 0 ;
41647 PyObject * obj1 = 0 ;
41648 char *kwnames[] = {
41649 (char *) "self",(char *) "col", NULL
41650 };
41651
41652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41654 if (SWIG_arg_fail(1)) SWIG_fail;
41655 {
41656 arg2 = (int)(SWIG_As_int(obj1));
41657 if (SWIG_arg_fail(2)) SWIG_fail;
41658 }
41659 {
41660 PyThreadState* __tstate = wxPyBeginAllowThreads();
41661 (arg1)->SetCol(arg2);
41662
41663 wxPyEndAllowThreads(__tstate);
41664 if (PyErr_Occurred()) SWIG_fail;
41665 }
41666 Py_INCREF(Py_None); resultobj = Py_None;
41667 return resultobj;
41668 fail:
41669 return NULL;
41670 }
41671
41672
41673 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41674 PyObject *resultobj;
41675 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41676 wxGBPosition *arg2 = 0 ;
41677 bool result;
41678 wxGBPosition temp2 ;
41679 PyObject * obj0 = 0 ;
41680 PyObject * obj1 = 0 ;
41681 char *kwnames[] = {
41682 (char *) "self",(char *) "other", NULL
41683 };
41684
41685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41687 if (SWIG_arg_fail(1)) SWIG_fail;
41688 {
41689 arg2 = &temp2;
41690 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41691 }
41692 {
41693 PyThreadState* __tstate = wxPyBeginAllowThreads();
41694 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41695
41696 wxPyEndAllowThreads(__tstate);
41697 if (PyErr_Occurred()) SWIG_fail;
41698 }
41699 {
41700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41701 }
41702 return resultobj;
41703 fail:
41704 return NULL;
41705 }
41706
41707
41708 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41709 PyObject *resultobj;
41710 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41711 wxGBPosition *arg2 = 0 ;
41712 bool result;
41713 wxGBPosition temp2 ;
41714 PyObject * obj0 = 0 ;
41715 PyObject * obj1 = 0 ;
41716 char *kwnames[] = {
41717 (char *) "self",(char *) "other", NULL
41718 };
41719
41720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41722 if (SWIG_arg_fail(1)) SWIG_fail;
41723 {
41724 arg2 = &temp2;
41725 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41726 }
41727 {
41728 PyThreadState* __tstate = wxPyBeginAllowThreads();
41729 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41730
41731 wxPyEndAllowThreads(__tstate);
41732 if (PyErr_Occurred()) SWIG_fail;
41733 }
41734 {
41735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41736 }
41737 return resultobj;
41738 fail:
41739 return NULL;
41740 }
41741
41742
41743 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41744 PyObject *resultobj;
41745 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41746 int arg2 = (int) 0 ;
41747 int arg3 = (int) 0 ;
41748 PyObject * obj0 = 0 ;
41749 PyObject * obj1 = 0 ;
41750 PyObject * obj2 = 0 ;
41751 char *kwnames[] = {
41752 (char *) "self",(char *) "row",(char *) "col", NULL
41753 };
41754
41755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41757 if (SWIG_arg_fail(1)) SWIG_fail;
41758 if (obj1) {
41759 {
41760 arg2 = (int)(SWIG_As_int(obj1));
41761 if (SWIG_arg_fail(2)) SWIG_fail;
41762 }
41763 }
41764 if (obj2) {
41765 {
41766 arg3 = (int)(SWIG_As_int(obj2));
41767 if (SWIG_arg_fail(3)) SWIG_fail;
41768 }
41769 }
41770 {
41771 PyThreadState* __tstate = wxPyBeginAllowThreads();
41772 wxGBPosition_Set(arg1,arg2,arg3);
41773
41774 wxPyEndAllowThreads(__tstate);
41775 if (PyErr_Occurred()) SWIG_fail;
41776 }
41777 Py_INCREF(Py_None); resultobj = Py_None;
41778 return resultobj;
41779 fail:
41780 return NULL;
41781 }
41782
41783
41784 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41785 PyObject *resultobj;
41786 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41787 PyObject *result;
41788 PyObject * obj0 = 0 ;
41789 char *kwnames[] = {
41790 (char *) "self", NULL
41791 };
41792
41793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41795 if (SWIG_arg_fail(1)) SWIG_fail;
41796 {
41797 PyThreadState* __tstate = wxPyBeginAllowThreads();
41798 result = (PyObject *)wxGBPosition_Get(arg1);
41799
41800 wxPyEndAllowThreads(__tstate);
41801 if (PyErr_Occurred()) SWIG_fail;
41802 }
41803 resultobj = result;
41804 return resultobj;
41805 fail:
41806 return NULL;
41807 }
41808
41809
41810 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41811 PyObject *obj;
41812 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41813 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41814 Py_INCREF(obj);
41815 return Py_BuildValue((char *)"");
41816 }
41817 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41818 PyObject *resultobj;
41819 int arg1 = (int) 1 ;
41820 int arg2 = (int) 1 ;
41821 wxGBSpan *result;
41822 PyObject * obj0 = 0 ;
41823 PyObject * obj1 = 0 ;
41824 char *kwnames[] = {
41825 (char *) "rowspan",(char *) "colspan", NULL
41826 };
41827
41828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41829 if (obj0) {
41830 {
41831 arg1 = (int)(SWIG_As_int(obj0));
41832 if (SWIG_arg_fail(1)) SWIG_fail;
41833 }
41834 }
41835 if (obj1) {
41836 {
41837 arg2 = (int)(SWIG_As_int(obj1));
41838 if (SWIG_arg_fail(2)) SWIG_fail;
41839 }
41840 }
41841 {
41842 PyThreadState* __tstate = wxPyBeginAllowThreads();
41843 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41844
41845 wxPyEndAllowThreads(__tstate);
41846 if (PyErr_Occurred()) SWIG_fail;
41847 }
41848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41849 return resultobj;
41850 fail:
41851 return NULL;
41852 }
41853
41854
41855 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41856 PyObject *resultobj;
41857 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41858 int result;
41859 PyObject * obj0 = 0 ;
41860 char *kwnames[] = {
41861 (char *) "self", NULL
41862 };
41863
41864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41866 if (SWIG_arg_fail(1)) SWIG_fail;
41867 {
41868 PyThreadState* __tstate = wxPyBeginAllowThreads();
41869 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41870
41871 wxPyEndAllowThreads(__tstate);
41872 if (PyErr_Occurred()) SWIG_fail;
41873 }
41874 {
41875 resultobj = SWIG_From_int((int)(result));
41876 }
41877 return resultobj;
41878 fail:
41879 return NULL;
41880 }
41881
41882
41883 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41884 PyObject *resultobj;
41885 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41886 int result;
41887 PyObject * obj0 = 0 ;
41888 char *kwnames[] = {
41889 (char *) "self", NULL
41890 };
41891
41892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41894 if (SWIG_arg_fail(1)) SWIG_fail;
41895 {
41896 PyThreadState* __tstate = wxPyBeginAllowThreads();
41897 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41898
41899 wxPyEndAllowThreads(__tstate);
41900 if (PyErr_Occurred()) SWIG_fail;
41901 }
41902 {
41903 resultobj = SWIG_From_int((int)(result));
41904 }
41905 return resultobj;
41906 fail:
41907 return NULL;
41908 }
41909
41910
41911 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41912 PyObject *resultobj;
41913 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41914 int arg2 ;
41915 PyObject * obj0 = 0 ;
41916 PyObject * obj1 = 0 ;
41917 char *kwnames[] = {
41918 (char *) "self",(char *) "rowspan", NULL
41919 };
41920
41921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41923 if (SWIG_arg_fail(1)) SWIG_fail;
41924 {
41925 arg2 = (int)(SWIG_As_int(obj1));
41926 if (SWIG_arg_fail(2)) SWIG_fail;
41927 }
41928 {
41929 PyThreadState* __tstate = wxPyBeginAllowThreads();
41930 (arg1)->SetRowspan(arg2);
41931
41932 wxPyEndAllowThreads(__tstate);
41933 if (PyErr_Occurred()) SWIG_fail;
41934 }
41935 Py_INCREF(Py_None); resultobj = Py_None;
41936 return resultobj;
41937 fail:
41938 return NULL;
41939 }
41940
41941
41942 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41943 PyObject *resultobj;
41944 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41945 int arg2 ;
41946 PyObject * obj0 = 0 ;
41947 PyObject * obj1 = 0 ;
41948 char *kwnames[] = {
41949 (char *) "self",(char *) "colspan", NULL
41950 };
41951
41952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41954 if (SWIG_arg_fail(1)) SWIG_fail;
41955 {
41956 arg2 = (int)(SWIG_As_int(obj1));
41957 if (SWIG_arg_fail(2)) SWIG_fail;
41958 }
41959 {
41960 PyThreadState* __tstate = wxPyBeginAllowThreads();
41961 (arg1)->SetColspan(arg2);
41962
41963 wxPyEndAllowThreads(__tstate);
41964 if (PyErr_Occurred()) SWIG_fail;
41965 }
41966 Py_INCREF(Py_None); resultobj = Py_None;
41967 return resultobj;
41968 fail:
41969 return NULL;
41970 }
41971
41972
41973 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41974 PyObject *resultobj;
41975 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41976 wxGBSpan *arg2 = 0 ;
41977 bool result;
41978 wxGBSpan temp2 ;
41979 PyObject * obj0 = 0 ;
41980 PyObject * obj1 = 0 ;
41981 char *kwnames[] = {
41982 (char *) "self",(char *) "other", NULL
41983 };
41984
41985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41987 if (SWIG_arg_fail(1)) SWIG_fail;
41988 {
41989 arg2 = &temp2;
41990 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41991 }
41992 {
41993 PyThreadState* __tstate = wxPyBeginAllowThreads();
41994 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41995
41996 wxPyEndAllowThreads(__tstate);
41997 if (PyErr_Occurred()) SWIG_fail;
41998 }
41999 {
42000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42001 }
42002 return resultobj;
42003 fail:
42004 return NULL;
42005 }
42006
42007
42008 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42009 PyObject *resultobj;
42010 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42011 wxGBSpan *arg2 = 0 ;
42012 bool result;
42013 wxGBSpan temp2 ;
42014 PyObject * obj0 = 0 ;
42015 PyObject * obj1 = 0 ;
42016 char *kwnames[] = {
42017 (char *) "self",(char *) "other", NULL
42018 };
42019
42020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42022 if (SWIG_arg_fail(1)) SWIG_fail;
42023 {
42024 arg2 = &temp2;
42025 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42026 }
42027 {
42028 PyThreadState* __tstate = wxPyBeginAllowThreads();
42029 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42030
42031 wxPyEndAllowThreads(__tstate);
42032 if (PyErr_Occurred()) SWIG_fail;
42033 }
42034 {
42035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42036 }
42037 return resultobj;
42038 fail:
42039 return NULL;
42040 }
42041
42042
42043 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42044 PyObject *resultobj;
42045 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42046 int arg2 = (int) 1 ;
42047 int arg3 = (int) 1 ;
42048 PyObject * obj0 = 0 ;
42049 PyObject * obj1 = 0 ;
42050 PyObject * obj2 = 0 ;
42051 char *kwnames[] = {
42052 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42053 };
42054
42055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42057 if (SWIG_arg_fail(1)) SWIG_fail;
42058 if (obj1) {
42059 {
42060 arg2 = (int)(SWIG_As_int(obj1));
42061 if (SWIG_arg_fail(2)) SWIG_fail;
42062 }
42063 }
42064 if (obj2) {
42065 {
42066 arg3 = (int)(SWIG_As_int(obj2));
42067 if (SWIG_arg_fail(3)) SWIG_fail;
42068 }
42069 }
42070 {
42071 PyThreadState* __tstate = wxPyBeginAllowThreads();
42072 wxGBSpan_Set(arg1,arg2,arg3);
42073
42074 wxPyEndAllowThreads(__tstate);
42075 if (PyErr_Occurred()) SWIG_fail;
42076 }
42077 Py_INCREF(Py_None); resultobj = Py_None;
42078 return resultobj;
42079 fail:
42080 return NULL;
42081 }
42082
42083
42084 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42085 PyObject *resultobj;
42086 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42087 PyObject *result;
42088 PyObject * obj0 = 0 ;
42089 char *kwnames[] = {
42090 (char *) "self", NULL
42091 };
42092
42093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42095 if (SWIG_arg_fail(1)) SWIG_fail;
42096 {
42097 PyThreadState* __tstate = wxPyBeginAllowThreads();
42098 result = (PyObject *)wxGBSpan_Get(arg1);
42099
42100 wxPyEndAllowThreads(__tstate);
42101 if (PyErr_Occurred()) SWIG_fail;
42102 }
42103 resultobj = result;
42104 return resultobj;
42105 fail:
42106 return NULL;
42107 }
42108
42109
42110 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42111 PyObject *obj;
42112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42113 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42114 Py_INCREF(obj);
42115 return Py_BuildValue((char *)"");
42116 }
42117 static int _wrap_DefaultSpan_set(PyObject *) {
42118 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42119 return 1;
42120 }
42121
42122
42123 static PyObject *_wrap_DefaultSpan_get(void) {
42124 PyObject *pyobj;
42125
42126 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42127 return pyobj;
42128 }
42129
42130
42131 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42132 PyObject *resultobj;
42133 wxGBSizerItem *result;
42134 char *kwnames[] = {
42135 NULL
42136 };
42137
42138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42139 {
42140 PyThreadState* __tstate = wxPyBeginAllowThreads();
42141 result = (wxGBSizerItem *)new wxGBSizerItem();
42142
42143 wxPyEndAllowThreads(__tstate);
42144 if (PyErr_Occurred()) SWIG_fail;
42145 }
42146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42147 return resultobj;
42148 fail:
42149 return NULL;
42150 }
42151
42152
42153 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42154 PyObject *resultobj;
42155 wxWindow *arg1 = (wxWindow *) 0 ;
42156 wxGBPosition *arg2 = 0 ;
42157 wxGBSpan *arg3 = 0 ;
42158 int arg4 ;
42159 int arg5 ;
42160 PyObject *arg6 = (PyObject *) NULL ;
42161 wxGBSizerItem *result;
42162 wxGBPosition temp2 ;
42163 wxGBSpan temp3 ;
42164 PyObject * obj0 = 0 ;
42165 PyObject * obj1 = 0 ;
42166 PyObject * obj2 = 0 ;
42167 PyObject * obj3 = 0 ;
42168 PyObject * obj4 = 0 ;
42169 PyObject * obj5 = 0 ;
42170 char *kwnames[] = {
42171 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42172 };
42173
42174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42176 if (SWIG_arg_fail(1)) SWIG_fail;
42177 {
42178 arg2 = &temp2;
42179 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42180 }
42181 {
42182 arg3 = &temp3;
42183 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42184 }
42185 {
42186 arg4 = (int)(SWIG_As_int(obj3));
42187 if (SWIG_arg_fail(4)) SWIG_fail;
42188 }
42189 {
42190 arg5 = (int)(SWIG_As_int(obj4));
42191 if (SWIG_arg_fail(5)) SWIG_fail;
42192 }
42193 if (obj5) {
42194 arg6 = obj5;
42195 }
42196 {
42197 PyThreadState* __tstate = wxPyBeginAllowThreads();
42198 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42199
42200 wxPyEndAllowThreads(__tstate);
42201 if (PyErr_Occurred()) SWIG_fail;
42202 }
42203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42204 return resultobj;
42205 fail:
42206 return NULL;
42207 }
42208
42209
42210 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42211 PyObject *resultobj;
42212 wxSizer *arg1 = (wxSizer *) 0 ;
42213 wxGBPosition *arg2 = 0 ;
42214 wxGBSpan *arg3 = 0 ;
42215 int arg4 ;
42216 int arg5 ;
42217 PyObject *arg6 = (PyObject *) NULL ;
42218 wxGBSizerItem *result;
42219 wxGBPosition temp2 ;
42220 wxGBSpan temp3 ;
42221 PyObject * obj0 = 0 ;
42222 PyObject * obj1 = 0 ;
42223 PyObject * obj2 = 0 ;
42224 PyObject * obj3 = 0 ;
42225 PyObject * obj4 = 0 ;
42226 PyObject * obj5 = 0 ;
42227 char *kwnames[] = {
42228 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42229 };
42230
42231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42233 if (SWIG_arg_fail(1)) SWIG_fail;
42234 {
42235 arg2 = &temp2;
42236 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42237 }
42238 {
42239 arg3 = &temp3;
42240 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42241 }
42242 {
42243 arg4 = (int)(SWIG_As_int(obj3));
42244 if (SWIG_arg_fail(4)) SWIG_fail;
42245 }
42246 {
42247 arg5 = (int)(SWIG_As_int(obj4));
42248 if (SWIG_arg_fail(5)) SWIG_fail;
42249 }
42250 if (obj5) {
42251 arg6 = obj5;
42252 }
42253 {
42254 PyThreadState* __tstate = wxPyBeginAllowThreads();
42255 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42256
42257 wxPyEndAllowThreads(__tstate);
42258 if (PyErr_Occurred()) SWIG_fail;
42259 }
42260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42261 return resultobj;
42262 fail:
42263 return NULL;
42264 }
42265
42266
42267 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42268 PyObject *resultobj;
42269 int arg1 ;
42270 int arg2 ;
42271 wxGBPosition *arg3 = 0 ;
42272 wxGBSpan *arg4 = 0 ;
42273 int arg5 ;
42274 int arg6 ;
42275 PyObject *arg7 = (PyObject *) NULL ;
42276 wxGBSizerItem *result;
42277 wxGBPosition temp3 ;
42278 wxGBSpan temp4 ;
42279 PyObject * obj0 = 0 ;
42280 PyObject * obj1 = 0 ;
42281 PyObject * obj2 = 0 ;
42282 PyObject * obj3 = 0 ;
42283 PyObject * obj4 = 0 ;
42284 PyObject * obj5 = 0 ;
42285 PyObject * obj6 = 0 ;
42286 char *kwnames[] = {
42287 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42288 };
42289
42290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42291 {
42292 arg1 = (int)(SWIG_As_int(obj0));
42293 if (SWIG_arg_fail(1)) SWIG_fail;
42294 }
42295 {
42296 arg2 = (int)(SWIG_As_int(obj1));
42297 if (SWIG_arg_fail(2)) SWIG_fail;
42298 }
42299 {
42300 arg3 = &temp3;
42301 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42302 }
42303 {
42304 arg4 = &temp4;
42305 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42306 }
42307 {
42308 arg5 = (int)(SWIG_As_int(obj4));
42309 if (SWIG_arg_fail(5)) SWIG_fail;
42310 }
42311 {
42312 arg6 = (int)(SWIG_As_int(obj5));
42313 if (SWIG_arg_fail(6)) SWIG_fail;
42314 }
42315 if (obj6) {
42316 arg7 = obj6;
42317 }
42318 {
42319 PyThreadState* __tstate = wxPyBeginAllowThreads();
42320 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42321
42322 wxPyEndAllowThreads(__tstate);
42323 if (PyErr_Occurred()) SWIG_fail;
42324 }
42325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42326 return resultobj;
42327 fail:
42328 return NULL;
42329 }
42330
42331
42332 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42333 PyObject *resultobj;
42334 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42335 wxGBPosition result;
42336 PyObject * obj0 = 0 ;
42337 char *kwnames[] = {
42338 (char *) "self", NULL
42339 };
42340
42341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42343 if (SWIG_arg_fail(1)) SWIG_fail;
42344 {
42345 PyThreadState* __tstate = wxPyBeginAllowThreads();
42346 result = ((wxGBSizerItem const *)arg1)->GetPos();
42347
42348 wxPyEndAllowThreads(__tstate);
42349 if (PyErr_Occurred()) SWIG_fail;
42350 }
42351 {
42352 wxGBPosition * resultptr;
42353 resultptr = new wxGBPosition((wxGBPosition &)(result));
42354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42355 }
42356 return resultobj;
42357 fail:
42358 return NULL;
42359 }
42360
42361
42362 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42363 PyObject *resultobj;
42364 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42365 wxGBSpan result;
42366 PyObject * obj0 = 0 ;
42367 char *kwnames[] = {
42368 (char *) "self", NULL
42369 };
42370
42371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42373 if (SWIG_arg_fail(1)) SWIG_fail;
42374 {
42375 PyThreadState* __tstate = wxPyBeginAllowThreads();
42376 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42377
42378 wxPyEndAllowThreads(__tstate);
42379 if (PyErr_Occurred()) SWIG_fail;
42380 }
42381 {
42382 wxGBSpan * resultptr;
42383 resultptr = new wxGBSpan((wxGBSpan &)(result));
42384 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42385 }
42386 return resultobj;
42387 fail:
42388 return NULL;
42389 }
42390
42391
42392 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42393 PyObject *resultobj;
42394 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42395 wxGBPosition *arg2 = 0 ;
42396 bool result;
42397 wxGBPosition temp2 ;
42398 PyObject * obj0 = 0 ;
42399 PyObject * obj1 = 0 ;
42400 char *kwnames[] = {
42401 (char *) "self",(char *) "pos", NULL
42402 };
42403
42404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42406 if (SWIG_arg_fail(1)) SWIG_fail;
42407 {
42408 arg2 = &temp2;
42409 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42410 }
42411 {
42412 PyThreadState* __tstate = wxPyBeginAllowThreads();
42413 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42414
42415 wxPyEndAllowThreads(__tstate);
42416 if (PyErr_Occurred()) SWIG_fail;
42417 }
42418 {
42419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42420 }
42421 return resultobj;
42422 fail:
42423 return NULL;
42424 }
42425
42426
42427 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42428 PyObject *resultobj;
42429 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42430 wxGBSpan *arg2 = 0 ;
42431 bool result;
42432 wxGBSpan temp2 ;
42433 PyObject * obj0 = 0 ;
42434 PyObject * obj1 = 0 ;
42435 char *kwnames[] = {
42436 (char *) "self",(char *) "span", NULL
42437 };
42438
42439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42441 if (SWIG_arg_fail(1)) SWIG_fail;
42442 {
42443 arg2 = &temp2;
42444 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42445 }
42446 {
42447 PyThreadState* __tstate = wxPyBeginAllowThreads();
42448 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42449
42450 wxPyEndAllowThreads(__tstate);
42451 if (PyErr_Occurred()) SWIG_fail;
42452 }
42453 {
42454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42455 }
42456 return resultobj;
42457 fail:
42458 return NULL;
42459 }
42460
42461
42462 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42463 PyObject *resultobj;
42464 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42465 wxGBSizerItem *arg2 = 0 ;
42466 bool result;
42467 PyObject * obj0 = 0 ;
42468 PyObject * obj1 = 0 ;
42469 char *kwnames[] = {
42470 (char *) "self",(char *) "other", NULL
42471 };
42472
42473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42475 if (SWIG_arg_fail(1)) SWIG_fail;
42476 {
42477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42478 if (SWIG_arg_fail(2)) SWIG_fail;
42479 if (arg2 == NULL) {
42480 SWIG_null_ref("wxGBSizerItem");
42481 }
42482 if (SWIG_arg_fail(2)) SWIG_fail;
42483 }
42484 {
42485 PyThreadState* __tstate = wxPyBeginAllowThreads();
42486 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42487
42488 wxPyEndAllowThreads(__tstate);
42489 if (PyErr_Occurred()) SWIG_fail;
42490 }
42491 {
42492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42493 }
42494 return resultobj;
42495 fail:
42496 return NULL;
42497 }
42498
42499
42500 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42501 PyObject *resultobj;
42502 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42503 wxGBPosition *arg2 = 0 ;
42504 wxGBSpan *arg3 = 0 ;
42505 bool result;
42506 wxGBPosition temp2 ;
42507 wxGBSpan temp3 ;
42508 PyObject * obj0 = 0 ;
42509 PyObject * obj1 = 0 ;
42510 PyObject * obj2 = 0 ;
42511 char *kwnames[] = {
42512 (char *) "self",(char *) "pos",(char *) "span", NULL
42513 };
42514
42515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42517 if (SWIG_arg_fail(1)) SWIG_fail;
42518 {
42519 arg2 = &temp2;
42520 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42521 }
42522 {
42523 arg3 = &temp3;
42524 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42525 }
42526 {
42527 PyThreadState* __tstate = wxPyBeginAllowThreads();
42528 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42529
42530 wxPyEndAllowThreads(__tstate);
42531 if (PyErr_Occurred()) SWIG_fail;
42532 }
42533 {
42534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42535 }
42536 return resultobj;
42537 fail:
42538 return NULL;
42539 }
42540
42541
42542 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42543 PyObject *resultobj;
42544 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42545 wxGBPosition result;
42546 PyObject * obj0 = 0 ;
42547 char *kwnames[] = {
42548 (char *) "self", NULL
42549 };
42550
42551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42553 if (SWIG_arg_fail(1)) SWIG_fail;
42554 {
42555 PyThreadState* __tstate = wxPyBeginAllowThreads();
42556 result = wxGBSizerItem_GetEndPos(arg1);
42557
42558 wxPyEndAllowThreads(__tstate);
42559 if (PyErr_Occurred()) SWIG_fail;
42560 }
42561 {
42562 wxGBPosition * resultptr;
42563 resultptr = new wxGBPosition((wxGBPosition &)(result));
42564 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42565 }
42566 return resultobj;
42567 fail:
42568 return NULL;
42569 }
42570
42571
42572 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42573 PyObject *resultobj;
42574 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42575 wxGridBagSizer *result;
42576 PyObject * obj0 = 0 ;
42577 char *kwnames[] = {
42578 (char *) "self", NULL
42579 };
42580
42581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42583 if (SWIG_arg_fail(1)) SWIG_fail;
42584 {
42585 PyThreadState* __tstate = wxPyBeginAllowThreads();
42586 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42587
42588 wxPyEndAllowThreads(__tstate);
42589 if (PyErr_Occurred()) SWIG_fail;
42590 }
42591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42592 return resultobj;
42593 fail:
42594 return NULL;
42595 }
42596
42597
42598 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42599 PyObject *resultobj;
42600 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42601 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42602 PyObject * obj0 = 0 ;
42603 PyObject * obj1 = 0 ;
42604 char *kwnames[] = {
42605 (char *) "self",(char *) "sizer", NULL
42606 };
42607
42608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42610 if (SWIG_arg_fail(1)) SWIG_fail;
42611 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42612 if (SWIG_arg_fail(2)) SWIG_fail;
42613 {
42614 PyThreadState* __tstate = wxPyBeginAllowThreads();
42615 (arg1)->SetGBSizer(arg2);
42616
42617 wxPyEndAllowThreads(__tstate);
42618 if (PyErr_Occurred()) SWIG_fail;
42619 }
42620 Py_INCREF(Py_None); resultobj = Py_None;
42621 return resultobj;
42622 fail:
42623 return NULL;
42624 }
42625
42626
42627 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42628 PyObject *obj;
42629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42630 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42631 Py_INCREF(obj);
42632 return Py_BuildValue((char *)"");
42633 }
42634 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42635 PyObject *resultobj;
42636 int arg1 = (int) 0 ;
42637 int arg2 = (int) 0 ;
42638 wxGridBagSizer *result;
42639 PyObject * obj0 = 0 ;
42640 PyObject * obj1 = 0 ;
42641 char *kwnames[] = {
42642 (char *) "vgap",(char *) "hgap", NULL
42643 };
42644
42645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42646 if (obj0) {
42647 {
42648 arg1 = (int)(SWIG_As_int(obj0));
42649 if (SWIG_arg_fail(1)) SWIG_fail;
42650 }
42651 }
42652 if (obj1) {
42653 {
42654 arg2 = (int)(SWIG_As_int(obj1));
42655 if (SWIG_arg_fail(2)) SWIG_fail;
42656 }
42657 }
42658 {
42659 PyThreadState* __tstate = wxPyBeginAllowThreads();
42660 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42661
42662 wxPyEndAllowThreads(__tstate);
42663 if (PyErr_Occurred()) SWIG_fail;
42664 }
42665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42666 return resultobj;
42667 fail:
42668 return NULL;
42669 }
42670
42671
42672 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42673 PyObject *resultobj;
42674 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42675 PyObject *arg2 = (PyObject *) 0 ;
42676 wxGBPosition *arg3 = 0 ;
42677 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42678 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42679 int arg5 = (int) 0 ;
42680 int arg6 = (int) 0 ;
42681 PyObject *arg7 = (PyObject *) NULL ;
42682 wxGBSizerItem *result;
42683 wxGBPosition temp3 ;
42684 wxGBSpan temp4 ;
42685 PyObject * obj0 = 0 ;
42686 PyObject * obj1 = 0 ;
42687 PyObject * obj2 = 0 ;
42688 PyObject * obj3 = 0 ;
42689 PyObject * obj4 = 0 ;
42690 PyObject * obj5 = 0 ;
42691 PyObject * obj6 = 0 ;
42692 char *kwnames[] = {
42693 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42694 };
42695
42696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42698 if (SWIG_arg_fail(1)) SWIG_fail;
42699 arg2 = obj1;
42700 {
42701 arg3 = &temp3;
42702 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42703 }
42704 if (obj3) {
42705 {
42706 arg4 = &temp4;
42707 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42708 }
42709 }
42710 if (obj4) {
42711 {
42712 arg5 = (int)(SWIG_As_int(obj4));
42713 if (SWIG_arg_fail(5)) SWIG_fail;
42714 }
42715 }
42716 if (obj5) {
42717 {
42718 arg6 = (int)(SWIG_As_int(obj5));
42719 if (SWIG_arg_fail(6)) SWIG_fail;
42720 }
42721 }
42722 if (obj6) {
42723 arg7 = obj6;
42724 }
42725 {
42726 PyThreadState* __tstate = wxPyBeginAllowThreads();
42727 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42728
42729 wxPyEndAllowThreads(__tstate);
42730 if (PyErr_Occurred()) SWIG_fail;
42731 }
42732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42733 return resultobj;
42734 fail:
42735 return NULL;
42736 }
42737
42738
42739 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42740 PyObject *resultobj;
42741 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42742 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42743 wxGBSizerItem *result;
42744 PyObject * obj0 = 0 ;
42745 PyObject * obj1 = 0 ;
42746 char *kwnames[] = {
42747 (char *) "self",(char *) "item", NULL
42748 };
42749
42750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42752 if (SWIG_arg_fail(1)) SWIG_fail;
42753 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42754 if (SWIG_arg_fail(2)) SWIG_fail;
42755 {
42756 PyThreadState* __tstate = wxPyBeginAllowThreads();
42757 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42758
42759 wxPyEndAllowThreads(__tstate);
42760 if (PyErr_Occurred()) SWIG_fail;
42761 }
42762 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42763 return resultobj;
42764 fail:
42765 return NULL;
42766 }
42767
42768
42769 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42770 PyObject *resultobj;
42771 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42772 int arg2 ;
42773 int arg3 ;
42774 wxSize result;
42775 PyObject * obj0 = 0 ;
42776 PyObject * obj1 = 0 ;
42777 PyObject * obj2 = 0 ;
42778 char *kwnames[] = {
42779 (char *) "self",(char *) "row",(char *) "col", NULL
42780 };
42781
42782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42784 if (SWIG_arg_fail(1)) SWIG_fail;
42785 {
42786 arg2 = (int)(SWIG_As_int(obj1));
42787 if (SWIG_arg_fail(2)) SWIG_fail;
42788 }
42789 {
42790 arg3 = (int)(SWIG_As_int(obj2));
42791 if (SWIG_arg_fail(3)) SWIG_fail;
42792 }
42793 {
42794 PyThreadState* __tstate = wxPyBeginAllowThreads();
42795 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42796
42797 wxPyEndAllowThreads(__tstate);
42798 if (PyErr_Occurred()) SWIG_fail;
42799 }
42800 {
42801 wxSize * resultptr;
42802 resultptr = new wxSize((wxSize &)(result));
42803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42804 }
42805 return resultobj;
42806 fail:
42807 return NULL;
42808 }
42809
42810
42811 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42812 PyObject *resultobj;
42813 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42814 wxSize result;
42815 PyObject * obj0 = 0 ;
42816 char *kwnames[] = {
42817 (char *) "self", NULL
42818 };
42819
42820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42822 if (SWIG_arg_fail(1)) SWIG_fail;
42823 {
42824 PyThreadState* __tstate = wxPyBeginAllowThreads();
42825 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42826
42827 wxPyEndAllowThreads(__tstate);
42828 if (PyErr_Occurred()) SWIG_fail;
42829 }
42830 {
42831 wxSize * resultptr;
42832 resultptr = new wxSize((wxSize &)(result));
42833 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42834 }
42835 return resultobj;
42836 fail:
42837 return NULL;
42838 }
42839
42840
42841 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42842 PyObject *resultobj;
42843 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42844 wxSize *arg2 = 0 ;
42845 wxSize temp2 ;
42846 PyObject * obj0 = 0 ;
42847 PyObject * obj1 = 0 ;
42848 char *kwnames[] = {
42849 (char *) "self",(char *) "sz", NULL
42850 };
42851
42852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42854 if (SWIG_arg_fail(1)) SWIG_fail;
42855 {
42856 arg2 = &temp2;
42857 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42858 }
42859 {
42860 PyThreadState* __tstate = wxPyBeginAllowThreads();
42861 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42862
42863 wxPyEndAllowThreads(__tstate);
42864 if (PyErr_Occurred()) SWIG_fail;
42865 }
42866 Py_INCREF(Py_None); resultobj = Py_None;
42867 return resultobj;
42868 fail:
42869 return NULL;
42870 }
42871
42872
42873 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42874 PyObject *resultobj;
42875 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42876 wxWindow *arg2 = (wxWindow *) 0 ;
42877 wxGBPosition result;
42878 PyObject * obj0 = 0 ;
42879 PyObject * obj1 = 0 ;
42880
42881 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42883 if (SWIG_arg_fail(1)) SWIG_fail;
42884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42885 if (SWIG_arg_fail(2)) SWIG_fail;
42886 {
42887 PyThreadState* __tstate = wxPyBeginAllowThreads();
42888 result = (arg1)->GetItemPosition(arg2);
42889
42890 wxPyEndAllowThreads(__tstate);
42891 if (PyErr_Occurred()) SWIG_fail;
42892 }
42893 {
42894 wxGBPosition * resultptr;
42895 resultptr = new wxGBPosition((wxGBPosition &)(result));
42896 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42897 }
42898 return resultobj;
42899 fail:
42900 return NULL;
42901 }
42902
42903
42904 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42905 PyObject *resultobj;
42906 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42907 wxSizer *arg2 = (wxSizer *) 0 ;
42908 wxGBPosition result;
42909 PyObject * obj0 = 0 ;
42910 PyObject * obj1 = 0 ;
42911
42912 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42914 if (SWIG_arg_fail(1)) SWIG_fail;
42915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42916 if (SWIG_arg_fail(2)) SWIG_fail;
42917 {
42918 PyThreadState* __tstate = wxPyBeginAllowThreads();
42919 result = (arg1)->GetItemPosition(arg2);
42920
42921 wxPyEndAllowThreads(__tstate);
42922 if (PyErr_Occurred()) SWIG_fail;
42923 }
42924 {
42925 wxGBPosition * resultptr;
42926 resultptr = new wxGBPosition((wxGBPosition &)(result));
42927 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42928 }
42929 return resultobj;
42930 fail:
42931 return NULL;
42932 }
42933
42934
42935 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42936 PyObject *resultobj;
42937 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42938 size_t arg2 ;
42939 wxGBPosition result;
42940 PyObject * obj0 = 0 ;
42941 PyObject * obj1 = 0 ;
42942
42943 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42945 if (SWIG_arg_fail(1)) SWIG_fail;
42946 {
42947 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42948 if (SWIG_arg_fail(2)) SWIG_fail;
42949 }
42950 {
42951 PyThreadState* __tstate = wxPyBeginAllowThreads();
42952 result = (arg1)->GetItemPosition(arg2);
42953
42954 wxPyEndAllowThreads(__tstate);
42955 if (PyErr_Occurred()) SWIG_fail;
42956 }
42957 {
42958 wxGBPosition * resultptr;
42959 resultptr = new wxGBPosition((wxGBPosition &)(result));
42960 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42961 }
42962 return resultobj;
42963 fail:
42964 return NULL;
42965 }
42966
42967
42968 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42969 int argc;
42970 PyObject *argv[3];
42971 int ii;
42972
42973 argc = PyObject_Length(args);
42974 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42975 argv[ii] = PyTuple_GetItem(args,ii);
42976 }
42977 if (argc == 2) {
42978 int _v;
42979 {
42980 void *ptr;
42981 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42982 _v = 0;
42983 PyErr_Clear();
42984 } else {
42985 _v = 1;
42986 }
42987 }
42988 if (_v) {
42989 {
42990 void *ptr;
42991 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42992 _v = 0;
42993 PyErr_Clear();
42994 } else {
42995 _v = 1;
42996 }
42997 }
42998 if (_v) {
42999 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43000 }
43001 }
43002 }
43003 if (argc == 2) {
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 {
43016 void *ptr;
43017 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43018 _v = 0;
43019 PyErr_Clear();
43020 } else {
43021 _v = 1;
43022 }
43023 }
43024 if (_v) {
43025 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43026 }
43027 }
43028 }
43029 if (argc == 2) {
43030 int _v;
43031 {
43032 void *ptr;
43033 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43034 _v = 0;
43035 PyErr_Clear();
43036 } else {
43037 _v = 1;
43038 }
43039 }
43040 if (_v) {
43041 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43042 if (_v) {
43043 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43044 }
43045 }
43046 }
43047
43048 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43049 return NULL;
43050 }
43051
43052
43053 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43054 PyObject *resultobj;
43055 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43056 wxWindow *arg2 = (wxWindow *) 0 ;
43057 wxGBPosition *arg3 = 0 ;
43058 bool result;
43059 wxGBPosition temp3 ;
43060 PyObject * obj0 = 0 ;
43061 PyObject * obj1 = 0 ;
43062 PyObject * obj2 = 0 ;
43063
43064 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43066 if (SWIG_arg_fail(1)) SWIG_fail;
43067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43068 if (SWIG_arg_fail(2)) SWIG_fail;
43069 {
43070 arg3 = &temp3;
43071 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43072 }
43073 {
43074 PyThreadState* __tstate = wxPyBeginAllowThreads();
43075 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43076
43077 wxPyEndAllowThreads(__tstate);
43078 if (PyErr_Occurred()) SWIG_fail;
43079 }
43080 {
43081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43082 }
43083 return resultobj;
43084 fail:
43085 return NULL;
43086 }
43087
43088
43089 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43090 PyObject *resultobj;
43091 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43092 wxSizer *arg2 = (wxSizer *) 0 ;
43093 wxGBPosition *arg3 = 0 ;
43094 bool result;
43095 wxGBPosition temp3 ;
43096 PyObject * obj0 = 0 ;
43097 PyObject * obj1 = 0 ;
43098 PyObject * obj2 = 0 ;
43099
43100 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43102 if (SWIG_arg_fail(1)) SWIG_fail;
43103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43104 if (SWIG_arg_fail(2)) SWIG_fail;
43105 {
43106 arg3 = &temp3;
43107 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43108 }
43109 {
43110 PyThreadState* __tstate = wxPyBeginAllowThreads();
43111 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43112
43113 wxPyEndAllowThreads(__tstate);
43114 if (PyErr_Occurred()) SWIG_fail;
43115 }
43116 {
43117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43118 }
43119 return resultobj;
43120 fail:
43121 return NULL;
43122 }
43123
43124
43125 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43126 PyObject *resultobj;
43127 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43128 size_t arg2 ;
43129 wxGBPosition *arg3 = 0 ;
43130 bool result;
43131 wxGBPosition temp3 ;
43132 PyObject * obj0 = 0 ;
43133 PyObject * obj1 = 0 ;
43134 PyObject * obj2 = 0 ;
43135
43136 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43138 if (SWIG_arg_fail(1)) SWIG_fail;
43139 {
43140 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43141 if (SWIG_arg_fail(2)) SWIG_fail;
43142 }
43143 {
43144 arg3 = &temp3;
43145 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43146 }
43147 {
43148 PyThreadState* __tstate = wxPyBeginAllowThreads();
43149 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43150
43151 wxPyEndAllowThreads(__tstate);
43152 if (PyErr_Occurred()) SWIG_fail;
43153 }
43154 {
43155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43156 }
43157 return resultobj;
43158 fail:
43159 return NULL;
43160 }
43161
43162
43163 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43164 int argc;
43165 PyObject *argv[4];
43166 int ii;
43167
43168 argc = PyObject_Length(args);
43169 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43170 argv[ii] = PyTuple_GetItem(args,ii);
43171 }
43172 if (argc == 3) {
43173 int _v;
43174 {
43175 void *ptr;
43176 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43177 _v = 0;
43178 PyErr_Clear();
43179 } else {
43180 _v = 1;
43181 }
43182 }
43183 if (_v) {
43184 {
43185 void *ptr;
43186 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43187 _v = 0;
43188 PyErr_Clear();
43189 } else {
43190 _v = 1;
43191 }
43192 }
43193 if (_v) {
43194 {
43195 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43196 }
43197 if (_v) {
43198 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43199 }
43200 }
43201 }
43202 }
43203 if (argc == 3) {
43204 int _v;
43205 {
43206 void *ptr;
43207 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43208 _v = 0;
43209 PyErr_Clear();
43210 } else {
43211 _v = 1;
43212 }
43213 }
43214 if (_v) {
43215 {
43216 void *ptr;
43217 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43218 _v = 0;
43219 PyErr_Clear();
43220 } else {
43221 _v = 1;
43222 }
43223 }
43224 if (_v) {
43225 {
43226 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43227 }
43228 if (_v) {
43229 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43230 }
43231 }
43232 }
43233 }
43234 if (argc == 3) {
43235 int _v;
43236 {
43237 void *ptr;
43238 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43239 _v = 0;
43240 PyErr_Clear();
43241 } else {
43242 _v = 1;
43243 }
43244 }
43245 if (_v) {
43246 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43247 if (_v) {
43248 {
43249 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43250 }
43251 if (_v) {
43252 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43253 }
43254 }
43255 }
43256 }
43257
43258 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43259 return NULL;
43260 }
43261
43262
43263 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43264 PyObject *resultobj;
43265 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43266 wxWindow *arg2 = (wxWindow *) 0 ;
43267 wxGBSpan result;
43268 PyObject * obj0 = 0 ;
43269 PyObject * obj1 = 0 ;
43270
43271 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43273 if (SWIG_arg_fail(1)) SWIG_fail;
43274 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43275 if (SWIG_arg_fail(2)) SWIG_fail;
43276 {
43277 PyThreadState* __tstate = wxPyBeginAllowThreads();
43278 result = (arg1)->GetItemSpan(arg2);
43279
43280 wxPyEndAllowThreads(__tstate);
43281 if (PyErr_Occurred()) SWIG_fail;
43282 }
43283 {
43284 wxGBSpan * resultptr;
43285 resultptr = new wxGBSpan((wxGBSpan &)(result));
43286 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43287 }
43288 return resultobj;
43289 fail:
43290 return NULL;
43291 }
43292
43293
43294 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43295 PyObject *resultobj;
43296 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43297 wxSizer *arg2 = (wxSizer *) 0 ;
43298 wxGBSpan result;
43299 PyObject * obj0 = 0 ;
43300 PyObject * obj1 = 0 ;
43301
43302 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43304 if (SWIG_arg_fail(1)) SWIG_fail;
43305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43306 if (SWIG_arg_fail(2)) SWIG_fail;
43307 {
43308 PyThreadState* __tstate = wxPyBeginAllowThreads();
43309 result = (arg1)->GetItemSpan(arg2);
43310
43311 wxPyEndAllowThreads(__tstate);
43312 if (PyErr_Occurred()) SWIG_fail;
43313 }
43314 {
43315 wxGBSpan * resultptr;
43316 resultptr = new wxGBSpan((wxGBSpan &)(result));
43317 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43318 }
43319 return resultobj;
43320 fail:
43321 return NULL;
43322 }
43323
43324
43325 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43326 PyObject *resultobj;
43327 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43328 size_t arg2 ;
43329 wxGBSpan result;
43330 PyObject * obj0 = 0 ;
43331 PyObject * obj1 = 0 ;
43332
43333 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43335 if (SWIG_arg_fail(1)) SWIG_fail;
43336 {
43337 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43338 if (SWIG_arg_fail(2)) SWIG_fail;
43339 }
43340 {
43341 PyThreadState* __tstate = wxPyBeginAllowThreads();
43342 result = (arg1)->GetItemSpan(arg2);
43343
43344 wxPyEndAllowThreads(__tstate);
43345 if (PyErr_Occurred()) SWIG_fail;
43346 }
43347 {
43348 wxGBSpan * resultptr;
43349 resultptr = new wxGBSpan((wxGBSpan &)(result));
43350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43351 }
43352 return resultobj;
43353 fail:
43354 return NULL;
43355 }
43356
43357
43358 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43359 int argc;
43360 PyObject *argv[3];
43361 int ii;
43362
43363 argc = PyObject_Length(args);
43364 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43365 argv[ii] = PyTuple_GetItem(args,ii);
43366 }
43367 if (argc == 2) {
43368 int _v;
43369 {
43370 void *ptr;
43371 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43372 _v = 0;
43373 PyErr_Clear();
43374 } else {
43375 _v = 1;
43376 }
43377 }
43378 if (_v) {
43379 {
43380 void *ptr;
43381 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43382 _v = 0;
43383 PyErr_Clear();
43384 } else {
43385 _v = 1;
43386 }
43387 }
43388 if (_v) {
43389 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43390 }
43391 }
43392 }
43393 if (argc == 2) {
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 {
43406 void *ptr;
43407 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43408 _v = 0;
43409 PyErr_Clear();
43410 } else {
43411 _v = 1;
43412 }
43413 }
43414 if (_v) {
43415 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43416 }
43417 }
43418 }
43419 if (argc == 2) {
43420 int _v;
43421 {
43422 void *ptr;
43423 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43424 _v = 0;
43425 PyErr_Clear();
43426 } else {
43427 _v = 1;
43428 }
43429 }
43430 if (_v) {
43431 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43432 if (_v) {
43433 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43434 }
43435 }
43436 }
43437
43438 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43439 return NULL;
43440 }
43441
43442
43443 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43444 PyObject *resultobj;
43445 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43446 wxWindow *arg2 = (wxWindow *) 0 ;
43447 wxGBSpan *arg3 = 0 ;
43448 bool result;
43449 wxGBSpan temp3 ;
43450 PyObject * obj0 = 0 ;
43451 PyObject * obj1 = 0 ;
43452 PyObject * obj2 = 0 ;
43453
43454 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43456 if (SWIG_arg_fail(1)) SWIG_fail;
43457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43458 if (SWIG_arg_fail(2)) SWIG_fail;
43459 {
43460 arg3 = &temp3;
43461 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43462 }
43463 {
43464 PyThreadState* __tstate = wxPyBeginAllowThreads();
43465 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43466
43467 wxPyEndAllowThreads(__tstate);
43468 if (PyErr_Occurred()) SWIG_fail;
43469 }
43470 {
43471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43472 }
43473 return resultobj;
43474 fail:
43475 return NULL;
43476 }
43477
43478
43479 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43480 PyObject *resultobj;
43481 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43482 wxSizer *arg2 = (wxSizer *) 0 ;
43483 wxGBSpan *arg3 = 0 ;
43484 bool result;
43485 wxGBSpan temp3 ;
43486 PyObject * obj0 = 0 ;
43487 PyObject * obj1 = 0 ;
43488 PyObject * obj2 = 0 ;
43489
43490 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43492 if (SWIG_arg_fail(1)) SWIG_fail;
43493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43494 if (SWIG_arg_fail(2)) SWIG_fail;
43495 {
43496 arg3 = &temp3;
43497 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43498 }
43499 {
43500 PyThreadState* __tstate = wxPyBeginAllowThreads();
43501 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43502
43503 wxPyEndAllowThreads(__tstate);
43504 if (PyErr_Occurred()) SWIG_fail;
43505 }
43506 {
43507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43508 }
43509 return resultobj;
43510 fail:
43511 return NULL;
43512 }
43513
43514
43515 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43516 PyObject *resultobj;
43517 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43518 size_t arg2 ;
43519 wxGBSpan *arg3 = 0 ;
43520 bool result;
43521 wxGBSpan temp3 ;
43522 PyObject * obj0 = 0 ;
43523 PyObject * obj1 = 0 ;
43524 PyObject * obj2 = 0 ;
43525
43526 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43528 if (SWIG_arg_fail(1)) SWIG_fail;
43529 {
43530 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43531 if (SWIG_arg_fail(2)) SWIG_fail;
43532 }
43533 {
43534 arg3 = &temp3;
43535 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43536 }
43537 {
43538 PyThreadState* __tstate = wxPyBeginAllowThreads();
43539 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43540
43541 wxPyEndAllowThreads(__tstate);
43542 if (PyErr_Occurred()) SWIG_fail;
43543 }
43544 {
43545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43546 }
43547 return resultobj;
43548 fail:
43549 return NULL;
43550 }
43551
43552
43553 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43554 int argc;
43555 PyObject *argv[4];
43556 int ii;
43557
43558 argc = PyObject_Length(args);
43559 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43560 argv[ii] = PyTuple_GetItem(args,ii);
43561 }
43562 if (argc == 3) {
43563 int _v;
43564 {
43565 void *ptr;
43566 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43567 _v = 0;
43568 PyErr_Clear();
43569 } else {
43570 _v = 1;
43571 }
43572 }
43573 if (_v) {
43574 {
43575 void *ptr;
43576 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43577 _v = 0;
43578 PyErr_Clear();
43579 } else {
43580 _v = 1;
43581 }
43582 }
43583 if (_v) {
43584 {
43585 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43586 }
43587 if (_v) {
43588 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43589 }
43590 }
43591 }
43592 }
43593 if (argc == 3) {
43594 int _v;
43595 {
43596 void *ptr;
43597 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43598 _v = 0;
43599 PyErr_Clear();
43600 } else {
43601 _v = 1;
43602 }
43603 }
43604 if (_v) {
43605 {
43606 void *ptr;
43607 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43608 _v = 0;
43609 PyErr_Clear();
43610 } else {
43611 _v = 1;
43612 }
43613 }
43614 if (_v) {
43615 {
43616 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43617 }
43618 if (_v) {
43619 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43620 }
43621 }
43622 }
43623 }
43624 if (argc == 3) {
43625 int _v;
43626 {
43627 void *ptr;
43628 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43629 _v = 0;
43630 PyErr_Clear();
43631 } else {
43632 _v = 1;
43633 }
43634 }
43635 if (_v) {
43636 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43637 if (_v) {
43638 {
43639 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43640 }
43641 if (_v) {
43642 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43643 }
43644 }
43645 }
43646 }
43647
43648 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43649 return NULL;
43650 }
43651
43652
43653 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43654 PyObject *resultobj;
43655 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43656 wxWindow *arg2 = (wxWindow *) 0 ;
43657 wxGBSizerItem *result;
43658 PyObject * obj0 = 0 ;
43659 PyObject * obj1 = 0 ;
43660
43661 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43663 if (SWIG_arg_fail(1)) SWIG_fail;
43664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43665 if (SWIG_arg_fail(2)) SWIG_fail;
43666 {
43667 PyThreadState* __tstate = wxPyBeginAllowThreads();
43668 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43669
43670 wxPyEndAllowThreads(__tstate);
43671 if (PyErr_Occurred()) SWIG_fail;
43672 }
43673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43674 return resultobj;
43675 fail:
43676 return NULL;
43677 }
43678
43679
43680 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43681 PyObject *resultobj;
43682 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43683 wxSizer *arg2 = (wxSizer *) 0 ;
43684 wxGBSizerItem *result;
43685 PyObject * obj0 = 0 ;
43686 PyObject * obj1 = 0 ;
43687
43688 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43690 if (SWIG_arg_fail(1)) SWIG_fail;
43691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43692 if (SWIG_arg_fail(2)) SWIG_fail;
43693 {
43694 PyThreadState* __tstate = wxPyBeginAllowThreads();
43695 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43696
43697 wxPyEndAllowThreads(__tstate);
43698 if (PyErr_Occurred()) SWIG_fail;
43699 }
43700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43701 return resultobj;
43702 fail:
43703 return NULL;
43704 }
43705
43706
43707 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43708 int argc;
43709 PyObject *argv[3];
43710 int ii;
43711
43712 argc = PyObject_Length(args);
43713 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43714 argv[ii] = PyTuple_GetItem(args,ii);
43715 }
43716 if (argc == 2) {
43717 int _v;
43718 {
43719 void *ptr;
43720 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43721 _v = 0;
43722 PyErr_Clear();
43723 } else {
43724 _v = 1;
43725 }
43726 }
43727 if (_v) {
43728 {
43729 void *ptr;
43730 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43731 _v = 0;
43732 PyErr_Clear();
43733 } else {
43734 _v = 1;
43735 }
43736 }
43737 if (_v) {
43738 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43739 }
43740 }
43741 }
43742 if (argc == 2) {
43743 int _v;
43744 {
43745 void *ptr;
43746 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43747 _v = 0;
43748 PyErr_Clear();
43749 } else {
43750 _v = 1;
43751 }
43752 }
43753 if (_v) {
43754 {
43755 void *ptr;
43756 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43757 _v = 0;
43758 PyErr_Clear();
43759 } else {
43760 _v = 1;
43761 }
43762 }
43763 if (_v) {
43764 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43765 }
43766 }
43767 }
43768
43769 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43770 return NULL;
43771 }
43772
43773
43774 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43775 PyObject *resultobj;
43776 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43777 wxGBPosition *arg2 = 0 ;
43778 wxGBSizerItem *result;
43779 wxGBPosition temp2 ;
43780 PyObject * obj0 = 0 ;
43781 PyObject * obj1 = 0 ;
43782 char *kwnames[] = {
43783 (char *) "self",(char *) "pos", NULL
43784 };
43785
43786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43788 if (SWIG_arg_fail(1)) SWIG_fail;
43789 {
43790 arg2 = &temp2;
43791 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43792 }
43793 {
43794 PyThreadState* __tstate = wxPyBeginAllowThreads();
43795 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43796
43797 wxPyEndAllowThreads(__tstate);
43798 if (PyErr_Occurred()) SWIG_fail;
43799 }
43800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43801 return resultobj;
43802 fail:
43803 return NULL;
43804 }
43805
43806
43807 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43808 PyObject *resultobj;
43809 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43810 wxPoint *arg2 = 0 ;
43811 wxGBSizerItem *result;
43812 wxPoint temp2 ;
43813 PyObject * obj0 = 0 ;
43814 PyObject * obj1 = 0 ;
43815 char *kwnames[] = {
43816 (char *) "self",(char *) "pt", NULL
43817 };
43818
43819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43821 if (SWIG_arg_fail(1)) SWIG_fail;
43822 {
43823 arg2 = &temp2;
43824 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43825 }
43826 {
43827 PyThreadState* __tstate = wxPyBeginAllowThreads();
43828 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43829
43830 wxPyEndAllowThreads(__tstate);
43831 if (PyErr_Occurred()) SWIG_fail;
43832 }
43833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43834 return resultobj;
43835 fail:
43836 return NULL;
43837 }
43838
43839
43840 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43841 PyObject *resultobj;
43842 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43843 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43844 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43845 bool result;
43846 PyObject * obj0 = 0 ;
43847 PyObject * obj1 = 0 ;
43848 PyObject * obj2 = 0 ;
43849 char *kwnames[] = {
43850 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43851 };
43852
43853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43855 if (SWIG_arg_fail(1)) SWIG_fail;
43856 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43857 if (SWIG_arg_fail(2)) SWIG_fail;
43858 if (obj2) {
43859 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43860 if (SWIG_arg_fail(3)) SWIG_fail;
43861 }
43862 {
43863 PyThreadState* __tstate = wxPyBeginAllowThreads();
43864 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43865
43866 wxPyEndAllowThreads(__tstate);
43867 if (PyErr_Occurred()) SWIG_fail;
43868 }
43869 {
43870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43871 }
43872 return resultobj;
43873 fail:
43874 return NULL;
43875 }
43876
43877
43878 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43879 PyObject *resultobj;
43880 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43881 wxGBPosition *arg2 = 0 ;
43882 wxGBSpan *arg3 = 0 ;
43883 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43884 bool result;
43885 wxGBPosition temp2 ;
43886 wxGBSpan temp3 ;
43887 PyObject * obj0 = 0 ;
43888 PyObject * obj1 = 0 ;
43889 PyObject * obj2 = 0 ;
43890 PyObject * obj3 = 0 ;
43891 char *kwnames[] = {
43892 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43893 };
43894
43895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43897 if (SWIG_arg_fail(1)) SWIG_fail;
43898 {
43899 arg2 = &temp2;
43900 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43901 }
43902 {
43903 arg3 = &temp3;
43904 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43905 }
43906 if (obj3) {
43907 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43908 if (SWIG_arg_fail(4)) SWIG_fail;
43909 }
43910 {
43911 PyThreadState* __tstate = wxPyBeginAllowThreads();
43912 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43913
43914 wxPyEndAllowThreads(__tstate);
43915 if (PyErr_Occurred()) SWIG_fail;
43916 }
43917 {
43918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43919 }
43920 return resultobj;
43921 fail:
43922 return NULL;
43923 }
43924
43925
43926 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43927 PyObject *obj;
43928 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43929 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43930 Py_INCREF(obj);
43931 return Py_BuildValue((char *)"");
43932 }
43933 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43934 PyObject *resultobj;
43935 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43936 wxRelationship arg2 ;
43937 wxWindow *arg3 = (wxWindow *) 0 ;
43938 wxEdge arg4 ;
43939 int arg5 = (int) 0 ;
43940 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43941 PyObject * obj0 = 0 ;
43942 PyObject * obj1 = 0 ;
43943 PyObject * obj2 = 0 ;
43944 PyObject * obj3 = 0 ;
43945 PyObject * obj4 = 0 ;
43946 PyObject * obj5 = 0 ;
43947 char *kwnames[] = {
43948 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43949 };
43950
43951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43953 if (SWIG_arg_fail(1)) SWIG_fail;
43954 {
43955 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43956 if (SWIG_arg_fail(2)) SWIG_fail;
43957 }
43958 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43959 if (SWIG_arg_fail(3)) SWIG_fail;
43960 {
43961 arg4 = (wxEdge)(SWIG_As_int(obj3));
43962 if (SWIG_arg_fail(4)) SWIG_fail;
43963 }
43964 if (obj4) {
43965 {
43966 arg5 = (int)(SWIG_As_int(obj4));
43967 if (SWIG_arg_fail(5)) SWIG_fail;
43968 }
43969 }
43970 if (obj5) {
43971 {
43972 arg6 = (int)(SWIG_As_int(obj5));
43973 if (SWIG_arg_fail(6)) SWIG_fail;
43974 }
43975 }
43976 {
43977 PyThreadState* __tstate = wxPyBeginAllowThreads();
43978 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43979
43980 wxPyEndAllowThreads(__tstate);
43981 if (PyErr_Occurred()) SWIG_fail;
43982 }
43983 Py_INCREF(Py_None); resultobj = Py_None;
43984 return resultobj;
43985 fail:
43986 return NULL;
43987 }
43988
43989
43990 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43991 PyObject *resultobj;
43992 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43993 wxWindow *arg2 = (wxWindow *) 0 ;
43994 int arg3 = (int) 0 ;
43995 PyObject * obj0 = 0 ;
43996 PyObject * obj1 = 0 ;
43997 PyObject * obj2 = 0 ;
43998 char *kwnames[] = {
43999 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44000 };
44001
44002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44004 if (SWIG_arg_fail(1)) SWIG_fail;
44005 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44006 if (SWIG_arg_fail(2)) SWIG_fail;
44007 if (obj2) {
44008 {
44009 arg3 = (int)(SWIG_As_int(obj2));
44010 if (SWIG_arg_fail(3)) SWIG_fail;
44011 }
44012 }
44013 {
44014 PyThreadState* __tstate = wxPyBeginAllowThreads();
44015 (arg1)->LeftOf(arg2,arg3);
44016
44017 wxPyEndAllowThreads(__tstate);
44018 if (PyErr_Occurred()) SWIG_fail;
44019 }
44020 Py_INCREF(Py_None); resultobj = Py_None;
44021 return resultobj;
44022 fail:
44023 return NULL;
44024 }
44025
44026
44027 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44028 PyObject *resultobj;
44029 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44030 wxWindow *arg2 = (wxWindow *) 0 ;
44031 int arg3 = (int) 0 ;
44032 PyObject * obj0 = 0 ;
44033 PyObject * obj1 = 0 ;
44034 PyObject * obj2 = 0 ;
44035 char *kwnames[] = {
44036 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44037 };
44038
44039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44041 if (SWIG_arg_fail(1)) SWIG_fail;
44042 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44043 if (SWIG_arg_fail(2)) SWIG_fail;
44044 if (obj2) {
44045 {
44046 arg3 = (int)(SWIG_As_int(obj2));
44047 if (SWIG_arg_fail(3)) SWIG_fail;
44048 }
44049 }
44050 {
44051 PyThreadState* __tstate = wxPyBeginAllowThreads();
44052 (arg1)->RightOf(arg2,arg3);
44053
44054 wxPyEndAllowThreads(__tstate);
44055 if (PyErr_Occurred()) SWIG_fail;
44056 }
44057 Py_INCREF(Py_None); resultobj = Py_None;
44058 return resultobj;
44059 fail:
44060 return NULL;
44061 }
44062
44063
44064 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44065 PyObject *resultobj;
44066 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44067 wxWindow *arg2 = (wxWindow *) 0 ;
44068 int arg3 = (int) 0 ;
44069 PyObject * obj0 = 0 ;
44070 PyObject * obj1 = 0 ;
44071 PyObject * obj2 = 0 ;
44072 char *kwnames[] = {
44073 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44074 };
44075
44076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44078 if (SWIG_arg_fail(1)) SWIG_fail;
44079 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44080 if (SWIG_arg_fail(2)) SWIG_fail;
44081 if (obj2) {
44082 {
44083 arg3 = (int)(SWIG_As_int(obj2));
44084 if (SWIG_arg_fail(3)) SWIG_fail;
44085 }
44086 }
44087 {
44088 PyThreadState* __tstate = wxPyBeginAllowThreads();
44089 (arg1)->Above(arg2,arg3);
44090
44091 wxPyEndAllowThreads(__tstate);
44092 if (PyErr_Occurred()) SWIG_fail;
44093 }
44094 Py_INCREF(Py_None); resultobj = Py_None;
44095 return resultobj;
44096 fail:
44097 return NULL;
44098 }
44099
44100
44101 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44102 PyObject *resultobj;
44103 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44104 wxWindow *arg2 = (wxWindow *) 0 ;
44105 int arg3 = (int) 0 ;
44106 PyObject * obj0 = 0 ;
44107 PyObject * obj1 = 0 ;
44108 PyObject * obj2 = 0 ;
44109 char *kwnames[] = {
44110 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44111 };
44112
44113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44115 if (SWIG_arg_fail(1)) SWIG_fail;
44116 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44117 if (SWIG_arg_fail(2)) SWIG_fail;
44118 if (obj2) {
44119 {
44120 arg3 = (int)(SWIG_As_int(obj2));
44121 if (SWIG_arg_fail(3)) SWIG_fail;
44122 }
44123 }
44124 {
44125 PyThreadState* __tstate = wxPyBeginAllowThreads();
44126 (arg1)->Below(arg2,arg3);
44127
44128 wxPyEndAllowThreads(__tstate);
44129 if (PyErr_Occurred()) SWIG_fail;
44130 }
44131 Py_INCREF(Py_None); resultobj = Py_None;
44132 return resultobj;
44133 fail:
44134 return NULL;
44135 }
44136
44137
44138 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44139 PyObject *resultobj;
44140 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44141 wxWindow *arg2 = (wxWindow *) 0 ;
44142 wxEdge arg3 ;
44143 int arg4 = (int) 0 ;
44144 PyObject * obj0 = 0 ;
44145 PyObject * obj1 = 0 ;
44146 PyObject * obj2 = 0 ;
44147 PyObject * obj3 = 0 ;
44148 char *kwnames[] = {
44149 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44150 };
44151
44152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44154 if (SWIG_arg_fail(1)) SWIG_fail;
44155 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44156 if (SWIG_arg_fail(2)) SWIG_fail;
44157 {
44158 arg3 = (wxEdge)(SWIG_As_int(obj2));
44159 if (SWIG_arg_fail(3)) SWIG_fail;
44160 }
44161 if (obj3) {
44162 {
44163 arg4 = (int)(SWIG_As_int(obj3));
44164 if (SWIG_arg_fail(4)) SWIG_fail;
44165 }
44166 }
44167 {
44168 PyThreadState* __tstate = wxPyBeginAllowThreads();
44169 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44170
44171 wxPyEndAllowThreads(__tstate);
44172 if (PyErr_Occurred()) SWIG_fail;
44173 }
44174 Py_INCREF(Py_None); resultobj = Py_None;
44175 return resultobj;
44176 fail:
44177 return NULL;
44178 }
44179
44180
44181 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44182 PyObject *resultobj;
44183 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44184 wxWindow *arg2 = (wxWindow *) 0 ;
44185 wxEdge arg3 ;
44186 int arg4 ;
44187 PyObject * obj0 = 0 ;
44188 PyObject * obj1 = 0 ;
44189 PyObject * obj2 = 0 ;
44190 PyObject * obj3 = 0 ;
44191 char *kwnames[] = {
44192 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44193 };
44194
44195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44197 if (SWIG_arg_fail(1)) SWIG_fail;
44198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44199 if (SWIG_arg_fail(2)) SWIG_fail;
44200 {
44201 arg3 = (wxEdge)(SWIG_As_int(obj2));
44202 if (SWIG_arg_fail(3)) SWIG_fail;
44203 }
44204 {
44205 arg4 = (int)(SWIG_As_int(obj3));
44206 if (SWIG_arg_fail(4)) SWIG_fail;
44207 }
44208 {
44209 PyThreadState* __tstate = wxPyBeginAllowThreads();
44210 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44211
44212 wxPyEndAllowThreads(__tstate);
44213 if (PyErr_Occurred()) SWIG_fail;
44214 }
44215 Py_INCREF(Py_None); resultobj = Py_None;
44216 return resultobj;
44217 fail:
44218 return NULL;
44219 }
44220
44221
44222 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44223 PyObject *resultobj;
44224 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44225 int arg2 ;
44226 PyObject * obj0 = 0 ;
44227 PyObject * obj1 = 0 ;
44228 char *kwnames[] = {
44229 (char *) "self",(char *) "val", NULL
44230 };
44231
44232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44234 if (SWIG_arg_fail(1)) SWIG_fail;
44235 {
44236 arg2 = (int)(SWIG_As_int(obj1));
44237 if (SWIG_arg_fail(2)) SWIG_fail;
44238 }
44239 {
44240 PyThreadState* __tstate = wxPyBeginAllowThreads();
44241 (arg1)->Absolute(arg2);
44242
44243 wxPyEndAllowThreads(__tstate);
44244 if (PyErr_Occurred()) SWIG_fail;
44245 }
44246 Py_INCREF(Py_None); resultobj = Py_None;
44247 return resultobj;
44248 fail:
44249 return NULL;
44250 }
44251
44252
44253 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44254 PyObject *resultobj;
44255 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44256 PyObject * obj0 = 0 ;
44257 char *kwnames[] = {
44258 (char *) "self", NULL
44259 };
44260
44261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44263 if (SWIG_arg_fail(1)) SWIG_fail;
44264 {
44265 PyThreadState* __tstate = wxPyBeginAllowThreads();
44266 (arg1)->Unconstrained();
44267
44268 wxPyEndAllowThreads(__tstate);
44269 if (PyErr_Occurred()) SWIG_fail;
44270 }
44271 Py_INCREF(Py_None); resultobj = Py_None;
44272 return resultobj;
44273 fail:
44274 return NULL;
44275 }
44276
44277
44278 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44279 PyObject *resultobj;
44280 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44281 PyObject * obj0 = 0 ;
44282 char *kwnames[] = {
44283 (char *) "self", NULL
44284 };
44285
44286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44288 if (SWIG_arg_fail(1)) SWIG_fail;
44289 {
44290 PyThreadState* __tstate = wxPyBeginAllowThreads();
44291 (arg1)->AsIs();
44292
44293 wxPyEndAllowThreads(__tstate);
44294 if (PyErr_Occurred()) SWIG_fail;
44295 }
44296 Py_INCREF(Py_None); resultobj = Py_None;
44297 return resultobj;
44298 fail:
44299 return NULL;
44300 }
44301
44302
44303 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44304 PyObject *resultobj;
44305 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44306 wxWindow *result;
44307 PyObject * obj0 = 0 ;
44308 char *kwnames[] = {
44309 (char *) "self", NULL
44310 };
44311
44312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",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 = (wxWindow *)(arg1)->GetOtherWindow();
44318
44319 wxPyEndAllowThreads(__tstate);
44320 if (PyErr_Occurred()) SWIG_fail;
44321 }
44322 {
44323 resultobj = wxPyMake_wxObject(result, 0);
44324 }
44325 return resultobj;
44326 fail:
44327 return NULL;
44328 }
44329
44330
44331 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44332 PyObject *resultobj;
44333 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44334 wxEdge result;
44335 PyObject * obj0 = 0 ;
44336 char *kwnames[] = {
44337 (char *) "self", NULL
44338 };
44339
44340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",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 = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44346
44347 wxPyEndAllowThreads(__tstate);
44348 if (PyErr_Occurred()) SWIG_fail;
44349 }
44350 resultobj = SWIG_From_int((result));
44351 return resultobj;
44352 fail:
44353 return NULL;
44354 }
44355
44356
44357 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44358 PyObject *resultobj;
44359 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44360 wxEdge arg2 ;
44361 PyObject * obj0 = 0 ;
44362 PyObject * obj1 = 0 ;
44363 char *kwnames[] = {
44364 (char *) "self",(char *) "which", NULL
44365 };
44366
44367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44369 if (SWIG_arg_fail(1)) SWIG_fail;
44370 {
44371 arg2 = (wxEdge)(SWIG_As_int(obj1));
44372 if (SWIG_arg_fail(2)) SWIG_fail;
44373 }
44374 {
44375 PyThreadState* __tstate = wxPyBeginAllowThreads();
44376 (arg1)->SetEdge((wxEdge )arg2);
44377
44378 wxPyEndAllowThreads(__tstate);
44379 if (PyErr_Occurred()) SWIG_fail;
44380 }
44381 Py_INCREF(Py_None); resultobj = Py_None;
44382 return resultobj;
44383 fail:
44384 return NULL;
44385 }
44386
44387
44388 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44389 PyObject *resultobj;
44390 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44391 int arg2 ;
44392 PyObject * obj0 = 0 ;
44393 PyObject * obj1 = 0 ;
44394 char *kwnames[] = {
44395 (char *) "self",(char *) "v", NULL
44396 };
44397
44398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44400 if (SWIG_arg_fail(1)) SWIG_fail;
44401 {
44402 arg2 = (int)(SWIG_As_int(obj1));
44403 if (SWIG_arg_fail(2)) SWIG_fail;
44404 }
44405 {
44406 PyThreadState* __tstate = wxPyBeginAllowThreads();
44407 (arg1)->SetValue(arg2);
44408
44409 wxPyEndAllowThreads(__tstate);
44410 if (PyErr_Occurred()) SWIG_fail;
44411 }
44412 Py_INCREF(Py_None); resultobj = Py_None;
44413 return resultobj;
44414 fail:
44415 return NULL;
44416 }
44417
44418
44419 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44420 PyObject *resultobj;
44421 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44422 int result;
44423 PyObject * obj0 = 0 ;
44424 char *kwnames[] = {
44425 (char *) "self", NULL
44426 };
44427
44428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44430 if (SWIG_arg_fail(1)) SWIG_fail;
44431 {
44432 PyThreadState* __tstate = wxPyBeginAllowThreads();
44433 result = (int)(arg1)->GetMargin();
44434
44435 wxPyEndAllowThreads(__tstate);
44436 if (PyErr_Occurred()) SWIG_fail;
44437 }
44438 {
44439 resultobj = SWIG_From_int((int)(result));
44440 }
44441 return resultobj;
44442 fail:
44443 return NULL;
44444 }
44445
44446
44447 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44448 PyObject *resultobj;
44449 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44450 int arg2 ;
44451 PyObject * obj0 = 0 ;
44452 PyObject * obj1 = 0 ;
44453 char *kwnames[] = {
44454 (char *) "self",(char *) "m", NULL
44455 };
44456
44457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44459 if (SWIG_arg_fail(1)) SWIG_fail;
44460 {
44461 arg2 = (int)(SWIG_As_int(obj1));
44462 if (SWIG_arg_fail(2)) SWIG_fail;
44463 }
44464 {
44465 PyThreadState* __tstate = wxPyBeginAllowThreads();
44466 (arg1)->SetMargin(arg2);
44467
44468 wxPyEndAllowThreads(__tstate);
44469 if (PyErr_Occurred()) SWIG_fail;
44470 }
44471 Py_INCREF(Py_None); resultobj = Py_None;
44472 return resultobj;
44473 fail:
44474 return NULL;
44475 }
44476
44477
44478 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44479 PyObject *resultobj;
44480 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44481 int result;
44482 PyObject * obj0 = 0 ;
44483 char *kwnames[] = {
44484 (char *) "self", NULL
44485 };
44486
44487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44489 if (SWIG_arg_fail(1)) SWIG_fail;
44490 {
44491 PyThreadState* __tstate = wxPyBeginAllowThreads();
44492 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44493
44494 wxPyEndAllowThreads(__tstate);
44495 if (PyErr_Occurred()) SWIG_fail;
44496 }
44497 {
44498 resultobj = SWIG_From_int((int)(result));
44499 }
44500 return resultobj;
44501 fail:
44502 return NULL;
44503 }
44504
44505
44506 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44507 PyObject *resultobj;
44508 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44509 int result;
44510 PyObject * obj0 = 0 ;
44511 char *kwnames[] = {
44512 (char *) "self", NULL
44513 };
44514
44515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44517 if (SWIG_arg_fail(1)) SWIG_fail;
44518 {
44519 PyThreadState* __tstate = wxPyBeginAllowThreads();
44520 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44521
44522 wxPyEndAllowThreads(__tstate);
44523 if (PyErr_Occurred()) SWIG_fail;
44524 }
44525 {
44526 resultobj = SWIG_From_int((int)(result));
44527 }
44528 return resultobj;
44529 fail:
44530 return NULL;
44531 }
44532
44533
44534 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44535 PyObject *resultobj;
44536 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44537 int result;
44538 PyObject * obj0 = 0 ;
44539 char *kwnames[] = {
44540 (char *) "self", NULL
44541 };
44542
44543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44545 if (SWIG_arg_fail(1)) SWIG_fail;
44546 {
44547 PyThreadState* __tstate = wxPyBeginAllowThreads();
44548 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44549
44550 wxPyEndAllowThreads(__tstate);
44551 if (PyErr_Occurred()) SWIG_fail;
44552 }
44553 {
44554 resultobj = SWIG_From_int((int)(result));
44555 }
44556 return resultobj;
44557 fail:
44558 return NULL;
44559 }
44560
44561
44562 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44563 PyObject *resultobj;
44564 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44565 bool result;
44566 PyObject * obj0 = 0 ;
44567 char *kwnames[] = {
44568 (char *) "self", NULL
44569 };
44570
44571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44573 if (SWIG_arg_fail(1)) SWIG_fail;
44574 {
44575 PyThreadState* __tstate = wxPyBeginAllowThreads();
44576 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44577
44578 wxPyEndAllowThreads(__tstate);
44579 if (PyErr_Occurred()) SWIG_fail;
44580 }
44581 {
44582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44583 }
44584 return resultobj;
44585 fail:
44586 return NULL;
44587 }
44588
44589
44590 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44591 PyObject *resultobj;
44592 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44593 bool arg2 ;
44594 PyObject * obj0 = 0 ;
44595 PyObject * obj1 = 0 ;
44596 char *kwnames[] = {
44597 (char *) "self",(char *) "d", NULL
44598 };
44599
44600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44602 if (SWIG_arg_fail(1)) SWIG_fail;
44603 {
44604 arg2 = (bool)(SWIG_As_bool(obj1));
44605 if (SWIG_arg_fail(2)) SWIG_fail;
44606 }
44607 {
44608 PyThreadState* __tstate = wxPyBeginAllowThreads();
44609 (arg1)->SetDone(arg2);
44610
44611 wxPyEndAllowThreads(__tstate);
44612 if (PyErr_Occurred()) SWIG_fail;
44613 }
44614 Py_INCREF(Py_None); resultobj = Py_None;
44615 return resultobj;
44616 fail:
44617 return NULL;
44618 }
44619
44620
44621 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44622 PyObject *resultobj;
44623 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44624 wxRelationship result;
44625 PyObject * obj0 = 0 ;
44626 char *kwnames[] = {
44627 (char *) "self", NULL
44628 };
44629
44630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44632 if (SWIG_arg_fail(1)) SWIG_fail;
44633 {
44634 PyThreadState* __tstate = wxPyBeginAllowThreads();
44635 result = (wxRelationship)(arg1)->GetRelationship();
44636
44637 wxPyEndAllowThreads(__tstate);
44638 if (PyErr_Occurred()) SWIG_fail;
44639 }
44640 resultobj = SWIG_From_int((result));
44641 return resultobj;
44642 fail:
44643 return NULL;
44644 }
44645
44646
44647 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44648 PyObject *resultobj;
44649 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44650 wxRelationship arg2 ;
44651 PyObject * obj0 = 0 ;
44652 PyObject * obj1 = 0 ;
44653 char *kwnames[] = {
44654 (char *) "self",(char *) "r", NULL
44655 };
44656
44657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44659 if (SWIG_arg_fail(1)) SWIG_fail;
44660 {
44661 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44662 if (SWIG_arg_fail(2)) SWIG_fail;
44663 }
44664 {
44665 PyThreadState* __tstate = wxPyBeginAllowThreads();
44666 (arg1)->SetRelationship((wxRelationship )arg2);
44667
44668 wxPyEndAllowThreads(__tstate);
44669 if (PyErr_Occurred()) SWIG_fail;
44670 }
44671 Py_INCREF(Py_None); resultobj = Py_None;
44672 return resultobj;
44673 fail:
44674 return NULL;
44675 }
44676
44677
44678 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44679 PyObject *resultobj;
44680 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44681 wxWindow *arg2 = (wxWindow *) 0 ;
44682 bool result;
44683 PyObject * obj0 = 0 ;
44684 PyObject * obj1 = 0 ;
44685 char *kwnames[] = {
44686 (char *) "self",(char *) "otherW", NULL
44687 };
44688
44689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44691 if (SWIG_arg_fail(1)) SWIG_fail;
44692 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44693 if (SWIG_arg_fail(2)) SWIG_fail;
44694 {
44695 PyThreadState* __tstate = wxPyBeginAllowThreads();
44696 result = (bool)(arg1)->ResetIfWin(arg2);
44697
44698 wxPyEndAllowThreads(__tstate);
44699 if (PyErr_Occurred()) SWIG_fail;
44700 }
44701 {
44702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44703 }
44704 return resultobj;
44705 fail:
44706 return NULL;
44707 }
44708
44709
44710 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44711 PyObject *resultobj;
44712 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44713 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44714 wxWindow *arg3 = (wxWindow *) 0 ;
44715 bool result;
44716 PyObject * obj0 = 0 ;
44717 PyObject * obj1 = 0 ;
44718 PyObject * obj2 = 0 ;
44719 char *kwnames[] = {
44720 (char *) "self",(char *) "constraints",(char *) "win", NULL
44721 };
44722
44723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44725 if (SWIG_arg_fail(1)) SWIG_fail;
44726 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44727 if (SWIG_arg_fail(2)) SWIG_fail;
44728 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44729 if (SWIG_arg_fail(3)) SWIG_fail;
44730 {
44731 PyThreadState* __tstate = wxPyBeginAllowThreads();
44732 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44733
44734 wxPyEndAllowThreads(__tstate);
44735 if (PyErr_Occurred()) SWIG_fail;
44736 }
44737 {
44738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44739 }
44740 return resultobj;
44741 fail:
44742 return NULL;
44743 }
44744
44745
44746 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44747 PyObject *resultobj;
44748 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44749 wxEdge arg2 ;
44750 wxWindow *arg3 = (wxWindow *) 0 ;
44751 wxWindow *arg4 = (wxWindow *) 0 ;
44752 int result;
44753 PyObject * obj0 = 0 ;
44754 PyObject * obj1 = 0 ;
44755 PyObject * obj2 = 0 ;
44756 PyObject * obj3 = 0 ;
44757 char *kwnames[] = {
44758 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44759 };
44760
44761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44763 if (SWIG_arg_fail(1)) SWIG_fail;
44764 {
44765 arg2 = (wxEdge)(SWIG_As_int(obj1));
44766 if (SWIG_arg_fail(2)) SWIG_fail;
44767 }
44768 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44769 if (SWIG_arg_fail(3)) SWIG_fail;
44770 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44771 if (SWIG_arg_fail(4)) SWIG_fail;
44772 {
44773 PyThreadState* __tstate = wxPyBeginAllowThreads();
44774 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44775
44776 wxPyEndAllowThreads(__tstate);
44777 if (PyErr_Occurred()) SWIG_fail;
44778 }
44779 {
44780 resultobj = SWIG_From_int((int)(result));
44781 }
44782 return resultobj;
44783 fail:
44784 return NULL;
44785 }
44786
44787
44788 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44789 PyObject *obj;
44790 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44791 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44792 Py_INCREF(obj);
44793 return Py_BuildValue((char *)"");
44794 }
44795 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44796 PyObject *resultobj;
44797 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44798 wxIndividualLayoutConstraint *result;
44799 PyObject * obj0 = 0 ;
44800 char *kwnames[] = {
44801 (char *) "self", NULL
44802 };
44803
44804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44806 if (SWIG_arg_fail(1)) SWIG_fail;
44807 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44808
44809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44810 return resultobj;
44811 fail:
44812 return NULL;
44813 }
44814
44815
44816 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44817 PyObject *resultobj;
44818 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44819 wxIndividualLayoutConstraint *result;
44820 PyObject * obj0 = 0 ;
44821 char *kwnames[] = {
44822 (char *) "self", NULL
44823 };
44824
44825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44827 if (SWIG_arg_fail(1)) SWIG_fail;
44828 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44829
44830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44831 return resultobj;
44832 fail:
44833 return NULL;
44834 }
44835
44836
44837 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44838 PyObject *resultobj;
44839 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44840 wxIndividualLayoutConstraint *result;
44841 PyObject * obj0 = 0 ;
44842 char *kwnames[] = {
44843 (char *) "self", NULL
44844 };
44845
44846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44848 if (SWIG_arg_fail(1)) SWIG_fail;
44849 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44850
44851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44852 return resultobj;
44853 fail:
44854 return NULL;
44855 }
44856
44857
44858 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44859 PyObject *resultobj;
44860 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44861 wxIndividualLayoutConstraint *result;
44862 PyObject * obj0 = 0 ;
44863 char *kwnames[] = {
44864 (char *) "self", NULL
44865 };
44866
44867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44869 if (SWIG_arg_fail(1)) SWIG_fail;
44870 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44871
44872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44873 return resultobj;
44874 fail:
44875 return NULL;
44876 }
44877
44878
44879 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44880 PyObject *resultobj;
44881 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44882 wxIndividualLayoutConstraint *result;
44883 PyObject * obj0 = 0 ;
44884 char *kwnames[] = {
44885 (char *) "self", NULL
44886 };
44887
44888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44890 if (SWIG_arg_fail(1)) SWIG_fail;
44891 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44892
44893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44894 return resultobj;
44895 fail:
44896 return NULL;
44897 }
44898
44899
44900 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44901 PyObject *resultobj;
44902 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44903 wxIndividualLayoutConstraint *result;
44904 PyObject * obj0 = 0 ;
44905 char *kwnames[] = {
44906 (char *) "self", NULL
44907 };
44908
44909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44911 if (SWIG_arg_fail(1)) SWIG_fail;
44912 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44913
44914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44915 return resultobj;
44916 fail:
44917 return NULL;
44918 }
44919
44920
44921 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44922 PyObject *resultobj;
44923 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44924 wxIndividualLayoutConstraint *result;
44925 PyObject * obj0 = 0 ;
44926 char *kwnames[] = {
44927 (char *) "self", NULL
44928 };
44929
44930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44932 if (SWIG_arg_fail(1)) SWIG_fail;
44933 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44934
44935 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44936 return resultobj;
44937 fail:
44938 return NULL;
44939 }
44940
44941
44942 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44943 PyObject *resultobj;
44944 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44945 wxIndividualLayoutConstraint *result;
44946 PyObject * obj0 = 0 ;
44947 char *kwnames[] = {
44948 (char *) "self", NULL
44949 };
44950
44951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44953 if (SWIG_arg_fail(1)) SWIG_fail;
44954 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44955
44956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44957 return resultobj;
44958 fail:
44959 return NULL;
44960 }
44961
44962
44963 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44964 PyObject *resultobj;
44965 wxLayoutConstraints *result;
44966 char *kwnames[] = {
44967 NULL
44968 };
44969
44970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44971 {
44972 PyThreadState* __tstate = wxPyBeginAllowThreads();
44973 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44974
44975 wxPyEndAllowThreads(__tstate);
44976 if (PyErr_Occurred()) SWIG_fail;
44977 }
44978 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44979 return resultobj;
44980 fail:
44981 return NULL;
44982 }
44983
44984
44985 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44986 PyObject *resultobj;
44987 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44988 wxWindow *arg2 = (wxWindow *) 0 ;
44989 int *arg3 = (int *) 0 ;
44990 bool result;
44991 int temp3 ;
44992 int res3 = 0 ;
44993 PyObject * obj0 = 0 ;
44994 PyObject * obj1 = 0 ;
44995 char *kwnames[] = {
44996 (char *) "self",(char *) "win", NULL
44997 };
44998
44999 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45002 if (SWIG_arg_fail(1)) SWIG_fail;
45003 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45004 if (SWIG_arg_fail(2)) SWIG_fail;
45005 {
45006 PyThreadState* __tstate = wxPyBeginAllowThreads();
45007 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45008
45009 wxPyEndAllowThreads(__tstate);
45010 if (PyErr_Occurred()) SWIG_fail;
45011 }
45012 {
45013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45014 }
45015 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45016 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45017 return resultobj;
45018 fail:
45019 return NULL;
45020 }
45021
45022
45023 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45024 PyObject *resultobj;
45025 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45026 bool result;
45027 PyObject * obj0 = 0 ;
45028 char *kwnames[] = {
45029 (char *) "self", NULL
45030 };
45031
45032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45034 if (SWIG_arg_fail(1)) SWIG_fail;
45035 {
45036 PyThreadState* __tstate = wxPyBeginAllowThreads();
45037 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45038
45039 wxPyEndAllowThreads(__tstate);
45040 if (PyErr_Occurred()) SWIG_fail;
45041 }
45042 {
45043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45044 }
45045 return resultobj;
45046 fail:
45047 return NULL;
45048 }
45049
45050
45051 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45052 PyObject *obj;
45053 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45054 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45055 Py_INCREF(obj);
45056 return Py_BuildValue((char *)"");
45057 }
45058 static PyMethodDef SwigMethods[] = {
45059 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45060 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45061 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45064 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45085 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45098 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45113 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45167 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45195 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45214 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45216 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45224 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45225 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45237 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45249 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45253 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45259 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45269 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45279 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45283 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45362 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45364 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45366 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45368 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45370 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45372 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45374 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45376 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45378 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45380 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45382 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45384 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45386 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45400 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45418 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45421 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45424 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45436 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45441 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45447 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45453 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45516 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45523 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45559 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45569 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45575 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45577 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45579 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45582 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45586 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45589 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45592 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45594 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45599 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45607 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45611 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45614 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45616 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45620 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45637 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45639 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45642 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45644 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45648 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45652 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45663 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45666 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45669 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45673 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45680 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45685 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45690 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45694 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45739 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45759 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45766 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45770 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45780 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45952 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45992 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46006 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46009 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46064 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46091 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46135 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46143 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46162 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46163 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46200 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46230 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46233 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46237 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46240 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46250 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46262 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46274 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46284 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46294 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46308 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46315 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46316 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46317 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46318 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46319 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46324 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46351 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46363 { NULL, NULL, 0, NULL }
46364 };
46365
46366
46367 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46368
46369 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46370 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46371 }
46372 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46373 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46374 }
46375 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46376 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46377 }
46378 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46379 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46380 }
46381 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46382 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46383 }
46384 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46385 return (void *)((wxSizer *) ((wxGridSizer *) x));
46386 }
46387 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46388 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46389 }
46390 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46391 return (void *)((wxSizer *) ((wxPySizer *) x));
46392 }
46393 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46394 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46395 }
46396 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46397 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46398 }
46399 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46400 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46401 }
46402 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46403 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46404 }
46405 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46406 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46407 }
46408 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46409 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46410 }
46411 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46412 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46413 }
46414 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46415 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46416 }
46417 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46418 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46419 }
46420 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46421 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46422 }
46423 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46424 return (void *)((wxEvent *) ((wxPyEvent *) x));
46425 }
46426 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46427 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46428 }
46429 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46430 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46431 }
46432 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46433 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46434 }
46435 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46436 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46437 }
46438 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46439 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46440 }
46441 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46442 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46443 }
46444 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46445 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46446 }
46447 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46448 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46449 }
46450 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46451 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46452 }
46453 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46454 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46455 }
46456 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46457 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46458 }
46459 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46460 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46461 }
46462 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46463 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46464 }
46465 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46466 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46467 }
46468 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46469 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46470 }
46471 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46472 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46473 }
46474 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46475 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46476 }
46477 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46478 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46479 }
46480 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46481 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46482 }
46483 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46484 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46485 }
46486 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46487 return (void *)((wxEvent *) ((wxShowEvent *) x));
46488 }
46489 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46490 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46491 }
46492 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46493 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46494 }
46495 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46496 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46497 }
46498 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46499 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46500 }
46501 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46502 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46503 }
46504 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46505 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46506 }
46507 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46508 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46509 }
46510 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46511 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46512 }
46513 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46514 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46515 }
46516 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46517 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46518 }
46519 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46520 return (void *)((wxControl *) ((wxControlWithItems *) x));
46521 }
46522 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46523 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46524 }
46525 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46526 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46527 }
46528 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46529 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46530 }
46531 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46532 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46533 }
46534 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46535 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46536 }
46537 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46538 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46539 }
46540 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46541 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46542 }
46543 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46544 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46545 }
46546 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46547 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46548 }
46549 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46550 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46551 }
46552 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46553 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46554 }
46555 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46556 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46557 }
46558 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46559 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46560 }
46561 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46562 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46563 }
46564 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46565 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46566 }
46567 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46568 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46569 }
46570 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46571 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46572 }
46573 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46574 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46575 }
46576 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46577 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46578 }
46579 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46580 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46581 }
46582 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46583 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46584 }
46585 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46586 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46587 }
46588 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46589 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46590 }
46591 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46592 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46593 }
46594 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46595 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46596 }
46597 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46598 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46599 }
46600 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46601 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46602 }
46603 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46604 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46605 }
46606 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46607 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46608 }
46609 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46610 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46611 }
46612 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46613 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46614 }
46615 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46616 return (void *)((wxObject *) ((wxSizerItem *) x));
46617 }
46618 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46619 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46620 }
46621 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46622 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46623 }
46624 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46625 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46626 }
46627 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46628 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46629 }
46630 static void *_p_wxSizerTo_p_wxObject(void *x) {
46631 return (void *)((wxObject *) ((wxSizer *) x));
46632 }
46633 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46634 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46635 }
46636 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46637 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46638 }
46639 static void *_p_wxEventTo_p_wxObject(void *x) {
46640 return (void *)((wxObject *) ((wxEvent *) x));
46641 }
46642 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46643 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46644 }
46645 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46646 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46647 }
46648 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46649 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46650 }
46651 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46652 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46653 }
46654 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46655 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46656 }
46657 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46658 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46659 }
46660 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46661 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46662 }
46663 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46664 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46665 }
46666 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46667 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46668 }
46669 static void *_p_wxControlTo_p_wxObject(void *x) {
46670 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46671 }
46672 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46673 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46674 }
46675 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46676 return (void *)((wxObject *) ((wxFSFile *) x));
46677 }
46678 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46679 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46680 }
46681 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46682 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46683 }
46684 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46685 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46686 }
46687 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46688 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46689 }
46690 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46691 return (void *)((wxObject *) ((wxMenuItem *) x));
46692 }
46693 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46694 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46695 }
46696 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46697 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46698 }
46699 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46700 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46701 }
46702 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46703 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46704 }
46705 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46706 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46707 }
46708 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46709 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46710 }
46711 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46712 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46713 }
46714 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46715 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46716 }
46717 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46718 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46719 }
46720 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46721 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46722 }
46723 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46724 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46725 }
46726 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46727 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46728 }
46729 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46730 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46731 }
46732 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46733 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46734 }
46735 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46736 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46737 }
46738 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46739 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46740 }
46741 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46742 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46743 }
46744 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46745 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46746 }
46747 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46748 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46749 }
46750 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46751 return (void *)((wxObject *) ((wxImageHandler *) x));
46752 }
46753 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46754 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46755 }
46756 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46757 return (void *)((wxObject *) ((wxEvtHandler *) x));
46758 }
46759 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46760 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46761 }
46762 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46763 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46764 }
46765 static void *_p_wxImageTo_p_wxObject(void *x) {
46766 return (void *)((wxObject *) ((wxImage *) x));
46767 }
46768 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46769 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46770 }
46771 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46772 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46773 }
46774 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46775 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46776 }
46777 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46778 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46779 }
46780 static void *_p_wxWindowTo_p_wxObject(void *x) {
46781 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46782 }
46783 static void *_p_wxMenuTo_p_wxObject(void *x) {
46784 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46785 }
46786 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46787 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46788 }
46789 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46790 return (void *)((wxObject *) ((wxFileSystem *) x));
46791 }
46792 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46793 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46794 }
46795 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46796 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46797 }
46798 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46799 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46800 }
46801 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46802 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46803 }
46804 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46805 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46806 }
46807 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46808 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46809 }
46810 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46811 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46812 }
46813 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46814 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46815 }
46816 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46817 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46818 }
46819 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46820 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46821 }
46822 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46823 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46824 }
46825 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46826 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46827 }
46828 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46829 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46830 }
46831 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46832 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46833 }
46834 static void *_p_wxControlTo_p_wxWindow(void *x) {
46835 return (void *)((wxWindow *) ((wxControl *) x));
46836 }
46837 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46838 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46839 }
46840 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46841 return (void *)((wxWindow *) ((wxMenuBar *) x));
46842 }
46843 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46844 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46845 }
46846 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46847 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46848 }
46849 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46850 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46851 }
46852 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46853 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46854 }
46855 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46856 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46857 }
46858 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46859 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46860 }
46861 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46862 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46863 }
46864 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46865 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46866 }
46867 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46868 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46869 }
46870 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46871 return (void *)((wxValidator *) ((wxPyValidator *) x));
46872 }
46873 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}};
46874 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}};
46875 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}};
46876 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}};
46877 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}};
46878 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}};
46879 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}};
46880 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}};
46881 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}};
46882 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}};
46883 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}};
46884 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}};
46885 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}};
46886 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}};
46887 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}};
46888 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}};
46889 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}};
46890 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}};
46891 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}};
46892 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}};
46893 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}};
46894 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}};
46895 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}};
46896 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}};
46897 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}};
46898 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}};
46899 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}};
46900 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}};
46901 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}};
46902 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}};
46903 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}};
46904 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}};
46905 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}};
46906 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}};
46907 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}};
46908 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}};
46909 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}};
46910 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}};
46911 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}};
46912 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}};
46913 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}};
46914 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}};
46915 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}};
46916 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}};
46917 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}};
46918 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}};
46919 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}};
46920 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}};
46921 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}};
46922 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}};
46923 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}};
46924 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}};
46925 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}};
46926 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}};
46927 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}};
46928 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}};
46929 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}};
46930 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}};
46931 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}};
46932 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}};
46933 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}};
46934 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}};
46935 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}};
46936 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}};
46937 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}};
46938 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}};
46939 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}};
46940 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}};
46941 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}};
46942 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}};
46943 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}};
46944 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}};
46945 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}};
46946 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}};
46947 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}};
46948 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}};
46949 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}};
46950 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}};
46951 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}};
46952 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}};
46953 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}};
46954 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}};
46955 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}};
46956 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}};
46957 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}};
46958 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}};
46959 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}};
46960 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}};
46961 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}};
46962 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}};
46963 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}};
46964 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}};
46965 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}};
46966 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}};
46967 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}};
46968 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}};
46969 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}};
46970 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}};
46971 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}};
46972 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}};
46973 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}};
46974 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}};
46975 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}};
46976 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}};
46977 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}};
46978 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}};
46979 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}};
46980 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}};
46981 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}};
46982 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}};
46983 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}};
46984 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46985 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}};
46986 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}};
46987 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}};
46988 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}};
46989 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}};
46990 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}};
46991 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}};
46992 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}};
46993 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}};
46994 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}};
46995 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}};
46996 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}};
46997 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}};
46998 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}};
46999 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}};
47000
47001 static swig_type_info *swig_types_initial[] = {
47002 _swigt__p_wxLayoutConstraints,
47003 _swigt__p_wxRealPoint,
47004 _swigt__p_wxSizerItem,
47005 _swigt__p_wxGBSizerItem,
47006 _swigt__p_wxScrollEvent,
47007 _swigt__p_wxEventLoop,
47008 _swigt__p_wxIndividualLayoutConstraint,
47009 _swigt__p_wxSizer,
47010 _swigt__p_wxBoxSizer,
47011 _swigt__p_wxStaticBoxSizer,
47012 _swigt__p_wxGridBagSizer,
47013 _swigt__p_wxAcceleratorEntry,
47014 _swigt__p_wxUpdateUIEvent,
47015 _swigt__p_wxEvent,
47016 _swigt__p_wxMenu,
47017 _swigt__p_wxGridSizer,
47018 _swigt__p_wxFlexGridSizer,
47019 _swigt__p_wxInitDialogEvent,
47020 _swigt__p_wxItemContainer,
47021 _swigt__p_wxNcPaintEvent,
47022 _swigt__p_wxPaintEvent,
47023 _swigt__p_wxSysColourChangedEvent,
47024 _swigt__p_wxMouseCaptureChangedEvent,
47025 _swigt__p_wxDisplayChangedEvent,
47026 _swigt__p_wxPaletteChangedEvent,
47027 _swigt__p_wxControl,
47028 _swigt__p_wxFont,
47029 _swigt__p_wxMenuBarBase,
47030 _swigt__p_wxSetCursorEvent,
47031 _swigt__p_wxFSFile,
47032 _swigt__p_wxCaret,
47033 _swigt__ptrdiff_t,
47034 _swigt__std__ptrdiff_t,
47035 _swigt__p_wxRegion,
47036 _swigt__p_wxPoint2D,
47037 _swigt__p_int,
47038 _swigt__p_wxSize,
47039 _swigt__p_wxDC,
47040 _swigt__p_wxPySizer,
47041 _swigt__p_wxVisualAttributes,
47042 _swigt__p_wxNotifyEvent,
47043 _swigt__p_wxPyEvent,
47044 _swigt__p_wxPropagationDisabler,
47045 _swigt__p_form_ops_t,
47046 _swigt__p_wxAppTraits,
47047 _swigt__p_wxArrayString,
47048 _swigt__p_wxShowEvent,
47049 _swigt__p_wxToolTip,
47050 _swigt__p_wxMoveEvent,
47051 _swigt__p_wxSizeEvent,
47052 _swigt__p_wxActivateEvent,
47053 _swigt__p_wxIconizeEvent,
47054 _swigt__p_wxMaximizeEvent,
47055 _swigt__p_wxQueryNewPaletteEvent,
47056 _swigt__p_wxWindowCreateEvent,
47057 _swigt__p_wxIdleEvent,
47058 _swigt__p_wxDateEvent,
47059 _swigt__p_wxMenuItem,
47060 _swigt__p_wxStaticBox,
47061 _swigt__p_long,
47062 _swigt__p_wxDuplexMode,
47063 _swigt__p_wxTIFFHandler,
47064 _swigt__p_wxXPMHandler,
47065 _swigt__p_wxPNMHandler,
47066 _swigt__p_wxJPEGHandler,
47067 _swigt__p_wxPCXHandler,
47068 _swigt__p_wxGIFHandler,
47069 _swigt__p_wxPNGHandler,
47070 _swigt__p_wxANIHandler,
47071 _swigt__p_wxMemoryFSHandler,
47072 _swigt__p_wxZipFSHandler,
47073 _swigt__p_wxInternetFSHandler,
47074 _swigt__p_wxPyFileSystemHandler,
47075 _swigt__p_wxEvtHandler,
47076 _swigt__p_wxCURHandler,
47077 _swigt__p_wxICOHandler,
47078 _swigt__p_wxBMPHandler,
47079 _swigt__p_wxImageHandler,
47080 _swigt__p_wxFileSystemHandler,
47081 _swigt__p_wxRect,
47082 _swigt__p_wxButton,
47083 _swigt__p_wxGBSpan,
47084 _swigt__p_wxPropagateOnce,
47085 _swigt__p_wxAcceleratorTable,
47086 _swigt__p_wxStdDialogButtonSizer,
47087 _swigt__p_char,
47088 _swigt__p_wxGBPosition,
47089 _swigt__p_wxImage,
47090 _swigt__p_wxFrame,
47091 _swigt__p_wxScrollWinEvent,
47092 _swigt__p_wxPaperSize,
47093 _swigt__p_wxImageHistogram,
47094 _swigt__p_wxPoint,
47095 _swigt__p_wxCursor,
47096 _swigt__p_wxObject,
47097 _swigt__p_wxInputStream,
47098 _swigt__p_wxOutputStream,
47099 _swigt__p_wxPyInputStream,
47100 _swigt__p_wxDateTime,
47101 _swigt__p_wxKeyEvent,
47102 _swigt__p_wxNavigationKeyEvent,
47103 _swigt__p_wxWindowDestroyEvent,
47104 _swigt__p_unsigned_long,
47105 _swigt__p_wxWindow,
47106 _swigt__p_wxMenuBar,
47107 _swigt__p_wxFileSystem,
47108 _swigt__p_wxBitmap,
47109 _swigt__unsigned_int,
47110 _swigt__p_unsigned_int,
47111 _swigt__p_wxMenuEvent,
47112 _swigt__p_wxContextMenuEvent,
47113 _swigt__p_unsigned_char,
47114 _swigt__p_wxEraseEvent,
47115 _swigt__p_wxMouseEvent,
47116 _swigt__p_wxCloseEvent,
47117 _swigt__p_wxPyApp,
47118 _swigt__p_wxCommandEvent,
47119 _swigt__p_wxPyCommandEvent,
47120 _swigt__p_wxPyDropTarget,
47121 _swigt__p_wxQuantize,
47122 _swigt__p_wxChildFocusEvent,
47123 _swigt__p_wxFocusEvent,
47124 _swigt__p_wxDropFilesEvent,
47125 _swigt__p_wxControlWithItems,
47126 _swigt__p_wxColour,
47127 _swigt__p_wxValidator,
47128 _swigt__p_wxPyValidator,
47129 0
47130 };
47131
47132
47133 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47134
47135 static swig_const_info swig_const_table[] = {
47136 {0, 0, 0, 0.0, 0, 0}};
47137
47138 #ifdef __cplusplus
47139 }
47140 #endif
47141
47142
47143 #ifdef __cplusplus
47144 extern "C" {
47145 #endif
47146
47147 /* Python-specific SWIG API */
47148 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47149 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47150 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47151
47152 /* -----------------------------------------------------------------------------
47153 * global variable support code.
47154 * ----------------------------------------------------------------------------- */
47155
47156 typedef struct swig_globalvar {
47157 char *name; /* Name of global variable */
47158 PyObject *(*get_attr)(); /* Return the current value */
47159 int (*set_attr)(PyObject *); /* Set the value */
47160 struct swig_globalvar *next;
47161 } swig_globalvar;
47162
47163 typedef struct swig_varlinkobject {
47164 PyObject_HEAD
47165 swig_globalvar *vars;
47166 } swig_varlinkobject;
47167
47168 static PyObject *
47169 swig_varlink_repr(swig_varlinkobject *v) {
47170 v = v;
47171 return PyString_FromString("<Swig global variables>");
47172 }
47173
47174 static int
47175 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47176 swig_globalvar *var;
47177 flags = flags;
47178 fprintf(fp,"Swig global variables { ");
47179 for (var = v->vars; var; var=var->next) {
47180 fprintf(fp,"%s", var->name);
47181 if (var->next) fprintf(fp,", ");
47182 }
47183 fprintf(fp," }\n");
47184 return 0;
47185 }
47186
47187 static PyObject *
47188 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47189 swig_globalvar *var = v->vars;
47190 while (var) {
47191 if (strcmp(var->name,n) == 0) {
47192 return (*var->get_attr)();
47193 }
47194 var = var->next;
47195 }
47196 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47197 return NULL;
47198 }
47199
47200 static int
47201 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47202 swig_globalvar *var = v->vars;
47203 while (var) {
47204 if (strcmp(var->name,n) == 0) {
47205 return (*var->set_attr)(p);
47206 }
47207 var = var->next;
47208 }
47209 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47210 return 1;
47211 }
47212
47213 static PyTypeObject varlinktype = {
47214 PyObject_HEAD_INIT(0)
47215 0, /* Number of items in variable part (ob_size) */
47216 (char *)"swigvarlink", /* Type name (tp_name) */
47217 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47218 0, /* Itemsize (tp_itemsize) */
47219 0, /* Deallocator (tp_dealloc) */
47220 (printfunc) swig_varlink_print, /* Print (tp_print) */
47221 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47222 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47223 0, /* tp_compare */
47224 (reprfunc) swig_varlink_repr, /* tp_repr */
47225 0, /* tp_as_number */
47226 0, /* tp_as_sequence */
47227 0, /* tp_as_mapping */
47228 0, /* tp_hash */
47229 0, /* tp_call */
47230 0, /* tp_str */
47231 0, /* tp_getattro */
47232 0, /* tp_setattro */
47233 0, /* tp_as_buffer */
47234 0, /* tp_flags */
47235 0, /* tp_doc */
47236 #if PY_VERSION_HEX >= 0x02000000
47237 0, /* tp_traverse */
47238 0, /* tp_clear */
47239 #endif
47240 #if PY_VERSION_HEX >= 0x02010000
47241 0, /* tp_richcompare */
47242 0, /* tp_weaklistoffset */
47243 #endif
47244 #if PY_VERSION_HEX >= 0x02020000
47245 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47246 #endif
47247 #if PY_VERSION_HEX >= 0x02030000
47248 0, /* tp_del */
47249 #endif
47250 #ifdef COUNT_ALLOCS
47251 0,0,0,0 /* tp_alloc -> tp_next */
47252 #endif
47253 };
47254
47255 /* Create a variable linking object for use later */
47256 static PyObject *
47257 SWIG_Python_newvarlink(void) {
47258 swig_varlinkobject *result = 0;
47259 result = PyMem_NEW(swig_varlinkobject,1);
47260 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47261 result->ob_type = &varlinktype;
47262 result->vars = 0;
47263 result->ob_refcnt = 0;
47264 Py_XINCREF((PyObject *) result);
47265 return ((PyObject*) result);
47266 }
47267
47268 static void
47269 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47270 swig_varlinkobject *v;
47271 swig_globalvar *gv;
47272 v= (swig_varlinkobject *) p;
47273 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47274 gv->name = (char *) malloc(strlen(name)+1);
47275 strcpy(gv->name,name);
47276 gv->get_attr = get_attr;
47277 gv->set_attr = set_attr;
47278 gv->next = v->vars;
47279 v->vars = gv;
47280 }
47281
47282 /* -----------------------------------------------------------------------------
47283 * constants/methods manipulation
47284 * ----------------------------------------------------------------------------- */
47285
47286 /* Install Constants */
47287 static void
47288 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47289 PyObject *obj = 0;
47290 size_t i;
47291 for (i = 0; constants[i].type; i++) {
47292 switch(constants[i].type) {
47293 case SWIG_PY_INT:
47294 obj = PyInt_FromLong(constants[i].lvalue);
47295 break;
47296 case SWIG_PY_FLOAT:
47297 obj = PyFloat_FromDouble(constants[i].dvalue);
47298 break;
47299 case SWIG_PY_STRING:
47300 if (constants[i].pvalue) {
47301 obj = PyString_FromString((char *) constants[i].pvalue);
47302 } else {
47303 Py_INCREF(Py_None);
47304 obj = Py_None;
47305 }
47306 break;
47307 case SWIG_PY_POINTER:
47308 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47309 break;
47310 case SWIG_PY_BINARY:
47311 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47312 break;
47313 default:
47314 obj = 0;
47315 break;
47316 }
47317 if (obj) {
47318 PyDict_SetItemString(d,constants[i].name,obj);
47319 Py_DECREF(obj);
47320 }
47321 }
47322 }
47323
47324 /* -----------------------------------------------------------------------------*/
47325 /* Fix SwigMethods to carry the callback ptrs when needed */
47326 /* -----------------------------------------------------------------------------*/
47327
47328 static void
47329 SWIG_Python_FixMethods(PyMethodDef *methods,
47330 swig_const_info *const_table,
47331 swig_type_info **types,
47332 swig_type_info **types_initial) {
47333 size_t i;
47334 for (i = 0; methods[i].ml_name; ++i) {
47335 char *c = methods[i].ml_doc;
47336 if (c && (c = strstr(c, "swig_ptr: "))) {
47337 int j;
47338 swig_const_info *ci = 0;
47339 char *name = c + 10;
47340 for (j = 0; const_table[j].type; j++) {
47341 if (strncmp(const_table[j].name, name,
47342 strlen(const_table[j].name)) == 0) {
47343 ci = &(const_table[j]);
47344 break;
47345 }
47346 }
47347 if (ci) {
47348 size_t shift = (ci->ptype) - types;
47349 swig_type_info *ty = types_initial[shift];
47350 size_t ldoc = (c - methods[i].ml_doc);
47351 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47352 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47353 char *buff = ndoc;
47354 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47355 strncpy(buff, methods[i].ml_doc, ldoc);
47356 buff += ldoc;
47357 strncpy(buff, "swig_ptr: ", 10);
47358 buff += 10;
47359 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47360 methods[i].ml_doc = ndoc;
47361 }
47362 }
47363 }
47364 }
47365
47366 /* -----------------------------------------------------------------------------*
47367 * Initialize type list
47368 * -----------------------------------------------------------------------------*/
47369
47370 #if PY_MAJOR_VERSION < 2
47371 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47372 is copied out of Python/modsupport.c in python version 2.3.4 */
47373 static int
47374 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47375 {
47376 PyObject *dict;
47377 if (!PyModule_Check(m)) {
47378 PyErr_SetString(PyExc_TypeError,
47379 "PyModule_AddObject() needs module as first arg");
47380 return -1;
47381 }
47382 if (!o) {
47383 PyErr_SetString(PyExc_TypeError,
47384 "PyModule_AddObject() needs non-NULL value");
47385 return -1;
47386 }
47387
47388 dict = PyModule_GetDict(m);
47389 if (dict == NULL) {
47390 /* Internal error -- modules must have a dict! */
47391 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47392 PyModule_GetName(m));
47393 return -1;
47394 }
47395 if (PyDict_SetItemString(dict, name, o))
47396 return -1;
47397 Py_DECREF(o);
47398 return 0;
47399 }
47400 #endif
47401
47402 static swig_type_info **
47403 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47404 static PyMethodDef swig_empty_runtime_method_table[] = {
47405 {
47406 NULL, NULL, 0, NULL
47407 }
47408 };/* Sentinel */
47409
47410 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47411 swig_empty_runtime_method_table);
47412 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47413 if (pointer && module) {
47414 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47415 }
47416 return type_list_handle;
47417 }
47418
47419 static swig_type_info **
47420 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47421 swig_type_info **type_pointer;
47422
47423 /* first check if module already created */
47424 type_pointer = SWIG_Python_GetTypeListHandle();
47425 if (type_pointer) {
47426 return type_pointer;
47427 } else {
47428 /* create a new module and variable */
47429 return SWIG_Python_SetTypeListHandle(type_list_handle);
47430 }
47431 }
47432
47433 #ifdef __cplusplus
47434 }
47435 #endif
47436
47437 /* -----------------------------------------------------------------------------*
47438 * Partial Init method
47439 * -----------------------------------------------------------------------------*/
47440
47441 #ifdef SWIG_LINK_RUNTIME
47442 #ifdef __cplusplus
47443 extern "C"
47444 #endif
47445 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47446 #endif
47447
47448 #ifdef __cplusplus
47449 extern "C"
47450 #endif
47451 SWIGEXPORT(void) SWIG_init(void) {
47452 static PyObject *SWIG_globals = 0;
47453 static int typeinit = 0;
47454 PyObject *m, *d;
47455 int i;
47456 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47457
47458 /* Fix SwigMethods to carry the callback ptrs when needed */
47459 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47460
47461 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47462 d = PyModule_GetDict(m);
47463
47464 if (!typeinit) {
47465 #ifdef SWIG_LINK_RUNTIME
47466 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47467 #else
47468 # ifndef SWIG_STATIC_RUNTIME
47469 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47470 # endif
47471 #endif
47472 for (i = 0; swig_types_initial[i]; i++) {
47473 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47474 }
47475 typeinit = 1;
47476 }
47477 SWIG_InstallConstants(d,swig_const_table);
47478
47479
47480 #ifndef wxPyUSE_EXPORT
47481 // Make our API structure a CObject so other modules can import it
47482 // from this module.
47483 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47484 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47485 Py_XDECREF(cobj);
47486 #endif
47487
47488 {
47489 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47490 }
47491 {
47492 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47493 }
47494 {
47495 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47496 }
47497 {
47498 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47499 }
47500 {
47501 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47502 }
47503 {
47504 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47505 }
47506 {
47507 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47508 }
47509 {
47510 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47511 }
47512 {
47513 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47514 }
47515 {
47516 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47517 }
47518 {
47519 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47520 }
47521 {
47522 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47523 }
47524 {
47525 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47526 }
47527 {
47528 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47529 }
47530 {
47531 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47532 }
47533 {
47534 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47535 }
47536 {
47537 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47538 }
47539 {
47540 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47541 }
47542 {
47543 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47544 }
47545 {
47546 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47547 }
47548 {
47549 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47550 }
47551 {
47552 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47553 }
47554 {
47555 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47556 }
47557 {
47558 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47559 }
47560 {
47561 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47562 }
47563 {
47564 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47565 }
47566 {
47567 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47568 }
47569 {
47570 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47571 }
47572 {
47573 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47574 }
47575 {
47576 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47577 }
47578 {
47579 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47580 }
47581 {
47582 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47583 }
47584 {
47585 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47586 }
47587 {
47588 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47589 }
47590 {
47591 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47592 }
47593 {
47594 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47595 }
47596 {
47597 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47598 }
47599 {
47600 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47601 }
47602 {
47603 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47604 }
47605 {
47606 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47607 }
47608 {
47609 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47610 }
47611 {
47612 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47613 }
47614 {
47615 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47616 }
47617 {
47618 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47619 }
47620 {
47621 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47622 }
47623 {
47624 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47625 }
47626 {
47627 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47628 }
47629 {
47630 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47631 }
47632 {
47633 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47634 }
47635 {
47636 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47637 }
47638 {
47639 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47640 }
47641 {
47642 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47643 }
47644 {
47645 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47646 }
47647 {
47648 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47649 }
47650 {
47651 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47652 }
47653 {
47654 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47655 }
47656 {
47657 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47658 }
47659 {
47660 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47661 }
47662 {
47663 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47664 }
47665 {
47666 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47667 }
47668 {
47669 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47670 }
47671 {
47672 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47673 }
47674 {
47675 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49140 }
49141 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49142 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49143 {
49144 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49145 }
49146 {
49147 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49148 }
49149 {
49150 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49151 }
49152 {
49153 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49154 }
49155 {
49156 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49157 }
49158 {
49159 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49160 }
49161 {
49162 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49163 }
49164 {
49165 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49166 }
49167 {
49168 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49169 }
49170 {
49171 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49172 }
49173 {
49174 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49175 }
49176 {
49177 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49178 }
49179 {
49180 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49181 }
49182 {
49183 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49184 }
49185 {
49186 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49187 }
49188 {
49189 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49190 }
49191 {
49192 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49193 }
49194 {
49195 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49196 }
49197 {
49198 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49199 }
49200 {
49201 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49202 }
49203 {
49204 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49205 }
49206 {
49207 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49208 }
49209 {
49210 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49211 }
49212 {
49213 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49214 }
49215 {
49216 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49217 }
49218 {
49219 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49220 }
49221 {
49222 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49223 }
49224 {
49225 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49226 }
49227 {
49228 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49229 }
49230 {
49231 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49232 }
49233 {
49234 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49235 }
49236 {
49237 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49238 }
49239 {
49240 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49241 }
49242 {
49243 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49244 }
49245 {
49246 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49250 }
49251 {
49252 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49253 }
49254 {
49255 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49256 }
49257 {
49258 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49259 }
49260 {
49261 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49262 }
49263 {
49264 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49265 }
49266 {
49267 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49268 }
49269 {
49270 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49271 }
49272 {
49273 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49274 }
49275 {
49276 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49277 }
49278 {
49279 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49280 }
49281 {
49282 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49283 }
49284 {
49285 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49286 }
49287 {
49288 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49289 }
49290 {
49291 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49292 }
49293 {
49294 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49295 }
49296 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49297 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49298 {
49299 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49303 }
49304 {
49305 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49306 }
49307
49308 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49309
49310
49311 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49312
49313 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49314 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49315 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49316 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49317 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49318 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49319 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49320 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49321 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49322 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49323 {
49324 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49325 }
49326 {
49327 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49328 }
49329 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49330 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49331 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49332 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49333 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49334 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49335 {
49336 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49337 }
49338 {
49339 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49340 }
49341 {
49342 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49343 }
49344 {
49345 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49346 }
49347 {
49348 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49349 }
49350 {
49351 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49352 }
49353 {
49354 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49355 }
49356 {
49357 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49358 }
49359 {
49360 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49361 }
49362 {
49363 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49364 }
49365 {
49366 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49367 }
49368 {
49369 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49370 }
49371 {
49372 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49373 }
49374 {
49375 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49376 }
49377 {
49378 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49379 }
49380 {
49381 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49382 }
49383 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49384 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49385 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49386 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49387 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49388 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49389 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49390 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49391 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49392 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49393 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49394 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49395 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49396 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49397 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49398 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49399 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49400 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49401 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49402 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49403 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49404 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49405 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49406 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49407 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49408 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49409 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49410 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49411 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49412 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49413 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49414 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49415 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49416 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49417 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49418 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49419 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49420 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49421 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49422 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49423 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49424 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49425 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49426 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49427 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49428 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49429 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49430 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49431 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49432 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49433 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49434 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49435 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49436 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49437 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49438 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49439 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49440 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49441 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49442 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49443 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49444 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49445 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49446 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49447 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49448 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49449 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49450 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49451 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49452 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49453 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49454 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49455 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49456 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49457 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49458 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49459 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49460 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49461 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49462 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49463 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49464 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49465 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49466 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49467 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49468 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49469 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49470 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49471 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49472 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49473 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49474 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49475 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49476 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49477 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49478 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49479 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49480 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49481 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49482 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49483 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49484 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49485 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49486 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49487 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49488 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49489 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49490 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49491 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49492 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49493 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49494 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49495 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49496 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49497 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49498 {
49499 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49500 }
49501 {
49502 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49503 }
49504 {
49505 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49506 }
49507 {
49508 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49509 }
49510 {
49511 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49512 }
49513 {
49514 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49515 }
49516 {
49517 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49518 }
49519 {
49520 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49521 }
49522 {
49523 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49524 }
49525 {
49526 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49527 }
49528 {
49529 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49530 }
49531 {
49532 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49536 }
49537 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49538 {
49539 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49540 }
49541 {
49542 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49543 }
49544 {
49545 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49546 }
49547 {
49548 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49549 }
49550 {
49551 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49555 }
49556 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49557 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49558 {
49559 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49560 }
49561 {
49562 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49563 }
49564 {
49565 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49566 }
49567 {
49568 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49569 }
49570 {
49571 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49572 }
49573 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49574 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49575 {
49576 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49577 }
49578 {
49579 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49580 }
49581 {
49582 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49583 }
49584 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49585 {
49586 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49587 }
49588 {
49589 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49590 }
49591 {
49592 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49593 }
49594 {
49595 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49596 }
49597 {
49598 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49599 }
49600 {
49601 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49602 }
49603 {
49604 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49605 }
49606 {
49607 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49608 }
49609 {
49610 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49611 }
49612 {
49613 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49614 }
49615 {
49616 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49617 }
49618 {
49619 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49620 }
49621 {
49622 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49623 }
49624 {
49625 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49626 }
49627 {
49628 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49629 }
49630 {
49631 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49632 }
49633 {
49634 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49635 }
49636 {
49637 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49638 }
49639 {
49640 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49641 }
49642
49643 // Initialize threading, some globals and such
49644 __wxPyPreStart(d);
49645
49646
49647 // Although these are defined in __version__ they need to be here too so
49648 // that an assert can be done to ensure that the wxPython and the wxWindows
49649 // versions match.
49650 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49651 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49652 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49653
49654 }
49655
wxWidgets (Impactor)