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


20c825759e9b58d44e9a084800e2eab76cee0886
[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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 ;
38617 PyObject * obj0 = 0 ;
38618 PyObject * obj1 = 0 ;
38619 char *kwnames[] = {
38620 (char *) "self",(char *) "size", NULL
38621 };
38622
38623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38625 if (SWIG_arg_fail(1)) SWIG_fail;
38626 {
38627 wxSize * argp;
38628 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38629 if (SWIG_arg_fail(2)) SWIG_fail;
38630 if (argp == NULL) {
38631 SWIG_null_ref("wxSize");
38632 }
38633 if (SWIG_arg_fail(2)) SWIG_fail;
38634 arg2 = *argp;
38635 }
38636 {
38637 PyThreadState* __tstate = wxPyBeginAllowThreads();
38638 (arg1)->SetRatio(arg2);
38639
38640 wxPyEndAllowThreads(__tstate);
38641 if (PyErr_Occurred()) SWIG_fail;
38642 }
38643 Py_INCREF(Py_None); resultobj = Py_None;
38644 return resultobj;
38645 fail:
38646 return NULL;
38647 }
38648
38649
38650 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38651 PyObject *resultobj;
38652 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38653 float arg2 ;
38654 PyObject * obj0 = 0 ;
38655 PyObject * obj1 = 0 ;
38656 char *kwnames[] = {
38657 (char *) "self",(char *) "ratio", NULL
38658 };
38659
38660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38662 if (SWIG_arg_fail(1)) SWIG_fail;
38663 {
38664 arg2 = (float)(SWIG_As_float(obj1));
38665 if (SWIG_arg_fail(2)) SWIG_fail;
38666 }
38667 {
38668 PyThreadState* __tstate = wxPyBeginAllowThreads();
38669 (arg1)->SetRatio(arg2);
38670
38671 wxPyEndAllowThreads(__tstate);
38672 if (PyErr_Occurred()) SWIG_fail;
38673 }
38674 Py_INCREF(Py_None); resultobj = Py_None;
38675 return resultobj;
38676 fail:
38677 return NULL;
38678 }
38679
38680
38681 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38682 PyObject *resultobj;
38683 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38684 float result;
38685 PyObject * obj0 = 0 ;
38686 char *kwnames[] = {
38687 (char *) "self", NULL
38688 };
38689
38690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38692 if (SWIG_arg_fail(1)) SWIG_fail;
38693 {
38694 PyThreadState* __tstate = wxPyBeginAllowThreads();
38695 result = (float)(arg1)->GetRatio();
38696
38697 wxPyEndAllowThreads(__tstate);
38698 if (PyErr_Occurred()) SWIG_fail;
38699 }
38700 {
38701 resultobj = SWIG_From_float((float)(result));
38702 }
38703 return resultobj;
38704 fail:
38705 return NULL;
38706 }
38707
38708
38709 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38710 PyObject *resultobj;
38711 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38712 wxRect result;
38713 PyObject * obj0 = 0 ;
38714 char *kwnames[] = {
38715 (char *) "self", NULL
38716 };
38717
38718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38720 if (SWIG_arg_fail(1)) SWIG_fail;
38721 {
38722 PyThreadState* __tstate = wxPyBeginAllowThreads();
38723 result = (arg1)->GetRect();
38724
38725 wxPyEndAllowThreads(__tstate);
38726 if (PyErr_Occurred()) SWIG_fail;
38727 }
38728 {
38729 wxRect * resultptr;
38730 resultptr = new wxRect((wxRect &)(result));
38731 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38732 }
38733 return resultobj;
38734 fail:
38735 return NULL;
38736 }
38737
38738
38739 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38740 PyObject *resultobj;
38741 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38742 bool result;
38743 PyObject * obj0 = 0 ;
38744 char *kwnames[] = {
38745 (char *) "self", NULL
38746 };
38747
38748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38750 if (SWIG_arg_fail(1)) SWIG_fail;
38751 {
38752 PyThreadState* __tstate = wxPyBeginAllowThreads();
38753 result = (bool)(arg1)->IsWindow();
38754
38755 wxPyEndAllowThreads(__tstate);
38756 if (PyErr_Occurred()) SWIG_fail;
38757 }
38758 {
38759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38760 }
38761 return resultobj;
38762 fail:
38763 return NULL;
38764 }
38765
38766
38767 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38768 PyObject *resultobj;
38769 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38770 bool result;
38771 PyObject * obj0 = 0 ;
38772 char *kwnames[] = {
38773 (char *) "self", NULL
38774 };
38775
38776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38778 if (SWIG_arg_fail(1)) SWIG_fail;
38779 {
38780 PyThreadState* __tstate = wxPyBeginAllowThreads();
38781 result = (bool)(arg1)->IsSizer();
38782
38783 wxPyEndAllowThreads(__tstate);
38784 if (PyErr_Occurred()) SWIG_fail;
38785 }
38786 {
38787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38788 }
38789 return resultobj;
38790 fail:
38791 return NULL;
38792 }
38793
38794
38795 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38796 PyObject *resultobj;
38797 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38798 bool result;
38799 PyObject * obj0 = 0 ;
38800 char *kwnames[] = {
38801 (char *) "self", NULL
38802 };
38803
38804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38806 if (SWIG_arg_fail(1)) SWIG_fail;
38807 {
38808 PyThreadState* __tstate = wxPyBeginAllowThreads();
38809 result = (bool)(arg1)->IsSpacer();
38810
38811 wxPyEndAllowThreads(__tstate);
38812 if (PyErr_Occurred()) SWIG_fail;
38813 }
38814 {
38815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38816 }
38817 return resultobj;
38818 fail:
38819 return NULL;
38820 }
38821
38822
38823 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38824 PyObject *resultobj;
38825 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38826 int arg2 ;
38827 PyObject * obj0 = 0 ;
38828 PyObject * obj1 = 0 ;
38829 char *kwnames[] = {
38830 (char *) "self",(char *) "proportion", NULL
38831 };
38832
38833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38835 if (SWIG_arg_fail(1)) SWIG_fail;
38836 {
38837 arg2 = (int)(SWIG_As_int(obj1));
38838 if (SWIG_arg_fail(2)) SWIG_fail;
38839 }
38840 {
38841 PyThreadState* __tstate = wxPyBeginAllowThreads();
38842 (arg1)->SetProportion(arg2);
38843
38844 wxPyEndAllowThreads(__tstate);
38845 if (PyErr_Occurred()) SWIG_fail;
38846 }
38847 Py_INCREF(Py_None); resultobj = Py_None;
38848 return resultobj;
38849 fail:
38850 return NULL;
38851 }
38852
38853
38854 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38855 PyObject *resultobj;
38856 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38857 int result;
38858 PyObject * obj0 = 0 ;
38859 char *kwnames[] = {
38860 (char *) "self", NULL
38861 };
38862
38863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38865 if (SWIG_arg_fail(1)) SWIG_fail;
38866 {
38867 PyThreadState* __tstate = wxPyBeginAllowThreads();
38868 result = (int)(arg1)->GetProportion();
38869
38870 wxPyEndAllowThreads(__tstate);
38871 if (PyErr_Occurred()) SWIG_fail;
38872 }
38873 {
38874 resultobj = SWIG_From_int((int)(result));
38875 }
38876 return resultobj;
38877 fail:
38878 return NULL;
38879 }
38880
38881
38882 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38883 PyObject *resultobj;
38884 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38885 int arg2 ;
38886 PyObject * obj0 = 0 ;
38887 PyObject * obj1 = 0 ;
38888 char *kwnames[] = {
38889 (char *) "self",(char *) "flag", NULL
38890 };
38891
38892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38894 if (SWIG_arg_fail(1)) SWIG_fail;
38895 {
38896 arg2 = (int)(SWIG_As_int(obj1));
38897 if (SWIG_arg_fail(2)) SWIG_fail;
38898 }
38899 {
38900 PyThreadState* __tstate = wxPyBeginAllowThreads();
38901 (arg1)->SetFlag(arg2);
38902
38903 wxPyEndAllowThreads(__tstate);
38904 if (PyErr_Occurred()) SWIG_fail;
38905 }
38906 Py_INCREF(Py_None); resultobj = Py_None;
38907 return resultobj;
38908 fail:
38909 return NULL;
38910 }
38911
38912
38913 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38914 PyObject *resultobj;
38915 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38916 int result;
38917 PyObject * obj0 = 0 ;
38918 char *kwnames[] = {
38919 (char *) "self", NULL
38920 };
38921
38922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38924 if (SWIG_arg_fail(1)) SWIG_fail;
38925 {
38926 PyThreadState* __tstate = wxPyBeginAllowThreads();
38927 result = (int)(arg1)->GetFlag();
38928
38929 wxPyEndAllowThreads(__tstate);
38930 if (PyErr_Occurred()) SWIG_fail;
38931 }
38932 {
38933 resultobj = SWIG_From_int((int)(result));
38934 }
38935 return resultobj;
38936 fail:
38937 return NULL;
38938 }
38939
38940
38941 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38942 PyObject *resultobj;
38943 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38944 int arg2 ;
38945 PyObject * obj0 = 0 ;
38946 PyObject * obj1 = 0 ;
38947 char *kwnames[] = {
38948 (char *) "self",(char *) "border", NULL
38949 };
38950
38951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38953 if (SWIG_arg_fail(1)) SWIG_fail;
38954 {
38955 arg2 = (int)(SWIG_As_int(obj1));
38956 if (SWIG_arg_fail(2)) SWIG_fail;
38957 }
38958 {
38959 PyThreadState* __tstate = wxPyBeginAllowThreads();
38960 (arg1)->SetBorder(arg2);
38961
38962 wxPyEndAllowThreads(__tstate);
38963 if (PyErr_Occurred()) SWIG_fail;
38964 }
38965 Py_INCREF(Py_None); resultobj = Py_None;
38966 return resultobj;
38967 fail:
38968 return NULL;
38969 }
38970
38971
38972 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38973 PyObject *resultobj;
38974 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38975 int result;
38976 PyObject * obj0 = 0 ;
38977 char *kwnames[] = {
38978 (char *) "self", NULL
38979 };
38980
38981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38983 if (SWIG_arg_fail(1)) SWIG_fail;
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 result = (int)(arg1)->GetBorder();
38987
38988 wxPyEndAllowThreads(__tstate);
38989 if (PyErr_Occurred()) SWIG_fail;
38990 }
38991 {
38992 resultobj = SWIG_From_int((int)(result));
38993 }
38994 return resultobj;
38995 fail:
38996 return NULL;
38997 }
38998
38999
39000 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39001 PyObject *resultobj;
39002 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39003 wxWindow *result;
39004 PyObject * obj0 = 0 ;
39005 char *kwnames[] = {
39006 (char *) "self", NULL
39007 };
39008
39009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39011 if (SWIG_arg_fail(1)) SWIG_fail;
39012 {
39013 PyThreadState* __tstate = wxPyBeginAllowThreads();
39014 result = (wxWindow *)(arg1)->GetWindow();
39015
39016 wxPyEndAllowThreads(__tstate);
39017 if (PyErr_Occurred()) SWIG_fail;
39018 }
39019 {
39020 resultobj = wxPyMake_wxObject(result, 0);
39021 }
39022 return resultobj;
39023 fail:
39024 return NULL;
39025 }
39026
39027
39028 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39029 PyObject *resultobj;
39030 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39031 wxWindow *arg2 = (wxWindow *) 0 ;
39032 PyObject * obj0 = 0 ;
39033 PyObject * obj1 = 0 ;
39034 char *kwnames[] = {
39035 (char *) "self",(char *) "window", NULL
39036 };
39037
39038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39040 if (SWIG_arg_fail(1)) SWIG_fail;
39041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39042 if (SWIG_arg_fail(2)) SWIG_fail;
39043 {
39044 PyThreadState* __tstate = wxPyBeginAllowThreads();
39045 (arg1)->SetWindow(arg2);
39046
39047 wxPyEndAllowThreads(__tstate);
39048 if (PyErr_Occurred()) SWIG_fail;
39049 }
39050 Py_INCREF(Py_None); resultobj = Py_None;
39051 return resultobj;
39052 fail:
39053 return NULL;
39054 }
39055
39056
39057 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39058 PyObject *resultobj;
39059 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39060 wxSizer *result;
39061 PyObject * obj0 = 0 ;
39062 char *kwnames[] = {
39063 (char *) "self", NULL
39064 };
39065
39066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39068 if (SWIG_arg_fail(1)) SWIG_fail;
39069 {
39070 PyThreadState* __tstate = wxPyBeginAllowThreads();
39071 result = (wxSizer *)(arg1)->GetSizer();
39072
39073 wxPyEndAllowThreads(__tstate);
39074 if (PyErr_Occurred()) SWIG_fail;
39075 }
39076 {
39077 resultobj = wxPyMake_wxSizer(result, 0);
39078 }
39079 return resultobj;
39080 fail:
39081 return NULL;
39082 }
39083
39084
39085 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39086 PyObject *resultobj;
39087 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39088 wxSizer *arg2 = (wxSizer *) 0 ;
39089 PyObject * obj0 = 0 ;
39090 PyObject * obj1 = 0 ;
39091 char *kwnames[] = {
39092 (char *) "self",(char *) "sizer", NULL
39093 };
39094
39095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39097 if (SWIG_arg_fail(1)) SWIG_fail;
39098 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39099 if (SWIG_arg_fail(2)) SWIG_fail;
39100 {
39101 PyThreadState* __tstate = wxPyBeginAllowThreads();
39102 (arg1)->SetSizer(arg2);
39103
39104 wxPyEndAllowThreads(__tstate);
39105 if (PyErr_Occurred()) SWIG_fail;
39106 }
39107 Py_INCREF(Py_None); resultobj = Py_None;
39108 return resultobj;
39109 fail:
39110 return NULL;
39111 }
39112
39113
39114 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39115 PyObject *resultobj;
39116 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39117 wxSize *result;
39118 PyObject * obj0 = 0 ;
39119 char *kwnames[] = {
39120 (char *) "self", NULL
39121 };
39122
39123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39125 if (SWIG_arg_fail(1)) SWIG_fail;
39126 {
39127 PyThreadState* __tstate = wxPyBeginAllowThreads();
39128 {
39129 wxSize const &_result_ref = (arg1)->GetSpacer();
39130 result = (wxSize *) &_result_ref;
39131 }
39132
39133 wxPyEndAllowThreads(__tstate);
39134 if (PyErr_Occurred()) SWIG_fail;
39135 }
39136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39137 return resultobj;
39138 fail:
39139 return NULL;
39140 }
39141
39142
39143 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39144 PyObject *resultobj;
39145 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39146 wxSize *arg2 = 0 ;
39147 wxSize temp2 ;
39148 PyObject * obj0 = 0 ;
39149 PyObject * obj1 = 0 ;
39150 char *kwnames[] = {
39151 (char *) "self",(char *) "size", NULL
39152 };
39153
39154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39156 if (SWIG_arg_fail(1)) SWIG_fail;
39157 {
39158 arg2 = &temp2;
39159 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39160 }
39161 {
39162 PyThreadState* __tstate = wxPyBeginAllowThreads();
39163 (arg1)->SetSpacer((wxSize const &)*arg2);
39164
39165 wxPyEndAllowThreads(__tstate);
39166 if (PyErr_Occurred()) SWIG_fail;
39167 }
39168 Py_INCREF(Py_None); resultobj = Py_None;
39169 return resultobj;
39170 fail:
39171 return NULL;
39172 }
39173
39174
39175 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39176 PyObject *resultobj;
39177 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39178 bool arg2 ;
39179 PyObject * obj0 = 0 ;
39180 PyObject * obj1 = 0 ;
39181 char *kwnames[] = {
39182 (char *) "self",(char *) "show", NULL
39183 };
39184
39185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39187 if (SWIG_arg_fail(1)) SWIG_fail;
39188 {
39189 arg2 = (bool)(SWIG_As_bool(obj1));
39190 if (SWIG_arg_fail(2)) SWIG_fail;
39191 }
39192 {
39193 PyThreadState* __tstate = wxPyBeginAllowThreads();
39194 (arg1)->Show(arg2);
39195
39196 wxPyEndAllowThreads(__tstate);
39197 if (PyErr_Occurred()) SWIG_fail;
39198 }
39199 Py_INCREF(Py_None); resultobj = Py_None;
39200 return resultobj;
39201 fail:
39202 return NULL;
39203 }
39204
39205
39206 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39207 PyObject *resultobj;
39208 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39209 bool result;
39210 PyObject * obj0 = 0 ;
39211 char *kwnames[] = {
39212 (char *) "self", NULL
39213 };
39214
39215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39217 if (SWIG_arg_fail(1)) SWIG_fail;
39218 {
39219 PyThreadState* __tstate = wxPyBeginAllowThreads();
39220 result = (bool)(arg1)->IsShown();
39221
39222 wxPyEndAllowThreads(__tstate);
39223 if (PyErr_Occurred()) SWIG_fail;
39224 }
39225 {
39226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39227 }
39228 return resultobj;
39229 fail:
39230 return NULL;
39231 }
39232
39233
39234 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39235 PyObject *resultobj;
39236 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39237 wxPoint result;
39238 PyObject * obj0 = 0 ;
39239 char *kwnames[] = {
39240 (char *) "self", NULL
39241 };
39242
39243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39245 if (SWIG_arg_fail(1)) SWIG_fail;
39246 {
39247 PyThreadState* __tstate = wxPyBeginAllowThreads();
39248 result = (arg1)->GetPosition();
39249
39250 wxPyEndAllowThreads(__tstate);
39251 if (PyErr_Occurred()) SWIG_fail;
39252 }
39253 {
39254 wxPoint * resultptr;
39255 resultptr = new wxPoint((wxPoint &)(result));
39256 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39257 }
39258 return resultobj;
39259 fail:
39260 return NULL;
39261 }
39262
39263
39264 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39265 PyObject *resultobj;
39266 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39267 PyObject *result;
39268 PyObject * obj0 = 0 ;
39269 char *kwnames[] = {
39270 (char *) "self", NULL
39271 };
39272
39273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39275 if (SWIG_arg_fail(1)) SWIG_fail;
39276 {
39277 PyThreadState* __tstate = wxPyBeginAllowThreads();
39278 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39279
39280 wxPyEndAllowThreads(__tstate);
39281 if (PyErr_Occurred()) SWIG_fail;
39282 }
39283 resultobj = result;
39284 return resultobj;
39285 fail:
39286 return NULL;
39287 }
39288
39289
39290 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39291 PyObject *obj;
39292 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39293 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39294 Py_INCREF(obj);
39295 return Py_BuildValue((char *)"");
39296 }
39297 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39298 PyObject *resultobj;
39299 wxSizer *arg1 = (wxSizer *) 0 ;
39300 PyObject *arg2 = (PyObject *) 0 ;
39301 PyObject * obj0 = 0 ;
39302 PyObject * obj1 = 0 ;
39303 char *kwnames[] = {
39304 (char *) "self",(char *) "_self", NULL
39305 };
39306
39307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39309 if (SWIG_arg_fail(1)) SWIG_fail;
39310 arg2 = obj1;
39311 {
39312 PyThreadState* __tstate = wxPyBeginAllowThreads();
39313 wxSizer__setOORInfo(arg1,arg2);
39314
39315 wxPyEndAllowThreads(__tstate);
39316 if (PyErr_Occurred()) SWIG_fail;
39317 }
39318 Py_INCREF(Py_None); resultobj = Py_None;
39319 return resultobj;
39320 fail:
39321 return NULL;
39322 }
39323
39324
39325 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39326 PyObject *resultobj;
39327 wxSizer *arg1 = (wxSizer *) 0 ;
39328 PyObject *arg2 = (PyObject *) 0 ;
39329 int arg3 = (int) 0 ;
39330 int arg4 = (int) 0 ;
39331 int arg5 = (int) 0 ;
39332 PyObject *arg6 = (PyObject *) NULL ;
39333 wxSizerItem *result;
39334 PyObject * obj0 = 0 ;
39335 PyObject * obj1 = 0 ;
39336 PyObject * obj2 = 0 ;
39337 PyObject * obj3 = 0 ;
39338 PyObject * obj4 = 0 ;
39339 PyObject * obj5 = 0 ;
39340 char *kwnames[] = {
39341 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39342 };
39343
39344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39346 if (SWIG_arg_fail(1)) SWIG_fail;
39347 arg2 = obj1;
39348 if (obj2) {
39349 {
39350 arg3 = (int)(SWIG_As_int(obj2));
39351 if (SWIG_arg_fail(3)) SWIG_fail;
39352 }
39353 }
39354 if (obj3) {
39355 {
39356 arg4 = (int)(SWIG_As_int(obj3));
39357 if (SWIG_arg_fail(4)) SWIG_fail;
39358 }
39359 }
39360 if (obj4) {
39361 {
39362 arg5 = (int)(SWIG_As_int(obj4));
39363 if (SWIG_arg_fail(5)) SWIG_fail;
39364 }
39365 }
39366 if (obj5) {
39367 arg6 = obj5;
39368 }
39369 {
39370 PyThreadState* __tstate = wxPyBeginAllowThreads();
39371 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39372
39373 wxPyEndAllowThreads(__tstate);
39374 if (PyErr_Occurred()) SWIG_fail;
39375 }
39376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39377 return resultobj;
39378 fail:
39379 return NULL;
39380 }
39381
39382
39383 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39384 PyObject *resultobj;
39385 wxSizer *arg1 = (wxSizer *) 0 ;
39386 int arg2 ;
39387 PyObject *arg3 = (PyObject *) 0 ;
39388 int arg4 = (int) 0 ;
39389 int arg5 = (int) 0 ;
39390 int arg6 = (int) 0 ;
39391 PyObject *arg7 = (PyObject *) NULL ;
39392 wxSizerItem *result;
39393 PyObject * obj0 = 0 ;
39394 PyObject * obj1 = 0 ;
39395 PyObject * obj2 = 0 ;
39396 PyObject * obj3 = 0 ;
39397 PyObject * obj4 = 0 ;
39398 PyObject * obj5 = 0 ;
39399 PyObject * obj6 = 0 ;
39400 char *kwnames[] = {
39401 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39402 };
39403
39404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39406 if (SWIG_arg_fail(1)) SWIG_fail;
39407 {
39408 arg2 = (int)(SWIG_As_int(obj1));
39409 if (SWIG_arg_fail(2)) SWIG_fail;
39410 }
39411 arg3 = obj2;
39412 if (obj3) {
39413 {
39414 arg4 = (int)(SWIG_As_int(obj3));
39415 if (SWIG_arg_fail(4)) SWIG_fail;
39416 }
39417 }
39418 if (obj4) {
39419 {
39420 arg5 = (int)(SWIG_As_int(obj4));
39421 if (SWIG_arg_fail(5)) SWIG_fail;
39422 }
39423 }
39424 if (obj5) {
39425 {
39426 arg6 = (int)(SWIG_As_int(obj5));
39427 if (SWIG_arg_fail(6)) SWIG_fail;
39428 }
39429 }
39430 if (obj6) {
39431 arg7 = obj6;
39432 }
39433 {
39434 PyThreadState* __tstate = wxPyBeginAllowThreads();
39435 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39436
39437 wxPyEndAllowThreads(__tstate);
39438 if (PyErr_Occurred()) SWIG_fail;
39439 }
39440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39441 return resultobj;
39442 fail:
39443 return NULL;
39444 }
39445
39446
39447 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39448 PyObject *resultobj;
39449 wxSizer *arg1 = (wxSizer *) 0 ;
39450 PyObject *arg2 = (PyObject *) 0 ;
39451 int arg3 = (int) 0 ;
39452 int arg4 = (int) 0 ;
39453 int arg5 = (int) 0 ;
39454 PyObject *arg6 = (PyObject *) NULL ;
39455 wxSizerItem *result;
39456 PyObject * obj0 = 0 ;
39457 PyObject * obj1 = 0 ;
39458 PyObject * obj2 = 0 ;
39459 PyObject * obj3 = 0 ;
39460 PyObject * obj4 = 0 ;
39461 PyObject * obj5 = 0 ;
39462 char *kwnames[] = {
39463 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39464 };
39465
39466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39468 if (SWIG_arg_fail(1)) SWIG_fail;
39469 arg2 = obj1;
39470 if (obj2) {
39471 {
39472 arg3 = (int)(SWIG_As_int(obj2));
39473 if (SWIG_arg_fail(3)) SWIG_fail;
39474 }
39475 }
39476 if (obj3) {
39477 {
39478 arg4 = (int)(SWIG_As_int(obj3));
39479 if (SWIG_arg_fail(4)) SWIG_fail;
39480 }
39481 }
39482 if (obj4) {
39483 {
39484 arg5 = (int)(SWIG_As_int(obj4));
39485 if (SWIG_arg_fail(5)) SWIG_fail;
39486 }
39487 }
39488 if (obj5) {
39489 arg6 = obj5;
39490 }
39491 {
39492 PyThreadState* __tstate = wxPyBeginAllowThreads();
39493 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39494
39495 wxPyEndAllowThreads(__tstate);
39496 if (PyErr_Occurred()) SWIG_fail;
39497 }
39498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39499 return resultobj;
39500 fail:
39501 return NULL;
39502 }
39503
39504
39505 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39506 PyObject *resultobj;
39507 wxSizer *arg1 = (wxSizer *) 0 ;
39508 PyObject *arg2 = (PyObject *) 0 ;
39509 bool result;
39510 PyObject * obj0 = 0 ;
39511 PyObject * obj1 = 0 ;
39512 char *kwnames[] = {
39513 (char *) "self",(char *) "item", NULL
39514 };
39515
39516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39518 if (SWIG_arg_fail(1)) SWIG_fail;
39519 arg2 = obj1;
39520 {
39521 PyThreadState* __tstate = wxPyBeginAllowThreads();
39522 result = (bool)wxSizer_Remove(arg1,arg2);
39523
39524 wxPyEndAllowThreads(__tstate);
39525 if (PyErr_Occurred()) SWIG_fail;
39526 }
39527 {
39528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39529 }
39530 return resultobj;
39531 fail:
39532 return NULL;
39533 }
39534
39535
39536 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39537 PyObject *resultobj;
39538 wxSizer *arg1 = (wxSizer *) 0 ;
39539 PyObject *arg2 = (PyObject *) 0 ;
39540 bool result;
39541 PyObject * obj0 = 0 ;
39542 PyObject * obj1 = 0 ;
39543 char *kwnames[] = {
39544 (char *) "self",(char *) "item", NULL
39545 };
39546
39547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39549 if (SWIG_arg_fail(1)) SWIG_fail;
39550 arg2 = obj1;
39551 {
39552 PyThreadState* __tstate = wxPyBeginAllowThreads();
39553 result = (bool)wxSizer_Detach(arg1,arg2);
39554
39555 wxPyEndAllowThreads(__tstate);
39556 if (PyErr_Occurred()) SWIG_fail;
39557 }
39558 {
39559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39560 }
39561 return resultobj;
39562 fail:
39563 return NULL;
39564 }
39565
39566
39567 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39568 PyObject *resultobj;
39569 wxSizer *arg1 = (wxSizer *) 0 ;
39570 PyObject *arg2 = (PyObject *) 0 ;
39571 wxSizerItem *result;
39572 PyObject * obj0 = 0 ;
39573 PyObject * obj1 = 0 ;
39574 char *kwnames[] = {
39575 (char *) "self",(char *) "item", NULL
39576 };
39577
39578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39580 if (SWIG_arg_fail(1)) SWIG_fail;
39581 arg2 = obj1;
39582 {
39583 PyThreadState* __tstate = wxPyBeginAllowThreads();
39584 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39585
39586 wxPyEndAllowThreads(__tstate);
39587 if (PyErr_Occurred()) SWIG_fail;
39588 }
39589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39590 return resultobj;
39591 fail:
39592 return NULL;
39593 }
39594
39595
39596 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39597 PyObject *resultobj;
39598 wxSizer *arg1 = (wxSizer *) 0 ;
39599 PyObject *arg2 = (PyObject *) 0 ;
39600 wxSize *arg3 = 0 ;
39601 wxSize temp3 ;
39602 PyObject * obj0 = 0 ;
39603 PyObject * obj1 = 0 ;
39604 PyObject * obj2 = 0 ;
39605 char *kwnames[] = {
39606 (char *) "self",(char *) "item",(char *) "size", NULL
39607 };
39608
39609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39611 if (SWIG_arg_fail(1)) SWIG_fail;
39612 arg2 = obj1;
39613 {
39614 arg3 = &temp3;
39615 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39616 }
39617 {
39618 PyThreadState* __tstate = wxPyBeginAllowThreads();
39619 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39620
39621 wxPyEndAllowThreads(__tstate);
39622 if (PyErr_Occurred()) SWIG_fail;
39623 }
39624 Py_INCREF(Py_None); resultobj = Py_None;
39625 return resultobj;
39626 fail:
39627 return NULL;
39628 }
39629
39630
39631 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39632 PyObject *resultobj;
39633 wxSizer *arg1 = (wxSizer *) 0 ;
39634 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39635 wxSizerItem *result;
39636 PyObject * obj0 = 0 ;
39637 PyObject * obj1 = 0 ;
39638 char *kwnames[] = {
39639 (char *) "self",(char *) "item", NULL
39640 };
39641
39642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39644 if (SWIG_arg_fail(1)) SWIG_fail;
39645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39646 if (SWIG_arg_fail(2)) SWIG_fail;
39647 {
39648 PyThreadState* __tstate = wxPyBeginAllowThreads();
39649 result = (wxSizerItem *)(arg1)->Add(arg2);
39650
39651 wxPyEndAllowThreads(__tstate);
39652 if (PyErr_Occurred()) SWIG_fail;
39653 }
39654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39655 return resultobj;
39656 fail:
39657 return NULL;
39658 }
39659
39660
39661 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39662 PyObject *resultobj;
39663 wxSizer *arg1 = (wxSizer *) 0 ;
39664 size_t arg2 ;
39665 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39666 wxSizerItem *result;
39667 PyObject * obj0 = 0 ;
39668 PyObject * obj1 = 0 ;
39669 PyObject * obj2 = 0 ;
39670 char *kwnames[] = {
39671 (char *) "self",(char *) "index",(char *) "item", NULL
39672 };
39673
39674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39676 if (SWIG_arg_fail(1)) SWIG_fail;
39677 {
39678 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39679 if (SWIG_arg_fail(2)) SWIG_fail;
39680 }
39681 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39682 if (SWIG_arg_fail(3)) SWIG_fail;
39683 {
39684 PyThreadState* __tstate = wxPyBeginAllowThreads();
39685 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39686
39687 wxPyEndAllowThreads(__tstate);
39688 if (PyErr_Occurred()) SWIG_fail;
39689 }
39690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39691 return resultobj;
39692 fail:
39693 return NULL;
39694 }
39695
39696
39697 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39698 PyObject *resultobj;
39699 wxSizer *arg1 = (wxSizer *) 0 ;
39700 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39701 wxSizerItem *result;
39702 PyObject * obj0 = 0 ;
39703 PyObject * obj1 = 0 ;
39704 char *kwnames[] = {
39705 (char *) "self",(char *) "item", NULL
39706 };
39707
39708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39710 if (SWIG_arg_fail(1)) SWIG_fail;
39711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39712 if (SWIG_arg_fail(2)) SWIG_fail;
39713 {
39714 PyThreadState* __tstate = wxPyBeginAllowThreads();
39715 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39716
39717 wxPyEndAllowThreads(__tstate);
39718 if (PyErr_Occurred()) SWIG_fail;
39719 }
39720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39721 return resultobj;
39722 fail:
39723 return NULL;
39724 }
39725
39726
39727 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39728 PyObject *resultobj;
39729 wxSizer *arg1 = (wxSizer *) 0 ;
39730 int arg2 ;
39731 int arg3 ;
39732 int arg4 ;
39733 int arg5 ;
39734 PyObject * obj0 = 0 ;
39735 PyObject * obj1 = 0 ;
39736 PyObject * obj2 = 0 ;
39737 PyObject * obj3 = 0 ;
39738 PyObject * obj4 = 0 ;
39739 char *kwnames[] = {
39740 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39741 };
39742
39743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39745 if (SWIG_arg_fail(1)) SWIG_fail;
39746 {
39747 arg2 = (int)(SWIG_As_int(obj1));
39748 if (SWIG_arg_fail(2)) SWIG_fail;
39749 }
39750 {
39751 arg3 = (int)(SWIG_As_int(obj2));
39752 if (SWIG_arg_fail(3)) SWIG_fail;
39753 }
39754 {
39755 arg4 = (int)(SWIG_As_int(obj3));
39756 if (SWIG_arg_fail(4)) SWIG_fail;
39757 }
39758 {
39759 arg5 = (int)(SWIG_As_int(obj4));
39760 if (SWIG_arg_fail(5)) SWIG_fail;
39761 }
39762 {
39763 PyThreadState* __tstate = wxPyBeginAllowThreads();
39764 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39765
39766 wxPyEndAllowThreads(__tstate);
39767 if (PyErr_Occurred()) SWIG_fail;
39768 }
39769 Py_INCREF(Py_None); resultobj = Py_None;
39770 return resultobj;
39771 fail:
39772 return NULL;
39773 }
39774
39775
39776 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39777 PyObject *resultobj;
39778 wxSizer *arg1 = (wxSizer *) 0 ;
39779 wxSize *arg2 = 0 ;
39780 wxSize temp2 ;
39781 PyObject * obj0 = 0 ;
39782 PyObject * obj1 = 0 ;
39783 char *kwnames[] = {
39784 (char *) "self",(char *) "size", NULL
39785 };
39786
39787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39789 if (SWIG_arg_fail(1)) SWIG_fail;
39790 {
39791 arg2 = &temp2;
39792 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39793 }
39794 {
39795 PyThreadState* __tstate = wxPyBeginAllowThreads();
39796 (arg1)->SetMinSize((wxSize const &)*arg2);
39797
39798 wxPyEndAllowThreads(__tstate);
39799 if (PyErr_Occurred()) SWIG_fail;
39800 }
39801 Py_INCREF(Py_None); resultobj = Py_None;
39802 return resultobj;
39803 fail:
39804 return NULL;
39805 }
39806
39807
39808 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39809 PyObject *resultobj;
39810 wxSizer *arg1 = (wxSizer *) 0 ;
39811 wxSize result;
39812 PyObject * obj0 = 0 ;
39813 char *kwnames[] = {
39814 (char *) "self", NULL
39815 };
39816
39817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39819 if (SWIG_arg_fail(1)) SWIG_fail;
39820 {
39821 PyThreadState* __tstate = wxPyBeginAllowThreads();
39822 result = (arg1)->GetSize();
39823
39824 wxPyEndAllowThreads(__tstate);
39825 if (PyErr_Occurred()) SWIG_fail;
39826 }
39827 {
39828 wxSize * resultptr;
39829 resultptr = new wxSize((wxSize &)(result));
39830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39831 }
39832 return resultobj;
39833 fail:
39834 return NULL;
39835 }
39836
39837
39838 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39839 PyObject *resultobj;
39840 wxSizer *arg1 = (wxSizer *) 0 ;
39841 wxPoint result;
39842 PyObject * obj0 = 0 ;
39843 char *kwnames[] = {
39844 (char *) "self", NULL
39845 };
39846
39847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39849 if (SWIG_arg_fail(1)) SWIG_fail;
39850 {
39851 PyThreadState* __tstate = wxPyBeginAllowThreads();
39852 result = (arg1)->GetPosition();
39853
39854 wxPyEndAllowThreads(__tstate);
39855 if (PyErr_Occurred()) SWIG_fail;
39856 }
39857 {
39858 wxPoint * resultptr;
39859 resultptr = new wxPoint((wxPoint &)(result));
39860 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39861 }
39862 return resultobj;
39863 fail:
39864 return NULL;
39865 }
39866
39867
39868 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39869 PyObject *resultobj;
39870 wxSizer *arg1 = (wxSizer *) 0 ;
39871 wxSize result;
39872 PyObject * obj0 = 0 ;
39873 char *kwnames[] = {
39874 (char *) "self", NULL
39875 };
39876
39877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39879 if (SWIG_arg_fail(1)) SWIG_fail;
39880 {
39881 PyThreadState* __tstate = wxPyBeginAllowThreads();
39882 result = (arg1)->GetMinSize();
39883
39884 wxPyEndAllowThreads(__tstate);
39885 if (PyErr_Occurred()) SWIG_fail;
39886 }
39887 {
39888 wxSize * resultptr;
39889 resultptr = new wxSize((wxSize &)(result));
39890 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39891 }
39892 return resultobj;
39893 fail:
39894 return NULL;
39895 }
39896
39897
39898 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39899 PyObject *resultobj;
39900 wxSizer *arg1 = (wxSizer *) 0 ;
39901 PyObject * obj0 = 0 ;
39902 char *kwnames[] = {
39903 (char *) "self", NULL
39904 };
39905
39906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39908 if (SWIG_arg_fail(1)) SWIG_fail;
39909 {
39910 PyThreadState* __tstate = wxPyBeginAllowThreads();
39911 (arg1)->RecalcSizes();
39912
39913 wxPyEndAllowThreads(__tstate);
39914 if (PyErr_Occurred()) SWIG_fail;
39915 }
39916 Py_INCREF(Py_None); resultobj = Py_None;
39917 return resultobj;
39918 fail:
39919 return NULL;
39920 }
39921
39922
39923 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39924 PyObject *resultobj;
39925 wxSizer *arg1 = (wxSizer *) 0 ;
39926 wxSize result;
39927 PyObject * obj0 = 0 ;
39928 char *kwnames[] = {
39929 (char *) "self", NULL
39930 };
39931
39932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39934 if (SWIG_arg_fail(1)) SWIG_fail;
39935 {
39936 PyThreadState* __tstate = wxPyBeginAllowThreads();
39937 result = (arg1)->CalcMin();
39938
39939 wxPyEndAllowThreads(__tstate);
39940 if (PyErr_Occurred()) SWIG_fail;
39941 }
39942 {
39943 wxSize * resultptr;
39944 resultptr = new wxSize((wxSize &)(result));
39945 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39946 }
39947 return resultobj;
39948 fail:
39949 return NULL;
39950 }
39951
39952
39953 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39954 PyObject *resultobj;
39955 wxSizer *arg1 = (wxSizer *) 0 ;
39956 PyObject * obj0 = 0 ;
39957 char *kwnames[] = {
39958 (char *) "self", NULL
39959 };
39960
39961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39963 if (SWIG_arg_fail(1)) SWIG_fail;
39964 {
39965 PyThreadState* __tstate = wxPyBeginAllowThreads();
39966 (arg1)->Layout();
39967
39968 wxPyEndAllowThreads(__tstate);
39969 if (PyErr_Occurred()) SWIG_fail;
39970 }
39971 Py_INCREF(Py_None); resultobj = Py_None;
39972 return resultobj;
39973 fail:
39974 return NULL;
39975 }
39976
39977
39978 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39979 PyObject *resultobj;
39980 wxSizer *arg1 = (wxSizer *) 0 ;
39981 wxWindow *arg2 = (wxWindow *) 0 ;
39982 wxSize result;
39983 PyObject * obj0 = 0 ;
39984 PyObject * obj1 = 0 ;
39985 char *kwnames[] = {
39986 (char *) "self",(char *) "window", NULL
39987 };
39988
39989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39991 if (SWIG_arg_fail(1)) SWIG_fail;
39992 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39993 if (SWIG_arg_fail(2)) SWIG_fail;
39994 {
39995 PyThreadState* __tstate = wxPyBeginAllowThreads();
39996 result = (arg1)->Fit(arg2);
39997
39998 wxPyEndAllowThreads(__tstate);
39999 if (PyErr_Occurred()) SWIG_fail;
40000 }
40001 {
40002 wxSize * resultptr;
40003 resultptr = new wxSize((wxSize &)(result));
40004 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40005 }
40006 return resultobj;
40007 fail:
40008 return NULL;
40009 }
40010
40011
40012 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40013 PyObject *resultobj;
40014 wxSizer *arg1 = (wxSizer *) 0 ;
40015 wxWindow *arg2 = (wxWindow *) 0 ;
40016 PyObject * obj0 = 0 ;
40017 PyObject * obj1 = 0 ;
40018 char *kwnames[] = {
40019 (char *) "self",(char *) "window", NULL
40020 };
40021
40022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40024 if (SWIG_arg_fail(1)) SWIG_fail;
40025 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40026 if (SWIG_arg_fail(2)) SWIG_fail;
40027 {
40028 PyThreadState* __tstate = wxPyBeginAllowThreads();
40029 (arg1)->FitInside(arg2);
40030
40031 wxPyEndAllowThreads(__tstate);
40032 if (PyErr_Occurred()) SWIG_fail;
40033 }
40034 Py_INCREF(Py_None); resultobj = Py_None;
40035 return resultobj;
40036 fail:
40037 return NULL;
40038 }
40039
40040
40041 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40042 PyObject *resultobj;
40043 wxSizer *arg1 = (wxSizer *) 0 ;
40044 wxWindow *arg2 = (wxWindow *) 0 ;
40045 PyObject * obj0 = 0 ;
40046 PyObject * obj1 = 0 ;
40047 char *kwnames[] = {
40048 (char *) "self",(char *) "window", NULL
40049 };
40050
40051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40053 if (SWIG_arg_fail(1)) SWIG_fail;
40054 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40055 if (SWIG_arg_fail(2)) SWIG_fail;
40056 {
40057 PyThreadState* __tstate = wxPyBeginAllowThreads();
40058 (arg1)->SetSizeHints(arg2);
40059
40060 wxPyEndAllowThreads(__tstate);
40061 if (PyErr_Occurred()) SWIG_fail;
40062 }
40063 Py_INCREF(Py_None); resultobj = Py_None;
40064 return resultobj;
40065 fail:
40066 return NULL;
40067 }
40068
40069
40070 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40071 PyObject *resultobj;
40072 wxSizer *arg1 = (wxSizer *) 0 ;
40073 wxWindow *arg2 = (wxWindow *) 0 ;
40074 PyObject * obj0 = 0 ;
40075 PyObject * obj1 = 0 ;
40076 char *kwnames[] = {
40077 (char *) "self",(char *) "window", NULL
40078 };
40079
40080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40082 if (SWIG_arg_fail(1)) SWIG_fail;
40083 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40084 if (SWIG_arg_fail(2)) SWIG_fail;
40085 {
40086 PyThreadState* __tstate = wxPyBeginAllowThreads();
40087 (arg1)->SetVirtualSizeHints(arg2);
40088
40089 wxPyEndAllowThreads(__tstate);
40090 if (PyErr_Occurred()) SWIG_fail;
40091 }
40092 Py_INCREF(Py_None); resultobj = Py_None;
40093 return resultobj;
40094 fail:
40095 return NULL;
40096 }
40097
40098
40099 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40100 PyObject *resultobj;
40101 wxSizer *arg1 = (wxSizer *) 0 ;
40102 bool arg2 = (bool) false ;
40103 PyObject * obj0 = 0 ;
40104 PyObject * obj1 = 0 ;
40105 char *kwnames[] = {
40106 (char *) "self",(char *) "deleteWindows", NULL
40107 };
40108
40109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40111 if (SWIG_arg_fail(1)) SWIG_fail;
40112 if (obj1) {
40113 {
40114 arg2 = (bool)(SWIG_As_bool(obj1));
40115 if (SWIG_arg_fail(2)) SWIG_fail;
40116 }
40117 }
40118 {
40119 PyThreadState* __tstate = wxPyBeginAllowThreads();
40120 (arg1)->Clear(arg2);
40121
40122 wxPyEndAllowThreads(__tstate);
40123 if (PyErr_Occurred()) SWIG_fail;
40124 }
40125 Py_INCREF(Py_None); resultobj = Py_None;
40126 return resultobj;
40127 fail:
40128 return NULL;
40129 }
40130
40131
40132 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40133 PyObject *resultobj;
40134 wxSizer *arg1 = (wxSizer *) 0 ;
40135 PyObject * obj0 = 0 ;
40136 char *kwnames[] = {
40137 (char *) "self", NULL
40138 };
40139
40140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40142 if (SWIG_arg_fail(1)) SWIG_fail;
40143 {
40144 PyThreadState* __tstate = wxPyBeginAllowThreads();
40145 (arg1)->DeleteWindows();
40146
40147 wxPyEndAllowThreads(__tstate);
40148 if (PyErr_Occurred()) SWIG_fail;
40149 }
40150 Py_INCREF(Py_None); resultobj = Py_None;
40151 return resultobj;
40152 fail:
40153 return NULL;
40154 }
40155
40156
40157 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40158 PyObject *resultobj;
40159 wxSizer *arg1 = (wxSizer *) 0 ;
40160 PyObject *result;
40161 PyObject * obj0 = 0 ;
40162 char *kwnames[] = {
40163 (char *) "self", NULL
40164 };
40165
40166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40168 if (SWIG_arg_fail(1)) SWIG_fail;
40169 {
40170 PyThreadState* __tstate = wxPyBeginAllowThreads();
40171 result = (PyObject *)wxSizer_GetChildren(arg1);
40172
40173 wxPyEndAllowThreads(__tstate);
40174 if (PyErr_Occurred()) SWIG_fail;
40175 }
40176 resultobj = result;
40177 return resultobj;
40178 fail:
40179 return NULL;
40180 }
40181
40182
40183 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40184 PyObject *resultobj;
40185 wxSizer *arg1 = (wxSizer *) 0 ;
40186 PyObject *arg2 = (PyObject *) 0 ;
40187 bool arg3 = (bool) true ;
40188 bool arg4 = (bool) false ;
40189 bool result;
40190 PyObject * obj0 = 0 ;
40191 PyObject * obj1 = 0 ;
40192 PyObject * obj2 = 0 ;
40193 PyObject * obj3 = 0 ;
40194 char *kwnames[] = {
40195 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40196 };
40197
40198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40200 if (SWIG_arg_fail(1)) SWIG_fail;
40201 arg2 = obj1;
40202 if (obj2) {
40203 {
40204 arg3 = (bool)(SWIG_As_bool(obj2));
40205 if (SWIG_arg_fail(3)) SWIG_fail;
40206 }
40207 }
40208 if (obj3) {
40209 {
40210 arg4 = (bool)(SWIG_As_bool(obj3));
40211 if (SWIG_arg_fail(4)) SWIG_fail;
40212 }
40213 }
40214 {
40215 PyThreadState* __tstate = wxPyBeginAllowThreads();
40216 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40217
40218 wxPyEndAllowThreads(__tstate);
40219 if (PyErr_Occurred()) SWIG_fail;
40220 }
40221 {
40222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40223 }
40224 return resultobj;
40225 fail:
40226 return NULL;
40227 }
40228
40229
40230 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40231 PyObject *resultobj;
40232 wxSizer *arg1 = (wxSizer *) 0 ;
40233 PyObject *arg2 = (PyObject *) 0 ;
40234 bool result;
40235 PyObject * obj0 = 0 ;
40236 PyObject * obj1 = 0 ;
40237 char *kwnames[] = {
40238 (char *) "self",(char *) "item", NULL
40239 };
40240
40241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40243 if (SWIG_arg_fail(1)) SWIG_fail;
40244 arg2 = obj1;
40245 {
40246 PyThreadState* __tstate = wxPyBeginAllowThreads();
40247 result = (bool)wxSizer_IsShown(arg1,arg2);
40248
40249 wxPyEndAllowThreads(__tstate);
40250 if (PyErr_Occurred()) SWIG_fail;
40251 }
40252 {
40253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40254 }
40255 return resultobj;
40256 fail:
40257 return NULL;
40258 }
40259
40260
40261 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40262 PyObject *resultobj;
40263 wxSizer *arg1 = (wxSizer *) 0 ;
40264 bool arg2 ;
40265 PyObject * obj0 = 0 ;
40266 PyObject * obj1 = 0 ;
40267 char *kwnames[] = {
40268 (char *) "self",(char *) "show", NULL
40269 };
40270
40271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40273 if (SWIG_arg_fail(1)) SWIG_fail;
40274 {
40275 arg2 = (bool)(SWIG_As_bool(obj1));
40276 if (SWIG_arg_fail(2)) SWIG_fail;
40277 }
40278 {
40279 PyThreadState* __tstate = wxPyBeginAllowThreads();
40280 (arg1)->ShowItems(arg2);
40281
40282 wxPyEndAllowThreads(__tstate);
40283 if (PyErr_Occurred()) SWIG_fail;
40284 }
40285 Py_INCREF(Py_None); resultobj = Py_None;
40286 return resultobj;
40287 fail:
40288 return NULL;
40289 }
40290
40291
40292 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40293 PyObject *obj;
40294 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40295 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40296 Py_INCREF(obj);
40297 return Py_BuildValue((char *)"");
40298 }
40299 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40300 PyObject *resultobj;
40301 wxPySizer *result;
40302 char *kwnames[] = {
40303 NULL
40304 };
40305
40306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40307 {
40308 PyThreadState* __tstate = wxPyBeginAllowThreads();
40309 result = (wxPySizer *)new wxPySizer();
40310
40311 wxPyEndAllowThreads(__tstate);
40312 if (PyErr_Occurred()) SWIG_fail;
40313 }
40314 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40315 return resultobj;
40316 fail:
40317 return NULL;
40318 }
40319
40320
40321 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40322 PyObject *resultobj;
40323 wxPySizer *arg1 = (wxPySizer *) 0 ;
40324 PyObject *arg2 = (PyObject *) 0 ;
40325 PyObject *arg3 = (PyObject *) 0 ;
40326 PyObject * obj0 = 0 ;
40327 PyObject * obj1 = 0 ;
40328 PyObject * obj2 = 0 ;
40329 char *kwnames[] = {
40330 (char *) "self",(char *) "self",(char *) "_class", NULL
40331 };
40332
40333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40335 if (SWIG_arg_fail(1)) SWIG_fail;
40336 arg2 = obj1;
40337 arg3 = obj2;
40338 {
40339 PyThreadState* __tstate = wxPyBeginAllowThreads();
40340 (arg1)->_setCallbackInfo(arg2,arg3);
40341
40342 wxPyEndAllowThreads(__tstate);
40343 if (PyErr_Occurred()) SWIG_fail;
40344 }
40345 Py_INCREF(Py_None); resultobj = Py_None;
40346 return resultobj;
40347 fail:
40348 return NULL;
40349 }
40350
40351
40352 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40353 PyObject *obj;
40354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40355 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40356 Py_INCREF(obj);
40357 return Py_BuildValue((char *)"");
40358 }
40359 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40360 PyObject *resultobj;
40361 int arg1 = (int) wxHORIZONTAL ;
40362 wxBoxSizer *result;
40363 PyObject * obj0 = 0 ;
40364 char *kwnames[] = {
40365 (char *) "orient", NULL
40366 };
40367
40368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40369 if (obj0) {
40370 {
40371 arg1 = (int)(SWIG_As_int(obj0));
40372 if (SWIG_arg_fail(1)) SWIG_fail;
40373 }
40374 }
40375 {
40376 PyThreadState* __tstate = wxPyBeginAllowThreads();
40377 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40378
40379 wxPyEndAllowThreads(__tstate);
40380 if (PyErr_Occurred()) SWIG_fail;
40381 }
40382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40383 return resultobj;
40384 fail:
40385 return NULL;
40386 }
40387
40388
40389 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40390 PyObject *resultobj;
40391 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40392 int result;
40393 PyObject * obj0 = 0 ;
40394 char *kwnames[] = {
40395 (char *) "self", NULL
40396 };
40397
40398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40400 if (SWIG_arg_fail(1)) SWIG_fail;
40401 {
40402 PyThreadState* __tstate = wxPyBeginAllowThreads();
40403 result = (int)(arg1)->GetOrientation();
40404
40405 wxPyEndAllowThreads(__tstate);
40406 if (PyErr_Occurred()) SWIG_fail;
40407 }
40408 {
40409 resultobj = SWIG_From_int((int)(result));
40410 }
40411 return resultobj;
40412 fail:
40413 return NULL;
40414 }
40415
40416
40417 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40418 PyObject *resultobj;
40419 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40420 int arg2 ;
40421 PyObject * obj0 = 0 ;
40422 PyObject * obj1 = 0 ;
40423 char *kwnames[] = {
40424 (char *) "self",(char *) "orient", NULL
40425 };
40426
40427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40429 if (SWIG_arg_fail(1)) SWIG_fail;
40430 {
40431 arg2 = (int)(SWIG_As_int(obj1));
40432 if (SWIG_arg_fail(2)) SWIG_fail;
40433 }
40434 {
40435 PyThreadState* __tstate = wxPyBeginAllowThreads();
40436 (arg1)->SetOrientation(arg2);
40437
40438 wxPyEndAllowThreads(__tstate);
40439 if (PyErr_Occurred()) SWIG_fail;
40440 }
40441 Py_INCREF(Py_None); resultobj = Py_None;
40442 return resultobj;
40443 fail:
40444 return NULL;
40445 }
40446
40447
40448 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40449 PyObject *obj;
40450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40451 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40452 Py_INCREF(obj);
40453 return Py_BuildValue((char *)"");
40454 }
40455 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40456 PyObject *resultobj;
40457 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40458 int arg2 = (int) wxHORIZONTAL ;
40459 wxStaticBoxSizer *result;
40460 PyObject * obj0 = 0 ;
40461 PyObject * obj1 = 0 ;
40462 char *kwnames[] = {
40463 (char *) "box",(char *) "orient", NULL
40464 };
40465
40466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40468 if (SWIG_arg_fail(1)) SWIG_fail;
40469 if (obj1) {
40470 {
40471 arg2 = (int)(SWIG_As_int(obj1));
40472 if (SWIG_arg_fail(2)) SWIG_fail;
40473 }
40474 }
40475 {
40476 PyThreadState* __tstate = wxPyBeginAllowThreads();
40477 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40478
40479 wxPyEndAllowThreads(__tstate);
40480 if (PyErr_Occurred()) SWIG_fail;
40481 }
40482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40483 return resultobj;
40484 fail:
40485 return NULL;
40486 }
40487
40488
40489 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40490 PyObject *resultobj;
40491 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40492 wxStaticBox *result;
40493 PyObject * obj0 = 0 ;
40494 char *kwnames[] = {
40495 (char *) "self", NULL
40496 };
40497
40498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40500 if (SWIG_arg_fail(1)) SWIG_fail;
40501 {
40502 PyThreadState* __tstate = wxPyBeginAllowThreads();
40503 result = (wxStaticBox *)(arg1)->GetStaticBox();
40504
40505 wxPyEndAllowThreads(__tstate);
40506 if (PyErr_Occurred()) SWIG_fail;
40507 }
40508 {
40509 resultobj = wxPyMake_wxObject(result, 0);
40510 }
40511 return resultobj;
40512 fail:
40513 return NULL;
40514 }
40515
40516
40517 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40518 PyObject *obj;
40519 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40520 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40521 Py_INCREF(obj);
40522 return Py_BuildValue((char *)"");
40523 }
40524 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40525 PyObject *resultobj;
40526 int arg1 = (int) 1 ;
40527 int arg2 = (int) 0 ;
40528 int arg3 = (int) 0 ;
40529 int arg4 = (int) 0 ;
40530 wxGridSizer *result;
40531 PyObject * obj0 = 0 ;
40532 PyObject * obj1 = 0 ;
40533 PyObject * obj2 = 0 ;
40534 PyObject * obj3 = 0 ;
40535 char *kwnames[] = {
40536 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40537 };
40538
40539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40540 if (obj0) {
40541 {
40542 arg1 = (int)(SWIG_As_int(obj0));
40543 if (SWIG_arg_fail(1)) SWIG_fail;
40544 }
40545 }
40546 if (obj1) {
40547 {
40548 arg2 = (int)(SWIG_As_int(obj1));
40549 if (SWIG_arg_fail(2)) SWIG_fail;
40550 }
40551 }
40552 if (obj2) {
40553 {
40554 arg3 = (int)(SWIG_As_int(obj2));
40555 if (SWIG_arg_fail(3)) SWIG_fail;
40556 }
40557 }
40558 if (obj3) {
40559 {
40560 arg4 = (int)(SWIG_As_int(obj3));
40561 if (SWIG_arg_fail(4)) SWIG_fail;
40562 }
40563 }
40564 {
40565 PyThreadState* __tstate = wxPyBeginAllowThreads();
40566 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40567
40568 wxPyEndAllowThreads(__tstate);
40569 if (PyErr_Occurred()) SWIG_fail;
40570 }
40571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40572 return resultobj;
40573 fail:
40574 return NULL;
40575 }
40576
40577
40578 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40579 PyObject *resultobj;
40580 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40581 int arg2 ;
40582 PyObject * obj0 = 0 ;
40583 PyObject * obj1 = 0 ;
40584 char *kwnames[] = {
40585 (char *) "self",(char *) "cols", NULL
40586 };
40587
40588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40590 if (SWIG_arg_fail(1)) SWIG_fail;
40591 {
40592 arg2 = (int)(SWIG_As_int(obj1));
40593 if (SWIG_arg_fail(2)) SWIG_fail;
40594 }
40595 {
40596 PyThreadState* __tstate = wxPyBeginAllowThreads();
40597 (arg1)->SetCols(arg2);
40598
40599 wxPyEndAllowThreads(__tstate);
40600 if (PyErr_Occurred()) SWIG_fail;
40601 }
40602 Py_INCREF(Py_None); resultobj = Py_None;
40603 return resultobj;
40604 fail:
40605 return NULL;
40606 }
40607
40608
40609 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40610 PyObject *resultobj;
40611 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40612 int arg2 ;
40613 PyObject * obj0 = 0 ;
40614 PyObject * obj1 = 0 ;
40615 char *kwnames[] = {
40616 (char *) "self",(char *) "rows", NULL
40617 };
40618
40619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40621 if (SWIG_arg_fail(1)) SWIG_fail;
40622 {
40623 arg2 = (int)(SWIG_As_int(obj1));
40624 if (SWIG_arg_fail(2)) SWIG_fail;
40625 }
40626 {
40627 PyThreadState* __tstate = wxPyBeginAllowThreads();
40628 (arg1)->SetRows(arg2);
40629
40630 wxPyEndAllowThreads(__tstate);
40631 if (PyErr_Occurred()) SWIG_fail;
40632 }
40633 Py_INCREF(Py_None); resultobj = Py_None;
40634 return resultobj;
40635 fail:
40636 return NULL;
40637 }
40638
40639
40640 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40641 PyObject *resultobj;
40642 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40643 int arg2 ;
40644 PyObject * obj0 = 0 ;
40645 PyObject * obj1 = 0 ;
40646 char *kwnames[] = {
40647 (char *) "self",(char *) "gap", NULL
40648 };
40649
40650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40652 if (SWIG_arg_fail(1)) SWIG_fail;
40653 {
40654 arg2 = (int)(SWIG_As_int(obj1));
40655 if (SWIG_arg_fail(2)) SWIG_fail;
40656 }
40657 {
40658 PyThreadState* __tstate = wxPyBeginAllowThreads();
40659 (arg1)->SetVGap(arg2);
40660
40661 wxPyEndAllowThreads(__tstate);
40662 if (PyErr_Occurred()) SWIG_fail;
40663 }
40664 Py_INCREF(Py_None); resultobj = Py_None;
40665 return resultobj;
40666 fail:
40667 return NULL;
40668 }
40669
40670
40671 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40672 PyObject *resultobj;
40673 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40674 int arg2 ;
40675 PyObject * obj0 = 0 ;
40676 PyObject * obj1 = 0 ;
40677 char *kwnames[] = {
40678 (char *) "self",(char *) "gap", NULL
40679 };
40680
40681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40683 if (SWIG_arg_fail(1)) SWIG_fail;
40684 {
40685 arg2 = (int)(SWIG_As_int(obj1));
40686 if (SWIG_arg_fail(2)) SWIG_fail;
40687 }
40688 {
40689 PyThreadState* __tstate = wxPyBeginAllowThreads();
40690 (arg1)->SetHGap(arg2);
40691
40692 wxPyEndAllowThreads(__tstate);
40693 if (PyErr_Occurred()) SWIG_fail;
40694 }
40695 Py_INCREF(Py_None); resultobj = Py_None;
40696 return resultobj;
40697 fail:
40698 return NULL;
40699 }
40700
40701
40702 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40703 PyObject *resultobj;
40704 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40705 int result;
40706 PyObject * obj0 = 0 ;
40707 char *kwnames[] = {
40708 (char *) "self", NULL
40709 };
40710
40711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40713 if (SWIG_arg_fail(1)) SWIG_fail;
40714 {
40715 PyThreadState* __tstate = wxPyBeginAllowThreads();
40716 result = (int)(arg1)->GetCols();
40717
40718 wxPyEndAllowThreads(__tstate);
40719 if (PyErr_Occurred()) SWIG_fail;
40720 }
40721 {
40722 resultobj = SWIG_From_int((int)(result));
40723 }
40724 return resultobj;
40725 fail:
40726 return NULL;
40727 }
40728
40729
40730 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40731 PyObject *resultobj;
40732 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40733 int result;
40734 PyObject * obj0 = 0 ;
40735 char *kwnames[] = {
40736 (char *) "self", NULL
40737 };
40738
40739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40741 if (SWIG_arg_fail(1)) SWIG_fail;
40742 {
40743 PyThreadState* __tstate = wxPyBeginAllowThreads();
40744 result = (int)(arg1)->GetRows();
40745
40746 wxPyEndAllowThreads(__tstate);
40747 if (PyErr_Occurred()) SWIG_fail;
40748 }
40749 {
40750 resultobj = SWIG_From_int((int)(result));
40751 }
40752 return resultobj;
40753 fail:
40754 return NULL;
40755 }
40756
40757
40758 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40759 PyObject *resultobj;
40760 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40761 int result;
40762 PyObject * obj0 = 0 ;
40763 char *kwnames[] = {
40764 (char *) "self", NULL
40765 };
40766
40767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40769 if (SWIG_arg_fail(1)) SWIG_fail;
40770 {
40771 PyThreadState* __tstate = wxPyBeginAllowThreads();
40772 result = (int)(arg1)->GetVGap();
40773
40774 wxPyEndAllowThreads(__tstate);
40775 if (PyErr_Occurred()) SWIG_fail;
40776 }
40777 {
40778 resultobj = SWIG_From_int((int)(result));
40779 }
40780 return resultobj;
40781 fail:
40782 return NULL;
40783 }
40784
40785
40786 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40787 PyObject *resultobj;
40788 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40789 int result;
40790 PyObject * obj0 = 0 ;
40791 char *kwnames[] = {
40792 (char *) "self", NULL
40793 };
40794
40795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40797 if (SWIG_arg_fail(1)) SWIG_fail;
40798 {
40799 PyThreadState* __tstate = wxPyBeginAllowThreads();
40800 result = (int)(arg1)->GetHGap();
40801
40802 wxPyEndAllowThreads(__tstate);
40803 if (PyErr_Occurred()) SWIG_fail;
40804 }
40805 {
40806 resultobj = SWIG_From_int((int)(result));
40807 }
40808 return resultobj;
40809 fail:
40810 return NULL;
40811 }
40812
40813
40814 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40815 PyObject *obj;
40816 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40817 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40818 Py_INCREF(obj);
40819 return Py_BuildValue((char *)"");
40820 }
40821 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40822 PyObject *resultobj;
40823 int arg1 = (int) 1 ;
40824 int arg2 = (int) 0 ;
40825 int arg3 = (int) 0 ;
40826 int arg4 = (int) 0 ;
40827 wxFlexGridSizer *result;
40828 PyObject * obj0 = 0 ;
40829 PyObject * obj1 = 0 ;
40830 PyObject * obj2 = 0 ;
40831 PyObject * obj3 = 0 ;
40832 char *kwnames[] = {
40833 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40834 };
40835
40836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40837 if (obj0) {
40838 {
40839 arg1 = (int)(SWIG_As_int(obj0));
40840 if (SWIG_arg_fail(1)) SWIG_fail;
40841 }
40842 }
40843 if (obj1) {
40844 {
40845 arg2 = (int)(SWIG_As_int(obj1));
40846 if (SWIG_arg_fail(2)) SWIG_fail;
40847 }
40848 }
40849 if (obj2) {
40850 {
40851 arg3 = (int)(SWIG_As_int(obj2));
40852 if (SWIG_arg_fail(3)) SWIG_fail;
40853 }
40854 }
40855 if (obj3) {
40856 {
40857 arg4 = (int)(SWIG_As_int(obj3));
40858 if (SWIG_arg_fail(4)) SWIG_fail;
40859 }
40860 }
40861 {
40862 PyThreadState* __tstate = wxPyBeginAllowThreads();
40863 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40864
40865 wxPyEndAllowThreads(__tstate);
40866 if (PyErr_Occurred()) SWIG_fail;
40867 }
40868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40869 return resultobj;
40870 fail:
40871 return NULL;
40872 }
40873
40874
40875 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40876 PyObject *resultobj;
40877 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40878 size_t arg2 ;
40879 int arg3 = (int) 0 ;
40880 PyObject * obj0 = 0 ;
40881 PyObject * obj1 = 0 ;
40882 PyObject * obj2 = 0 ;
40883 char *kwnames[] = {
40884 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40885 };
40886
40887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40889 if (SWIG_arg_fail(1)) SWIG_fail;
40890 {
40891 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40892 if (SWIG_arg_fail(2)) SWIG_fail;
40893 }
40894 if (obj2) {
40895 {
40896 arg3 = (int)(SWIG_As_int(obj2));
40897 if (SWIG_arg_fail(3)) SWIG_fail;
40898 }
40899 }
40900 {
40901 PyThreadState* __tstate = wxPyBeginAllowThreads();
40902 (arg1)->AddGrowableRow(arg2,arg3);
40903
40904 wxPyEndAllowThreads(__tstate);
40905 if (PyErr_Occurred()) SWIG_fail;
40906 }
40907 Py_INCREF(Py_None); resultobj = Py_None;
40908 return resultobj;
40909 fail:
40910 return NULL;
40911 }
40912
40913
40914 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40915 PyObject *resultobj;
40916 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40917 size_t arg2 ;
40918 PyObject * obj0 = 0 ;
40919 PyObject * obj1 = 0 ;
40920 char *kwnames[] = {
40921 (char *) "self",(char *) "idx", NULL
40922 };
40923
40924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40926 if (SWIG_arg_fail(1)) SWIG_fail;
40927 {
40928 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40929 if (SWIG_arg_fail(2)) SWIG_fail;
40930 }
40931 {
40932 PyThreadState* __tstate = wxPyBeginAllowThreads();
40933 (arg1)->RemoveGrowableRow(arg2);
40934
40935 wxPyEndAllowThreads(__tstate);
40936 if (PyErr_Occurred()) SWIG_fail;
40937 }
40938 Py_INCREF(Py_None); resultobj = Py_None;
40939 return resultobj;
40940 fail:
40941 return NULL;
40942 }
40943
40944
40945 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40946 PyObject *resultobj;
40947 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40948 size_t arg2 ;
40949 int arg3 = (int) 0 ;
40950 PyObject * obj0 = 0 ;
40951 PyObject * obj1 = 0 ;
40952 PyObject * obj2 = 0 ;
40953 char *kwnames[] = {
40954 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40955 };
40956
40957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40959 if (SWIG_arg_fail(1)) SWIG_fail;
40960 {
40961 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40962 if (SWIG_arg_fail(2)) SWIG_fail;
40963 }
40964 if (obj2) {
40965 {
40966 arg3 = (int)(SWIG_As_int(obj2));
40967 if (SWIG_arg_fail(3)) SWIG_fail;
40968 }
40969 }
40970 {
40971 PyThreadState* __tstate = wxPyBeginAllowThreads();
40972 (arg1)->AddGrowableCol(arg2,arg3);
40973
40974 wxPyEndAllowThreads(__tstate);
40975 if (PyErr_Occurred()) SWIG_fail;
40976 }
40977 Py_INCREF(Py_None); resultobj = Py_None;
40978 return resultobj;
40979 fail:
40980 return NULL;
40981 }
40982
40983
40984 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40985 PyObject *resultobj;
40986 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40987 size_t arg2 ;
40988 PyObject * obj0 = 0 ;
40989 PyObject * obj1 = 0 ;
40990 char *kwnames[] = {
40991 (char *) "self",(char *) "idx", NULL
40992 };
40993
40994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40996 if (SWIG_arg_fail(1)) SWIG_fail;
40997 {
40998 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40999 if (SWIG_arg_fail(2)) SWIG_fail;
41000 }
41001 {
41002 PyThreadState* __tstate = wxPyBeginAllowThreads();
41003 (arg1)->RemoveGrowableCol(arg2);
41004
41005 wxPyEndAllowThreads(__tstate);
41006 if (PyErr_Occurred()) SWIG_fail;
41007 }
41008 Py_INCREF(Py_None); resultobj = Py_None;
41009 return resultobj;
41010 fail:
41011 return NULL;
41012 }
41013
41014
41015 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41016 PyObject *resultobj;
41017 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41018 int arg2 ;
41019 PyObject * obj0 = 0 ;
41020 PyObject * obj1 = 0 ;
41021 char *kwnames[] = {
41022 (char *) "self",(char *) "direction", NULL
41023 };
41024
41025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41027 if (SWIG_arg_fail(1)) SWIG_fail;
41028 {
41029 arg2 = (int)(SWIG_As_int(obj1));
41030 if (SWIG_arg_fail(2)) SWIG_fail;
41031 }
41032 {
41033 PyThreadState* __tstate = wxPyBeginAllowThreads();
41034 (arg1)->SetFlexibleDirection(arg2);
41035
41036 wxPyEndAllowThreads(__tstate);
41037 if (PyErr_Occurred()) SWIG_fail;
41038 }
41039 Py_INCREF(Py_None); resultobj = Py_None;
41040 return resultobj;
41041 fail:
41042 return NULL;
41043 }
41044
41045
41046 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41047 PyObject *resultobj;
41048 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41049 int result;
41050 PyObject * obj0 = 0 ;
41051 char *kwnames[] = {
41052 (char *) "self", NULL
41053 };
41054
41055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41057 if (SWIG_arg_fail(1)) SWIG_fail;
41058 {
41059 PyThreadState* __tstate = wxPyBeginAllowThreads();
41060 result = (int)(arg1)->GetFlexibleDirection();
41061
41062 wxPyEndAllowThreads(__tstate);
41063 if (PyErr_Occurred()) SWIG_fail;
41064 }
41065 {
41066 resultobj = SWIG_From_int((int)(result));
41067 }
41068 return resultobj;
41069 fail:
41070 return NULL;
41071 }
41072
41073
41074 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41075 PyObject *resultobj;
41076 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41077 wxFlexSizerGrowMode arg2 ;
41078 PyObject * obj0 = 0 ;
41079 PyObject * obj1 = 0 ;
41080 char *kwnames[] = {
41081 (char *) "self",(char *) "mode", NULL
41082 };
41083
41084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41086 if (SWIG_arg_fail(1)) SWIG_fail;
41087 {
41088 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41089 if (SWIG_arg_fail(2)) SWIG_fail;
41090 }
41091 {
41092 PyThreadState* __tstate = wxPyBeginAllowThreads();
41093 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41094
41095 wxPyEndAllowThreads(__tstate);
41096 if (PyErr_Occurred()) SWIG_fail;
41097 }
41098 Py_INCREF(Py_None); resultobj = Py_None;
41099 return resultobj;
41100 fail:
41101 return NULL;
41102 }
41103
41104
41105 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41106 PyObject *resultobj;
41107 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41108 wxFlexSizerGrowMode result;
41109 PyObject * obj0 = 0 ;
41110 char *kwnames[] = {
41111 (char *) "self", NULL
41112 };
41113
41114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41116 if (SWIG_arg_fail(1)) SWIG_fail;
41117 {
41118 PyThreadState* __tstate = wxPyBeginAllowThreads();
41119 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41120
41121 wxPyEndAllowThreads(__tstate);
41122 if (PyErr_Occurred()) SWIG_fail;
41123 }
41124 resultobj = SWIG_From_int((result));
41125 return resultobj;
41126 fail:
41127 return NULL;
41128 }
41129
41130
41131 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41132 PyObject *resultobj;
41133 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41134 wxArrayInt *result;
41135 PyObject * obj0 = 0 ;
41136 char *kwnames[] = {
41137 (char *) "self", NULL
41138 };
41139
41140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41142 if (SWIG_arg_fail(1)) SWIG_fail;
41143 {
41144 PyThreadState* __tstate = wxPyBeginAllowThreads();
41145 {
41146 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41147 result = (wxArrayInt *) &_result_ref;
41148 }
41149
41150 wxPyEndAllowThreads(__tstate);
41151 if (PyErr_Occurred()) SWIG_fail;
41152 }
41153 {
41154 resultobj = PyList_New(0);
41155 size_t idx;
41156 for (idx = 0; idx < result->GetCount(); idx += 1) {
41157 PyObject* val = PyInt_FromLong( result->Item(idx) );
41158 PyList_Append(resultobj, val);
41159 Py_DECREF(val);
41160 }
41161 }
41162 return resultobj;
41163 fail:
41164 return NULL;
41165 }
41166
41167
41168 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41169 PyObject *resultobj;
41170 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41171 wxArrayInt *result;
41172 PyObject * obj0 = 0 ;
41173 char *kwnames[] = {
41174 (char *) "self", NULL
41175 };
41176
41177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41179 if (SWIG_arg_fail(1)) SWIG_fail;
41180 {
41181 PyThreadState* __tstate = wxPyBeginAllowThreads();
41182 {
41183 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41184 result = (wxArrayInt *) &_result_ref;
41185 }
41186
41187 wxPyEndAllowThreads(__tstate);
41188 if (PyErr_Occurred()) SWIG_fail;
41189 }
41190 {
41191 resultobj = PyList_New(0);
41192 size_t idx;
41193 for (idx = 0; idx < result->GetCount(); idx += 1) {
41194 PyObject* val = PyInt_FromLong( result->Item(idx) );
41195 PyList_Append(resultobj, val);
41196 Py_DECREF(val);
41197 }
41198 }
41199 return resultobj;
41200 fail:
41201 return NULL;
41202 }
41203
41204
41205 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41206 PyObject *obj;
41207 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41208 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41209 Py_INCREF(obj);
41210 return Py_BuildValue((char *)"");
41211 }
41212 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41213 PyObject *resultobj;
41214 wxStdDialogButtonSizer *result;
41215 char *kwnames[] = {
41216 NULL
41217 };
41218
41219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41220 {
41221 PyThreadState* __tstate = wxPyBeginAllowThreads();
41222 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41223
41224 wxPyEndAllowThreads(__tstate);
41225 if (PyErr_Occurred()) SWIG_fail;
41226 }
41227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41228 return resultobj;
41229 fail:
41230 return NULL;
41231 }
41232
41233
41234 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41235 PyObject *resultobj;
41236 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41237 wxButton *arg2 = (wxButton *) 0 ;
41238 PyObject * obj0 = 0 ;
41239 PyObject * obj1 = 0 ;
41240 char *kwnames[] = {
41241 (char *) "self",(char *) "button", NULL
41242 };
41243
41244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41246 if (SWIG_arg_fail(1)) SWIG_fail;
41247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41248 if (SWIG_arg_fail(2)) SWIG_fail;
41249 {
41250 PyThreadState* __tstate = wxPyBeginAllowThreads();
41251 (arg1)->AddButton(arg2);
41252
41253 wxPyEndAllowThreads(__tstate);
41254 if (PyErr_Occurred()) SWIG_fail;
41255 }
41256 Py_INCREF(Py_None); resultobj = Py_None;
41257 return resultobj;
41258 fail:
41259 return NULL;
41260 }
41261
41262
41263 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41264 PyObject *resultobj;
41265 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41266 PyObject * obj0 = 0 ;
41267 char *kwnames[] = {
41268 (char *) "self", NULL
41269 };
41270
41271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41273 if (SWIG_arg_fail(1)) SWIG_fail;
41274 {
41275 PyThreadState* __tstate = wxPyBeginAllowThreads();
41276 (arg1)->Realize();
41277
41278 wxPyEndAllowThreads(__tstate);
41279 if (PyErr_Occurred()) SWIG_fail;
41280 }
41281 Py_INCREF(Py_None); resultobj = Py_None;
41282 return resultobj;
41283 fail:
41284 return NULL;
41285 }
41286
41287
41288 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41289 PyObject *resultobj;
41290 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41291 wxButton *arg2 = (wxButton *) 0 ;
41292 PyObject * obj0 = 0 ;
41293 PyObject * obj1 = 0 ;
41294 char *kwnames[] = {
41295 (char *) "self",(char *) "button", NULL
41296 };
41297
41298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41300 if (SWIG_arg_fail(1)) SWIG_fail;
41301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41302 if (SWIG_arg_fail(2)) SWIG_fail;
41303 {
41304 PyThreadState* __tstate = wxPyBeginAllowThreads();
41305 (arg1)->SetAffirmativeButton(arg2);
41306
41307 wxPyEndAllowThreads(__tstate);
41308 if (PyErr_Occurred()) SWIG_fail;
41309 }
41310 Py_INCREF(Py_None); resultobj = Py_None;
41311 return resultobj;
41312 fail:
41313 return NULL;
41314 }
41315
41316
41317 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41318 PyObject *resultobj;
41319 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41320 wxButton *arg2 = (wxButton *) 0 ;
41321 PyObject * obj0 = 0 ;
41322 PyObject * obj1 = 0 ;
41323 char *kwnames[] = {
41324 (char *) "self",(char *) "button", NULL
41325 };
41326
41327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41329 if (SWIG_arg_fail(1)) SWIG_fail;
41330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41331 if (SWIG_arg_fail(2)) SWIG_fail;
41332 {
41333 PyThreadState* __tstate = wxPyBeginAllowThreads();
41334 (arg1)->SetNegativeButton(arg2);
41335
41336 wxPyEndAllowThreads(__tstate);
41337 if (PyErr_Occurred()) SWIG_fail;
41338 }
41339 Py_INCREF(Py_None); resultobj = Py_None;
41340 return resultobj;
41341 fail:
41342 return NULL;
41343 }
41344
41345
41346 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41347 PyObject *resultobj;
41348 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41349 wxButton *arg2 = (wxButton *) 0 ;
41350 PyObject * obj0 = 0 ;
41351 PyObject * obj1 = 0 ;
41352 char *kwnames[] = {
41353 (char *) "self",(char *) "button", NULL
41354 };
41355
41356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41358 if (SWIG_arg_fail(1)) SWIG_fail;
41359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41360 if (SWIG_arg_fail(2)) SWIG_fail;
41361 {
41362 PyThreadState* __tstate = wxPyBeginAllowThreads();
41363 (arg1)->SetCancelButton(arg2);
41364
41365 wxPyEndAllowThreads(__tstate);
41366 if (PyErr_Occurred()) SWIG_fail;
41367 }
41368 Py_INCREF(Py_None); resultobj = Py_None;
41369 return resultobj;
41370 fail:
41371 return NULL;
41372 }
41373
41374
41375 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41376 PyObject *resultobj;
41377 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41378 wxButton *result;
41379 PyObject * obj0 = 0 ;
41380 char *kwnames[] = {
41381 (char *) "self", NULL
41382 };
41383
41384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41386 if (SWIG_arg_fail(1)) SWIG_fail;
41387 {
41388 PyThreadState* __tstate = wxPyBeginAllowThreads();
41389 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41390
41391 wxPyEndAllowThreads(__tstate);
41392 if (PyErr_Occurred()) SWIG_fail;
41393 }
41394 {
41395 resultobj = wxPyMake_wxObject(result, 0);
41396 }
41397 return resultobj;
41398 fail:
41399 return NULL;
41400 }
41401
41402
41403 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41404 PyObject *resultobj;
41405 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41406 wxButton *result;
41407 PyObject * obj0 = 0 ;
41408 char *kwnames[] = {
41409 (char *) "self", NULL
41410 };
41411
41412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41414 if (SWIG_arg_fail(1)) SWIG_fail;
41415 {
41416 PyThreadState* __tstate = wxPyBeginAllowThreads();
41417 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41418
41419 wxPyEndAllowThreads(__tstate);
41420 if (PyErr_Occurred()) SWIG_fail;
41421 }
41422 {
41423 resultobj = wxPyMake_wxObject(result, 0);
41424 }
41425 return resultobj;
41426 fail:
41427 return NULL;
41428 }
41429
41430
41431 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41432 PyObject *resultobj;
41433 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41434 wxButton *result;
41435 PyObject * obj0 = 0 ;
41436 char *kwnames[] = {
41437 (char *) "self", NULL
41438 };
41439
41440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41442 if (SWIG_arg_fail(1)) SWIG_fail;
41443 {
41444 PyThreadState* __tstate = wxPyBeginAllowThreads();
41445 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41446
41447 wxPyEndAllowThreads(__tstate);
41448 if (PyErr_Occurred()) SWIG_fail;
41449 }
41450 {
41451 resultobj = wxPyMake_wxObject(result, 0);
41452 }
41453 return resultobj;
41454 fail:
41455 return NULL;
41456 }
41457
41458
41459 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41460 PyObject *resultobj;
41461 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41462 wxButton *result;
41463 PyObject * obj0 = 0 ;
41464 char *kwnames[] = {
41465 (char *) "self", NULL
41466 };
41467
41468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41470 if (SWIG_arg_fail(1)) SWIG_fail;
41471 {
41472 PyThreadState* __tstate = wxPyBeginAllowThreads();
41473 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41474
41475 wxPyEndAllowThreads(__tstate);
41476 if (PyErr_Occurred()) SWIG_fail;
41477 }
41478 {
41479 resultobj = wxPyMake_wxObject(result, 0);
41480 }
41481 return resultobj;
41482 fail:
41483 return NULL;
41484 }
41485
41486
41487 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41488 PyObject *resultobj;
41489 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41490 wxButton *result;
41491 PyObject * obj0 = 0 ;
41492 char *kwnames[] = {
41493 (char *) "self", NULL
41494 };
41495
41496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41498 if (SWIG_arg_fail(1)) SWIG_fail;
41499 {
41500 PyThreadState* __tstate = wxPyBeginAllowThreads();
41501 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41502
41503 wxPyEndAllowThreads(__tstate);
41504 if (PyErr_Occurred()) SWIG_fail;
41505 }
41506 {
41507 resultobj = wxPyMake_wxObject(result, 0);
41508 }
41509 return resultobj;
41510 fail:
41511 return NULL;
41512 }
41513
41514
41515 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41516 PyObject *obj;
41517 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41518 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41519 Py_INCREF(obj);
41520 return Py_BuildValue((char *)"");
41521 }
41522 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41523 PyObject *resultobj;
41524 int arg1 = (int) 0 ;
41525 int arg2 = (int) 0 ;
41526 wxGBPosition *result;
41527 PyObject * obj0 = 0 ;
41528 PyObject * obj1 = 0 ;
41529 char *kwnames[] = {
41530 (char *) "row",(char *) "col", NULL
41531 };
41532
41533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41534 if (obj0) {
41535 {
41536 arg1 = (int)(SWIG_As_int(obj0));
41537 if (SWIG_arg_fail(1)) SWIG_fail;
41538 }
41539 }
41540 if (obj1) {
41541 {
41542 arg2 = (int)(SWIG_As_int(obj1));
41543 if (SWIG_arg_fail(2)) SWIG_fail;
41544 }
41545 }
41546 {
41547 PyThreadState* __tstate = wxPyBeginAllowThreads();
41548 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41549
41550 wxPyEndAllowThreads(__tstate);
41551 if (PyErr_Occurred()) SWIG_fail;
41552 }
41553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41554 return resultobj;
41555 fail:
41556 return NULL;
41557 }
41558
41559
41560 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41561 PyObject *resultobj;
41562 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41563 int result;
41564 PyObject * obj0 = 0 ;
41565 char *kwnames[] = {
41566 (char *) "self", NULL
41567 };
41568
41569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41571 if (SWIG_arg_fail(1)) SWIG_fail;
41572 {
41573 PyThreadState* __tstate = wxPyBeginAllowThreads();
41574 result = (int)((wxGBPosition const *)arg1)->GetRow();
41575
41576 wxPyEndAllowThreads(__tstate);
41577 if (PyErr_Occurred()) SWIG_fail;
41578 }
41579 {
41580 resultobj = SWIG_From_int((int)(result));
41581 }
41582 return resultobj;
41583 fail:
41584 return NULL;
41585 }
41586
41587
41588 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41589 PyObject *resultobj;
41590 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41591 int result;
41592 PyObject * obj0 = 0 ;
41593 char *kwnames[] = {
41594 (char *) "self", NULL
41595 };
41596
41597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41599 if (SWIG_arg_fail(1)) SWIG_fail;
41600 {
41601 PyThreadState* __tstate = wxPyBeginAllowThreads();
41602 result = (int)((wxGBPosition const *)arg1)->GetCol();
41603
41604 wxPyEndAllowThreads(__tstate);
41605 if (PyErr_Occurred()) SWIG_fail;
41606 }
41607 {
41608 resultobj = SWIG_From_int((int)(result));
41609 }
41610 return resultobj;
41611 fail:
41612 return NULL;
41613 }
41614
41615
41616 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41617 PyObject *resultobj;
41618 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41619 int arg2 ;
41620 PyObject * obj0 = 0 ;
41621 PyObject * obj1 = 0 ;
41622 char *kwnames[] = {
41623 (char *) "self",(char *) "row", NULL
41624 };
41625
41626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41628 if (SWIG_arg_fail(1)) SWIG_fail;
41629 {
41630 arg2 = (int)(SWIG_As_int(obj1));
41631 if (SWIG_arg_fail(2)) SWIG_fail;
41632 }
41633 {
41634 PyThreadState* __tstate = wxPyBeginAllowThreads();
41635 (arg1)->SetRow(arg2);
41636
41637 wxPyEndAllowThreads(__tstate);
41638 if (PyErr_Occurred()) SWIG_fail;
41639 }
41640 Py_INCREF(Py_None); resultobj = Py_None;
41641 return resultobj;
41642 fail:
41643 return NULL;
41644 }
41645
41646
41647 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41648 PyObject *resultobj;
41649 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41650 int arg2 ;
41651 PyObject * obj0 = 0 ;
41652 PyObject * obj1 = 0 ;
41653 char *kwnames[] = {
41654 (char *) "self",(char *) "col", NULL
41655 };
41656
41657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41659 if (SWIG_arg_fail(1)) SWIG_fail;
41660 {
41661 arg2 = (int)(SWIG_As_int(obj1));
41662 if (SWIG_arg_fail(2)) SWIG_fail;
41663 }
41664 {
41665 PyThreadState* __tstate = wxPyBeginAllowThreads();
41666 (arg1)->SetCol(arg2);
41667
41668 wxPyEndAllowThreads(__tstate);
41669 if (PyErr_Occurred()) SWIG_fail;
41670 }
41671 Py_INCREF(Py_None); resultobj = Py_None;
41672 return resultobj;
41673 fail:
41674 return NULL;
41675 }
41676
41677
41678 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41679 PyObject *resultobj;
41680 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41681 wxGBPosition *arg2 = 0 ;
41682 bool result;
41683 wxGBPosition temp2 ;
41684 PyObject * obj0 = 0 ;
41685 PyObject * obj1 = 0 ;
41686 char *kwnames[] = {
41687 (char *) "self",(char *) "other", NULL
41688 };
41689
41690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41692 if (SWIG_arg_fail(1)) SWIG_fail;
41693 {
41694 arg2 = &temp2;
41695 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41696 }
41697 {
41698 PyThreadState* __tstate = wxPyBeginAllowThreads();
41699 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41700
41701 wxPyEndAllowThreads(__tstate);
41702 if (PyErr_Occurred()) SWIG_fail;
41703 }
41704 {
41705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41706 }
41707 return resultobj;
41708 fail:
41709 return NULL;
41710 }
41711
41712
41713 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41714 PyObject *resultobj;
41715 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41716 wxGBPosition *arg2 = 0 ;
41717 bool result;
41718 wxGBPosition temp2 ;
41719 PyObject * obj0 = 0 ;
41720 PyObject * obj1 = 0 ;
41721 char *kwnames[] = {
41722 (char *) "self",(char *) "other", NULL
41723 };
41724
41725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41727 if (SWIG_arg_fail(1)) SWIG_fail;
41728 {
41729 arg2 = &temp2;
41730 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41731 }
41732 {
41733 PyThreadState* __tstate = wxPyBeginAllowThreads();
41734 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41735
41736 wxPyEndAllowThreads(__tstate);
41737 if (PyErr_Occurred()) SWIG_fail;
41738 }
41739 {
41740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41741 }
41742 return resultobj;
41743 fail:
41744 return NULL;
41745 }
41746
41747
41748 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41749 PyObject *resultobj;
41750 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41751 int arg2 = (int) 0 ;
41752 int arg3 = (int) 0 ;
41753 PyObject * obj0 = 0 ;
41754 PyObject * obj1 = 0 ;
41755 PyObject * obj2 = 0 ;
41756 char *kwnames[] = {
41757 (char *) "self",(char *) "row",(char *) "col", NULL
41758 };
41759
41760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41762 if (SWIG_arg_fail(1)) SWIG_fail;
41763 if (obj1) {
41764 {
41765 arg2 = (int)(SWIG_As_int(obj1));
41766 if (SWIG_arg_fail(2)) SWIG_fail;
41767 }
41768 }
41769 if (obj2) {
41770 {
41771 arg3 = (int)(SWIG_As_int(obj2));
41772 if (SWIG_arg_fail(3)) SWIG_fail;
41773 }
41774 }
41775 {
41776 PyThreadState* __tstate = wxPyBeginAllowThreads();
41777 wxGBPosition_Set(arg1,arg2,arg3);
41778
41779 wxPyEndAllowThreads(__tstate);
41780 if (PyErr_Occurred()) SWIG_fail;
41781 }
41782 Py_INCREF(Py_None); resultobj = Py_None;
41783 return resultobj;
41784 fail:
41785 return NULL;
41786 }
41787
41788
41789 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41790 PyObject *resultobj;
41791 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41792 PyObject *result;
41793 PyObject * obj0 = 0 ;
41794 char *kwnames[] = {
41795 (char *) "self", NULL
41796 };
41797
41798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41800 if (SWIG_arg_fail(1)) SWIG_fail;
41801 {
41802 PyThreadState* __tstate = wxPyBeginAllowThreads();
41803 result = (PyObject *)wxGBPosition_Get(arg1);
41804
41805 wxPyEndAllowThreads(__tstate);
41806 if (PyErr_Occurred()) SWIG_fail;
41807 }
41808 resultobj = result;
41809 return resultobj;
41810 fail:
41811 return NULL;
41812 }
41813
41814
41815 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41816 PyObject *obj;
41817 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41818 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41819 Py_INCREF(obj);
41820 return Py_BuildValue((char *)"");
41821 }
41822 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41823 PyObject *resultobj;
41824 int arg1 = (int) 1 ;
41825 int arg2 = (int) 1 ;
41826 wxGBSpan *result;
41827 PyObject * obj0 = 0 ;
41828 PyObject * obj1 = 0 ;
41829 char *kwnames[] = {
41830 (char *) "rowspan",(char *) "colspan", NULL
41831 };
41832
41833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41834 if (obj0) {
41835 {
41836 arg1 = (int)(SWIG_As_int(obj0));
41837 if (SWIG_arg_fail(1)) SWIG_fail;
41838 }
41839 }
41840 if (obj1) {
41841 {
41842 arg2 = (int)(SWIG_As_int(obj1));
41843 if (SWIG_arg_fail(2)) SWIG_fail;
41844 }
41845 }
41846 {
41847 PyThreadState* __tstate = wxPyBeginAllowThreads();
41848 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41849
41850 wxPyEndAllowThreads(__tstate);
41851 if (PyErr_Occurred()) SWIG_fail;
41852 }
41853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41854 return resultobj;
41855 fail:
41856 return NULL;
41857 }
41858
41859
41860 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41861 PyObject *resultobj;
41862 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41863 int result;
41864 PyObject * obj0 = 0 ;
41865 char *kwnames[] = {
41866 (char *) "self", NULL
41867 };
41868
41869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41871 if (SWIG_arg_fail(1)) SWIG_fail;
41872 {
41873 PyThreadState* __tstate = wxPyBeginAllowThreads();
41874 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41875
41876 wxPyEndAllowThreads(__tstate);
41877 if (PyErr_Occurred()) SWIG_fail;
41878 }
41879 {
41880 resultobj = SWIG_From_int((int)(result));
41881 }
41882 return resultobj;
41883 fail:
41884 return NULL;
41885 }
41886
41887
41888 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41889 PyObject *resultobj;
41890 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41891 int result;
41892 PyObject * obj0 = 0 ;
41893 char *kwnames[] = {
41894 (char *) "self", NULL
41895 };
41896
41897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41899 if (SWIG_arg_fail(1)) SWIG_fail;
41900 {
41901 PyThreadState* __tstate = wxPyBeginAllowThreads();
41902 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41903
41904 wxPyEndAllowThreads(__tstate);
41905 if (PyErr_Occurred()) SWIG_fail;
41906 }
41907 {
41908 resultobj = SWIG_From_int((int)(result));
41909 }
41910 return resultobj;
41911 fail:
41912 return NULL;
41913 }
41914
41915
41916 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41917 PyObject *resultobj;
41918 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41919 int arg2 ;
41920 PyObject * obj0 = 0 ;
41921 PyObject * obj1 = 0 ;
41922 char *kwnames[] = {
41923 (char *) "self",(char *) "rowspan", NULL
41924 };
41925
41926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41928 if (SWIG_arg_fail(1)) SWIG_fail;
41929 {
41930 arg2 = (int)(SWIG_As_int(obj1));
41931 if (SWIG_arg_fail(2)) SWIG_fail;
41932 }
41933 {
41934 PyThreadState* __tstate = wxPyBeginAllowThreads();
41935 (arg1)->SetRowspan(arg2);
41936
41937 wxPyEndAllowThreads(__tstate);
41938 if (PyErr_Occurred()) SWIG_fail;
41939 }
41940 Py_INCREF(Py_None); resultobj = Py_None;
41941 return resultobj;
41942 fail:
41943 return NULL;
41944 }
41945
41946
41947 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41948 PyObject *resultobj;
41949 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41950 int arg2 ;
41951 PyObject * obj0 = 0 ;
41952 PyObject * obj1 = 0 ;
41953 char *kwnames[] = {
41954 (char *) "self",(char *) "colspan", NULL
41955 };
41956
41957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41959 if (SWIG_arg_fail(1)) SWIG_fail;
41960 {
41961 arg2 = (int)(SWIG_As_int(obj1));
41962 if (SWIG_arg_fail(2)) SWIG_fail;
41963 }
41964 {
41965 PyThreadState* __tstate = wxPyBeginAllowThreads();
41966 (arg1)->SetColspan(arg2);
41967
41968 wxPyEndAllowThreads(__tstate);
41969 if (PyErr_Occurred()) SWIG_fail;
41970 }
41971 Py_INCREF(Py_None); resultobj = Py_None;
41972 return resultobj;
41973 fail:
41974 return NULL;
41975 }
41976
41977
41978 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41979 PyObject *resultobj;
41980 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41981 wxGBSpan *arg2 = 0 ;
41982 bool result;
41983 wxGBSpan temp2 ;
41984 PyObject * obj0 = 0 ;
41985 PyObject * obj1 = 0 ;
41986 char *kwnames[] = {
41987 (char *) "self",(char *) "other", NULL
41988 };
41989
41990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41992 if (SWIG_arg_fail(1)) SWIG_fail;
41993 {
41994 arg2 = &temp2;
41995 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41996 }
41997 {
41998 PyThreadState* __tstate = wxPyBeginAllowThreads();
41999 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42000
42001 wxPyEndAllowThreads(__tstate);
42002 if (PyErr_Occurred()) SWIG_fail;
42003 }
42004 {
42005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42006 }
42007 return resultobj;
42008 fail:
42009 return NULL;
42010 }
42011
42012
42013 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42014 PyObject *resultobj;
42015 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42016 wxGBSpan *arg2 = 0 ;
42017 bool result;
42018 wxGBSpan temp2 ;
42019 PyObject * obj0 = 0 ;
42020 PyObject * obj1 = 0 ;
42021 char *kwnames[] = {
42022 (char *) "self",(char *) "other", NULL
42023 };
42024
42025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42027 if (SWIG_arg_fail(1)) SWIG_fail;
42028 {
42029 arg2 = &temp2;
42030 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42031 }
42032 {
42033 PyThreadState* __tstate = wxPyBeginAllowThreads();
42034 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42035
42036 wxPyEndAllowThreads(__tstate);
42037 if (PyErr_Occurred()) SWIG_fail;
42038 }
42039 {
42040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42041 }
42042 return resultobj;
42043 fail:
42044 return NULL;
42045 }
42046
42047
42048 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42049 PyObject *resultobj;
42050 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42051 int arg2 = (int) 1 ;
42052 int arg3 = (int) 1 ;
42053 PyObject * obj0 = 0 ;
42054 PyObject * obj1 = 0 ;
42055 PyObject * obj2 = 0 ;
42056 char *kwnames[] = {
42057 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42058 };
42059
42060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42062 if (SWIG_arg_fail(1)) SWIG_fail;
42063 if (obj1) {
42064 {
42065 arg2 = (int)(SWIG_As_int(obj1));
42066 if (SWIG_arg_fail(2)) SWIG_fail;
42067 }
42068 }
42069 if (obj2) {
42070 {
42071 arg3 = (int)(SWIG_As_int(obj2));
42072 if (SWIG_arg_fail(3)) SWIG_fail;
42073 }
42074 }
42075 {
42076 PyThreadState* __tstate = wxPyBeginAllowThreads();
42077 wxGBSpan_Set(arg1,arg2,arg3);
42078
42079 wxPyEndAllowThreads(__tstate);
42080 if (PyErr_Occurred()) SWIG_fail;
42081 }
42082 Py_INCREF(Py_None); resultobj = Py_None;
42083 return resultobj;
42084 fail:
42085 return NULL;
42086 }
42087
42088
42089 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42090 PyObject *resultobj;
42091 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42092 PyObject *result;
42093 PyObject * obj0 = 0 ;
42094 char *kwnames[] = {
42095 (char *) "self", NULL
42096 };
42097
42098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42100 if (SWIG_arg_fail(1)) SWIG_fail;
42101 {
42102 PyThreadState* __tstate = wxPyBeginAllowThreads();
42103 result = (PyObject *)wxGBSpan_Get(arg1);
42104
42105 wxPyEndAllowThreads(__tstate);
42106 if (PyErr_Occurred()) SWIG_fail;
42107 }
42108 resultobj = result;
42109 return resultobj;
42110 fail:
42111 return NULL;
42112 }
42113
42114
42115 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42116 PyObject *obj;
42117 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42118 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42119 Py_INCREF(obj);
42120 return Py_BuildValue((char *)"");
42121 }
42122 static int _wrap_DefaultSpan_set(PyObject *) {
42123 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42124 return 1;
42125 }
42126
42127
42128 static PyObject *_wrap_DefaultSpan_get(void) {
42129 PyObject *pyobj;
42130
42131 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42132 return pyobj;
42133 }
42134
42135
42136 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42137 PyObject *resultobj;
42138 wxGBSizerItem *result;
42139 char *kwnames[] = {
42140 NULL
42141 };
42142
42143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42144 {
42145 PyThreadState* __tstate = wxPyBeginAllowThreads();
42146 result = (wxGBSizerItem *)new wxGBSizerItem();
42147
42148 wxPyEndAllowThreads(__tstate);
42149 if (PyErr_Occurred()) SWIG_fail;
42150 }
42151 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42152 return resultobj;
42153 fail:
42154 return NULL;
42155 }
42156
42157
42158 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42159 PyObject *resultobj;
42160 wxWindow *arg1 = (wxWindow *) 0 ;
42161 wxGBPosition *arg2 = 0 ;
42162 wxGBSpan *arg3 = 0 ;
42163 int arg4 ;
42164 int arg5 ;
42165 PyObject *arg6 = (PyObject *) NULL ;
42166 wxGBSizerItem *result;
42167 wxGBPosition temp2 ;
42168 wxGBSpan temp3 ;
42169 PyObject * obj0 = 0 ;
42170 PyObject * obj1 = 0 ;
42171 PyObject * obj2 = 0 ;
42172 PyObject * obj3 = 0 ;
42173 PyObject * obj4 = 0 ;
42174 PyObject * obj5 = 0 ;
42175 char *kwnames[] = {
42176 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42177 };
42178
42179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42181 if (SWIG_arg_fail(1)) SWIG_fail;
42182 {
42183 arg2 = &temp2;
42184 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42185 }
42186 {
42187 arg3 = &temp3;
42188 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42189 }
42190 {
42191 arg4 = (int)(SWIG_As_int(obj3));
42192 if (SWIG_arg_fail(4)) SWIG_fail;
42193 }
42194 {
42195 arg5 = (int)(SWIG_As_int(obj4));
42196 if (SWIG_arg_fail(5)) SWIG_fail;
42197 }
42198 if (obj5) {
42199 arg6 = obj5;
42200 }
42201 {
42202 PyThreadState* __tstate = wxPyBeginAllowThreads();
42203 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42204
42205 wxPyEndAllowThreads(__tstate);
42206 if (PyErr_Occurred()) SWIG_fail;
42207 }
42208 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42209 return resultobj;
42210 fail:
42211 return NULL;
42212 }
42213
42214
42215 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42216 PyObject *resultobj;
42217 wxSizer *arg1 = (wxSizer *) 0 ;
42218 wxGBPosition *arg2 = 0 ;
42219 wxGBSpan *arg3 = 0 ;
42220 int arg4 ;
42221 int arg5 ;
42222 PyObject *arg6 = (PyObject *) NULL ;
42223 wxGBSizerItem *result;
42224 wxGBPosition temp2 ;
42225 wxGBSpan temp3 ;
42226 PyObject * obj0 = 0 ;
42227 PyObject * obj1 = 0 ;
42228 PyObject * obj2 = 0 ;
42229 PyObject * obj3 = 0 ;
42230 PyObject * obj4 = 0 ;
42231 PyObject * obj5 = 0 ;
42232 char *kwnames[] = {
42233 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42234 };
42235
42236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42238 if (SWIG_arg_fail(1)) SWIG_fail;
42239 {
42240 arg2 = &temp2;
42241 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42242 }
42243 {
42244 arg3 = &temp3;
42245 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42246 }
42247 {
42248 arg4 = (int)(SWIG_As_int(obj3));
42249 if (SWIG_arg_fail(4)) SWIG_fail;
42250 }
42251 {
42252 arg5 = (int)(SWIG_As_int(obj4));
42253 if (SWIG_arg_fail(5)) SWIG_fail;
42254 }
42255 if (obj5) {
42256 arg6 = obj5;
42257 }
42258 {
42259 PyThreadState* __tstate = wxPyBeginAllowThreads();
42260 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42261
42262 wxPyEndAllowThreads(__tstate);
42263 if (PyErr_Occurred()) SWIG_fail;
42264 }
42265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42266 return resultobj;
42267 fail:
42268 return NULL;
42269 }
42270
42271
42272 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42273 PyObject *resultobj;
42274 int arg1 ;
42275 int arg2 ;
42276 wxGBPosition *arg3 = 0 ;
42277 wxGBSpan *arg4 = 0 ;
42278 int arg5 ;
42279 int arg6 ;
42280 PyObject *arg7 = (PyObject *) NULL ;
42281 wxGBSizerItem *result;
42282 wxGBPosition temp3 ;
42283 wxGBSpan temp4 ;
42284 PyObject * obj0 = 0 ;
42285 PyObject * obj1 = 0 ;
42286 PyObject * obj2 = 0 ;
42287 PyObject * obj3 = 0 ;
42288 PyObject * obj4 = 0 ;
42289 PyObject * obj5 = 0 ;
42290 PyObject * obj6 = 0 ;
42291 char *kwnames[] = {
42292 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42293 };
42294
42295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42296 {
42297 arg1 = (int)(SWIG_As_int(obj0));
42298 if (SWIG_arg_fail(1)) SWIG_fail;
42299 }
42300 {
42301 arg2 = (int)(SWIG_As_int(obj1));
42302 if (SWIG_arg_fail(2)) SWIG_fail;
42303 }
42304 {
42305 arg3 = &temp3;
42306 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42307 }
42308 {
42309 arg4 = &temp4;
42310 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42311 }
42312 {
42313 arg5 = (int)(SWIG_As_int(obj4));
42314 if (SWIG_arg_fail(5)) SWIG_fail;
42315 }
42316 {
42317 arg6 = (int)(SWIG_As_int(obj5));
42318 if (SWIG_arg_fail(6)) SWIG_fail;
42319 }
42320 if (obj6) {
42321 arg7 = obj6;
42322 }
42323 {
42324 PyThreadState* __tstate = wxPyBeginAllowThreads();
42325 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42326
42327 wxPyEndAllowThreads(__tstate);
42328 if (PyErr_Occurred()) SWIG_fail;
42329 }
42330 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42331 return resultobj;
42332 fail:
42333 return NULL;
42334 }
42335
42336
42337 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42338 PyObject *resultobj;
42339 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42340 wxGBPosition result;
42341 PyObject * obj0 = 0 ;
42342 char *kwnames[] = {
42343 (char *) "self", NULL
42344 };
42345
42346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42348 if (SWIG_arg_fail(1)) SWIG_fail;
42349 {
42350 PyThreadState* __tstate = wxPyBeginAllowThreads();
42351 result = ((wxGBSizerItem const *)arg1)->GetPos();
42352
42353 wxPyEndAllowThreads(__tstate);
42354 if (PyErr_Occurred()) SWIG_fail;
42355 }
42356 {
42357 wxGBPosition * resultptr;
42358 resultptr = new wxGBPosition((wxGBPosition &)(result));
42359 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42360 }
42361 return resultobj;
42362 fail:
42363 return NULL;
42364 }
42365
42366
42367 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42368 PyObject *resultobj;
42369 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42370 wxGBSpan result;
42371 PyObject * obj0 = 0 ;
42372 char *kwnames[] = {
42373 (char *) "self", NULL
42374 };
42375
42376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42378 if (SWIG_arg_fail(1)) SWIG_fail;
42379 {
42380 PyThreadState* __tstate = wxPyBeginAllowThreads();
42381 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42382
42383 wxPyEndAllowThreads(__tstate);
42384 if (PyErr_Occurred()) SWIG_fail;
42385 }
42386 {
42387 wxGBSpan * resultptr;
42388 resultptr = new wxGBSpan((wxGBSpan &)(result));
42389 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42390 }
42391 return resultobj;
42392 fail:
42393 return NULL;
42394 }
42395
42396
42397 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42398 PyObject *resultobj;
42399 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42400 wxGBPosition *arg2 = 0 ;
42401 bool result;
42402 wxGBPosition temp2 ;
42403 PyObject * obj0 = 0 ;
42404 PyObject * obj1 = 0 ;
42405 char *kwnames[] = {
42406 (char *) "self",(char *) "pos", NULL
42407 };
42408
42409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42411 if (SWIG_arg_fail(1)) SWIG_fail;
42412 {
42413 arg2 = &temp2;
42414 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42415 }
42416 {
42417 PyThreadState* __tstate = wxPyBeginAllowThreads();
42418 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42419
42420 wxPyEndAllowThreads(__tstate);
42421 if (PyErr_Occurred()) SWIG_fail;
42422 }
42423 {
42424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42425 }
42426 return resultobj;
42427 fail:
42428 return NULL;
42429 }
42430
42431
42432 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42433 PyObject *resultobj;
42434 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42435 wxGBSpan *arg2 = 0 ;
42436 bool result;
42437 wxGBSpan temp2 ;
42438 PyObject * obj0 = 0 ;
42439 PyObject * obj1 = 0 ;
42440 char *kwnames[] = {
42441 (char *) "self",(char *) "span", NULL
42442 };
42443
42444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42446 if (SWIG_arg_fail(1)) SWIG_fail;
42447 {
42448 arg2 = &temp2;
42449 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42450 }
42451 {
42452 PyThreadState* __tstate = wxPyBeginAllowThreads();
42453 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42454
42455 wxPyEndAllowThreads(__tstate);
42456 if (PyErr_Occurred()) SWIG_fail;
42457 }
42458 {
42459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42460 }
42461 return resultobj;
42462 fail:
42463 return NULL;
42464 }
42465
42466
42467 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42468 PyObject *resultobj;
42469 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42470 wxGBSizerItem *arg2 = 0 ;
42471 bool result;
42472 PyObject * obj0 = 0 ;
42473 PyObject * obj1 = 0 ;
42474 char *kwnames[] = {
42475 (char *) "self",(char *) "other", NULL
42476 };
42477
42478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42480 if (SWIG_arg_fail(1)) SWIG_fail;
42481 {
42482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42483 if (SWIG_arg_fail(2)) SWIG_fail;
42484 if (arg2 == NULL) {
42485 SWIG_null_ref("wxGBSizerItem");
42486 }
42487 if (SWIG_arg_fail(2)) SWIG_fail;
42488 }
42489 {
42490 PyThreadState* __tstate = wxPyBeginAllowThreads();
42491 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42492
42493 wxPyEndAllowThreads(__tstate);
42494 if (PyErr_Occurred()) SWIG_fail;
42495 }
42496 {
42497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42498 }
42499 return resultobj;
42500 fail:
42501 return NULL;
42502 }
42503
42504
42505 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42506 PyObject *resultobj;
42507 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42508 wxGBPosition *arg2 = 0 ;
42509 wxGBSpan *arg3 = 0 ;
42510 bool result;
42511 wxGBPosition temp2 ;
42512 wxGBSpan temp3 ;
42513 PyObject * obj0 = 0 ;
42514 PyObject * obj1 = 0 ;
42515 PyObject * obj2 = 0 ;
42516 char *kwnames[] = {
42517 (char *) "self",(char *) "pos",(char *) "span", NULL
42518 };
42519
42520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42522 if (SWIG_arg_fail(1)) SWIG_fail;
42523 {
42524 arg2 = &temp2;
42525 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42526 }
42527 {
42528 arg3 = &temp3;
42529 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42530 }
42531 {
42532 PyThreadState* __tstate = wxPyBeginAllowThreads();
42533 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42534
42535 wxPyEndAllowThreads(__tstate);
42536 if (PyErr_Occurred()) SWIG_fail;
42537 }
42538 {
42539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42540 }
42541 return resultobj;
42542 fail:
42543 return NULL;
42544 }
42545
42546
42547 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42548 PyObject *resultobj;
42549 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42550 wxGBPosition result;
42551 PyObject * obj0 = 0 ;
42552 char *kwnames[] = {
42553 (char *) "self", NULL
42554 };
42555
42556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42558 if (SWIG_arg_fail(1)) SWIG_fail;
42559 {
42560 PyThreadState* __tstate = wxPyBeginAllowThreads();
42561 result = wxGBSizerItem_GetEndPos(arg1);
42562
42563 wxPyEndAllowThreads(__tstate);
42564 if (PyErr_Occurred()) SWIG_fail;
42565 }
42566 {
42567 wxGBPosition * resultptr;
42568 resultptr = new wxGBPosition((wxGBPosition &)(result));
42569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42570 }
42571 return resultobj;
42572 fail:
42573 return NULL;
42574 }
42575
42576
42577 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42578 PyObject *resultobj;
42579 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42580 wxGridBagSizer *result;
42581 PyObject * obj0 = 0 ;
42582 char *kwnames[] = {
42583 (char *) "self", NULL
42584 };
42585
42586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42588 if (SWIG_arg_fail(1)) SWIG_fail;
42589 {
42590 PyThreadState* __tstate = wxPyBeginAllowThreads();
42591 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42592
42593 wxPyEndAllowThreads(__tstate);
42594 if (PyErr_Occurred()) SWIG_fail;
42595 }
42596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42597 return resultobj;
42598 fail:
42599 return NULL;
42600 }
42601
42602
42603 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42604 PyObject *resultobj;
42605 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42606 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42607 PyObject * obj0 = 0 ;
42608 PyObject * obj1 = 0 ;
42609 char *kwnames[] = {
42610 (char *) "self",(char *) "sizer", NULL
42611 };
42612
42613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42615 if (SWIG_arg_fail(1)) SWIG_fail;
42616 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42617 if (SWIG_arg_fail(2)) SWIG_fail;
42618 {
42619 PyThreadState* __tstate = wxPyBeginAllowThreads();
42620 (arg1)->SetGBSizer(arg2);
42621
42622 wxPyEndAllowThreads(__tstate);
42623 if (PyErr_Occurred()) SWIG_fail;
42624 }
42625 Py_INCREF(Py_None); resultobj = Py_None;
42626 return resultobj;
42627 fail:
42628 return NULL;
42629 }
42630
42631
42632 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42633 PyObject *obj;
42634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42635 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42636 Py_INCREF(obj);
42637 return Py_BuildValue((char *)"");
42638 }
42639 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42640 PyObject *resultobj;
42641 int arg1 = (int) 0 ;
42642 int arg2 = (int) 0 ;
42643 wxGridBagSizer *result;
42644 PyObject * obj0 = 0 ;
42645 PyObject * obj1 = 0 ;
42646 char *kwnames[] = {
42647 (char *) "vgap",(char *) "hgap", NULL
42648 };
42649
42650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42651 if (obj0) {
42652 {
42653 arg1 = (int)(SWIG_As_int(obj0));
42654 if (SWIG_arg_fail(1)) SWIG_fail;
42655 }
42656 }
42657 if (obj1) {
42658 {
42659 arg2 = (int)(SWIG_As_int(obj1));
42660 if (SWIG_arg_fail(2)) SWIG_fail;
42661 }
42662 }
42663 {
42664 PyThreadState* __tstate = wxPyBeginAllowThreads();
42665 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42666
42667 wxPyEndAllowThreads(__tstate);
42668 if (PyErr_Occurred()) SWIG_fail;
42669 }
42670 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42671 return resultobj;
42672 fail:
42673 return NULL;
42674 }
42675
42676
42677 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42678 PyObject *resultobj;
42679 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42680 PyObject *arg2 = (PyObject *) 0 ;
42681 wxGBPosition *arg3 = 0 ;
42682 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42683 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42684 int arg5 = (int) 0 ;
42685 int arg6 = (int) 0 ;
42686 PyObject *arg7 = (PyObject *) NULL ;
42687 wxGBSizerItem *result;
42688 wxGBPosition temp3 ;
42689 wxGBSpan temp4 ;
42690 PyObject * obj0 = 0 ;
42691 PyObject * obj1 = 0 ;
42692 PyObject * obj2 = 0 ;
42693 PyObject * obj3 = 0 ;
42694 PyObject * obj4 = 0 ;
42695 PyObject * obj5 = 0 ;
42696 PyObject * obj6 = 0 ;
42697 char *kwnames[] = {
42698 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42699 };
42700
42701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42703 if (SWIG_arg_fail(1)) SWIG_fail;
42704 arg2 = obj1;
42705 {
42706 arg3 = &temp3;
42707 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42708 }
42709 if (obj3) {
42710 {
42711 arg4 = &temp4;
42712 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42713 }
42714 }
42715 if (obj4) {
42716 {
42717 arg5 = (int)(SWIG_As_int(obj4));
42718 if (SWIG_arg_fail(5)) SWIG_fail;
42719 }
42720 }
42721 if (obj5) {
42722 {
42723 arg6 = (int)(SWIG_As_int(obj5));
42724 if (SWIG_arg_fail(6)) SWIG_fail;
42725 }
42726 }
42727 if (obj6) {
42728 arg7 = obj6;
42729 }
42730 {
42731 PyThreadState* __tstate = wxPyBeginAllowThreads();
42732 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42733
42734 wxPyEndAllowThreads(__tstate);
42735 if (PyErr_Occurred()) SWIG_fail;
42736 }
42737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42738 return resultobj;
42739 fail:
42740 return NULL;
42741 }
42742
42743
42744 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42745 PyObject *resultobj;
42746 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42747 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42748 wxGBSizerItem *result;
42749 PyObject * obj0 = 0 ;
42750 PyObject * obj1 = 0 ;
42751 char *kwnames[] = {
42752 (char *) "self",(char *) "item", NULL
42753 };
42754
42755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42757 if (SWIG_arg_fail(1)) SWIG_fail;
42758 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42759 if (SWIG_arg_fail(2)) SWIG_fail;
42760 {
42761 PyThreadState* __tstate = wxPyBeginAllowThreads();
42762 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42763
42764 wxPyEndAllowThreads(__tstate);
42765 if (PyErr_Occurred()) SWIG_fail;
42766 }
42767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42768 return resultobj;
42769 fail:
42770 return NULL;
42771 }
42772
42773
42774 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42775 PyObject *resultobj;
42776 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42777 int arg2 ;
42778 int arg3 ;
42779 wxSize result;
42780 PyObject * obj0 = 0 ;
42781 PyObject * obj1 = 0 ;
42782 PyObject * obj2 = 0 ;
42783 char *kwnames[] = {
42784 (char *) "self",(char *) "row",(char *) "col", NULL
42785 };
42786
42787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42789 if (SWIG_arg_fail(1)) SWIG_fail;
42790 {
42791 arg2 = (int)(SWIG_As_int(obj1));
42792 if (SWIG_arg_fail(2)) SWIG_fail;
42793 }
42794 {
42795 arg3 = (int)(SWIG_As_int(obj2));
42796 if (SWIG_arg_fail(3)) SWIG_fail;
42797 }
42798 {
42799 PyThreadState* __tstate = wxPyBeginAllowThreads();
42800 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42801
42802 wxPyEndAllowThreads(__tstate);
42803 if (PyErr_Occurred()) SWIG_fail;
42804 }
42805 {
42806 wxSize * resultptr;
42807 resultptr = new wxSize((wxSize &)(result));
42808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42809 }
42810 return resultobj;
42811 fail:
42812 return NULL;
42813 }
42814
42815
42816 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42817 PyObject *resultobj;
42818 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42819 wxSize result;
42820 PyObject * obj0 = 0 ;
42821 char *kwnames[] = {
42822 (char *) "self", NULL
42823 };
42824
42825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42827 if (SWIG_arg_fail(1)) SWIG_fail;
42828 {
42829 PyThreadState* __tstate = wxPyBeginAllowThreads();
42830 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42831
42832 wxPyEndAllowThreads(__tstate);
42833 if (PyErr_Occurred()) SWIG_fail;
42834 }
42835 {
42836 wxSize * resultptr;
42837 resultptr = new wxSize((wxSize &)(result));
42838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42839 }
42840 return resultobj;
42841 fail:
42842 return NULL;
42843 }
42844
42845
42846 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42847 PyObject *resultobj;
42848 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42849 wxSize *arg2 = 0 ;
42850 wxSize temp2 ;
42851 PyObject * obj0 = 0 ;
42852 PyObject * obj1 = 0 ;
42853 char *kwnames[] = {
42854 (char *) "self",(char *) "sz", NULL
42855 };
42856
42857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42859 if (SWIG_arg_fail(1)) SWIG_fail;
42860 {
42861 arg2 = &temp2;
42862 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42863 }
42864 {
42865 PyThreadState* __tstate = wxPyBeginAllowThreads();
42866 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42867
42868 wxPyEndAllowThreads(__tstate);
42869 if (PyErr_Occurred()) SWIG_fail;
42870 }
42871 Py_INCREF(Py_None); resultobj = Py_None;
42872 return resultobj;
42873 fail:
42874 return NULL;
42875 }
42876
42877
42878 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42879 PyObject *resultobj;
42880 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42881 wxWindow *arg2 = (wxWindow *) 0 ;
42882 wxGBPosition result;
42883 PyObject * obj0 = 0 ;
42884 PyObject * obj1 = 0 ;
42885
42886 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42888 if (SWIG_arg_fail(1)) SWIG_fail;
42889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42890 if (SWIG_arg_fail(2)) SWIG_fail;
42891 {
42892 PyThreadState* __tstate = wxPyBeginAllowThreads();
42893 result = (arg1)->GetItemPosition(arg2);
42894
42895 wxPyEndAllowThreads(__tstate);
42896 if (PyErr_Occurred()) SWIG_fail;
42897 }
42898 {
42899 wxGBPosition * resultptr;
42900 resultptr = new wxGBPosition((wxGBPosition &)(result));
42901 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42902 }
42903 return resultobj;
42904 fail:
42905 return NULL;
42906 }
42907
42908
42909 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42910 PyObject *resultobj;
42911 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42912 wxSizer *arg2 = (wxSizer *) 0 ;
42913 wxGBPosition result;
42914 PyObject * obj0 = 0 ;
42915 PyObject * obj1 = 0 ;
42916
42917 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42919 if (SWIG_arg_fail(1)) SWIG_fail;
42920 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42921 if (SWIG_arg_fail(2)) SWIG_fail;
42922 {
42923 PyThreadState* __tstate = wxPyBeginAllowThreads();
42924 result = (arg1)->GetItemPosition(arg2);
42925
42926 wxPyEndAllowThreads(__tstate);
42927 if (PyErr_Occurred()) SWIG_fail;
42928 }
42929 {
42930 wxGBPosition * resultptr;
42931 resultptr = new wxGBPosition((wxGBPosition &)(result));
42932 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42933 }
42934 return resultobj;
42935 fail:
42936 return NULL;
42937 }
42938
42939
42940 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42941 PyObject *resultobj;
42942 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42943 size_t arg2 ;
42944 wxGBPosition result;
42945 PyObject * obj0 = 0 ;
42946 PyObject * obj1 = 0 ;
42947
42948 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42950 if (SWIG_arg_fail(1)) SWIG_fail;
42951 {
42952 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42953 if (SWIG_arg_fail(2)) SWIG_fail;
42954 }
42955 {
42956 PyThreadState* __tstate = wxPyBeginAllowThreads();
42957 result = (arg1)->GetItemPosition(arg2);
42958
42959 wxPyEndAllowThreads(__tstate);
42960 if (PyErr_Occurred()) SWIG_fail;
42961 }
42962 {
42963 wxGBPosition * resultptr;
42964 resultptr = new wxGBPosition((wxGBPosition &)(result));
42965 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42966 }
42967 return resultobj;
42968 fail:
42969 return NULL;
42970 }
42971
42972
42973 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42974 int argc;
42975 PyObject *argv[3];
42976 int ii;
42977
42978 argc = PyObject_Length(args);
42979 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42980 argv[ii] = PyTuple_GetItem(args,ii);
42981 }
42982 if (argc == 2) {
42983 int _v;
42984 {
42985 void *ptr;
42986 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42987 _v = 0;
42988 PyErr_Clear();
42989 } else {
42990 _v = 1;
42991 }
42992 }
42993 if (_v) {
42994 {
42995 void *ptr;
42996 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42997 _v = 0;
42998 PyErr_Clear();
42999 } else {
43000 _v = 1;
43001 }
43002 }
43003 if (_v) {
43004 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43005 }
43006 }
43007 }
43008 if (argc == 2) {
43009 int _v;
43010 {
43011 void *ptr;
43012 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43013 _v = 0;
43014 PyErr_Clear();
43015 } else {
43016 _v = 1;
43017 }
43018 }
43019 if (_v) {
43020 {
43021 void *ptr;
43022 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43023 _v = 0;
43024 PyErr_Clear();
43025 } else {
43026 _v = 1;
43027 }
43028 }
43029 if (_v) {
43030 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43031 }
43032 }
43033 }
43034 if (argc == 2) {
43035 int _v;
43036 {
43037 void *ptr;
43038 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43039 _v = 0;
43040 PyErr_Clear();
43041 } else {
43042 _v = 1;
43043 }
43044 }
43045 if (_v) {
43046 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43047 if (_v) {
43048 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43049 }
43050 }
43051 }
43052
43053 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43054 return NULL;
43055 }
43056
43057
43058 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43059 PyObject *resultobj;
43060 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43061 wxWindow *arg2 = (wxWindow *) 0 ;
43062 wxGBPosition *arg3 = 0 ;
43063 bool result;
43064 wxGBPosition temp3 ;
43065 PyObject * obj0 = 0 ;
43066 PyObject * obj1 = 0 ;
43067 PyObject * obj2 = 0 ;
43068
43069 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43071 if (SWIG_arg_fail(1)) SWIG_fail;
43072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43073 if (SWIG_arg_fail(2)) SWIG_fail;
43074 {
43075 arg3 = &temp3;
43076 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43077 }
43078 {
43079 PyThreadState* __tstate = wxPyBeginAllowThreads();
43080 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43081
43082 wxPyEndAllowThreads(__tstate);
43083 if (PyErr_Occurred()) SWIG_fail;
43084 }
43085 {
43086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43087 }
43088 return resultobj;
43089 fail:
43090 return NULL;
43091 }
43092
43093
43094 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43095 PyObject *resultobj;
43096 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43097 wxSizer *arg2 = (wxSizer *) 0 ;
43098 wxGBPosition *arg3 = 0 ;
43099 bool result;
43100 wxGBPosition temp3 ;
43101 PyObject * obj0 = 0 ;
43102 PyObject * obj1 = 0 ;
43103 PyObject * obj2 = 0 ;
43104
43105 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43107 if (SWIG_arg_fail(1)) SWIG_fail;
43108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43109 if (SWIG_arg_fail(2)) SWIG_fail;
43110 {
43111 arg3 = &temp3;
43112 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43113 }
43114 {
43115 PyThreadState* __tstate = wxPyBeginAllowThreads();
43116 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43117
43118 wxPyEndAllowThreads(__tstate);
43119 if (PyErr_Occurred()) SWIG_fail;
43120 }
43121 {
43122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43123 }
43124 return resultobj;
43125 fail:
43126 return NULL;
43127 }
43128
43129
43130 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43131 PyObject *resultobj;
43132 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43133 size_t arg2 ;
43134 wxGBPosition *arg3 = 0 ;
43135 bool result;
43136 wxGBPosition temp3 ;
43137 PyObject * obj0 = 0 ;
43138 PyObject * obj1 = 0 ;
43139 PyObject * obj2 = 0 ;
43140
43141 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43143 if (SWIG_arg_fail(1)) SWIG_fail;
43144 {
43145 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43146 if (SWIG_arg_fail(2)) SWIG_fail;
43147 }
43148 {
43149 arg3 = &temp3;
43150 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43151 }
43152 {
43153 PyThreadState* __tstate = wxPyBeginAllowThreads();
43154 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43155
43156 wxPyEndAllowThreads(__tstate);
43157 if (PyErr_Occurred()) SWIG_fail;
43158 }
43159 {
43160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43161 }
43162 return resultobj;
43163 fail:
43164 return NULL;
43165 }
43166
43167
43168 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43169 int argc;
43170 PyObject *argv[4];
43171 int ii;
43172
43173 argc = PyObject_Length(args);
43174 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43175 argv[ii] = PyTuple_GetItem(args,ii);
43176 }
43177 if (argc == 3) {
43178 int _v;
43179 {
43180 void *ptr;
43181 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43182 _v = 0;
43183 PyErr_Clear();
43184 } else {
43185 _v = 1;
43186 }
43187 }
43188 if (_v) {
43189 {
43190 void *ptr;
43191 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43192 _v = 0;
43193 PyErr_Clear();
43194 } else {
43195 _v = 1;
43196 }
43197 }
43198 if (_v) {
43199 {
43200 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43201 }
43202 if (_v) {
43203 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43204 }
43205 }
43206 }
43207 }
43208 if (argc == 3) {
43209 int _v;
43210 {
43211 void *ptr;
43212 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43213 _v = 0;
43214 PyErr_Clear();
43215 } else {
43216 _v = 1;
43217 }
43218 }
43219 if (_v) {
43220 {
43221 void *ptr;
43222 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43223 _v = 0;
43224 PyErr_Clear();
43225 } else {
43226 _v = 1;
43227 }
43228 }
43229 if (_v) {
43230 {
43231 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43232 }
43233 if (_v) {
43234 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43235 }
43236 }
43237 }
43238 }
43239 if (argc == 3) {
43240 int _v;
43241 {
43242 void *ptr;
43243 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43244 _v = 0;
43245 PyErr_Clear();
43246 } else {
43247 _v = 1;
43248 }
43249 }
43250 if (_v) {
43251 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43252 if (_v) {
43253 {
43254 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43255 }
43256 if (_v) {
43257 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43258 }
43259 }
43260 }
43261 }
43262
43263 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43264 return NULL;
43265 }
43266
43267
43268 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43269 PyObject *resultobj;
43270 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43271 wxWindow *arg2 = (wxWindow *) 0 ;
43272 wxGBSpan result;
43273 PyObject * obj0 = 0 ;
43274 PyObject * obj1 = 0 ;
43275
43276 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43278 if (SWIG_arg_fail(1)) SWIG_fail;
43279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43280 if (SWIG_arg_fail(2)) SWIG_fail;
43281 {
43282 PyThreadState* __tstate = wxPyBeginAllowThreads();
43283 result = (arg1)->GetItemSpan(arg2);
43284
43285 wxPyEndAllowThreads(__tstate);
43286 if (PyErr_Occurred()) SWIG_fail;
43287 }
43288 {
43289 wxGBSpan * resultptr;
43290 resultptr = new wxGBSpan((wxGBSpan &)(result));
43291 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43292 }
43293 return resultobj;
43294 fail:
43295 return NULL;
43296 }
43297
43298
43299 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43300 PyObject *resultobj;
43301 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43302 wxSizer *arg2 = (wxSizer *) 0 ;
43303 wxGBSpan result;
43304 PyObject * obj0 = 0 ;
43305 PyObject * obj1 = 0 ;
43306
43307 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43309 if (SWIG_arg_fail(1)) SWIG_fail;
43310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43311 if (SWIG_arg_fail(2)) SWIG_fail;
43312 {
43313 PyThreadState* __tstate = wxPyBeginAllowThreads();
43314 result = (arg1)->GetItemSpan(arg2);
43315
43316 wxPyEndAllowThreads(__tstate);
43317 if (PyErr_Occurred()) SWIG_fail;
43318 }
43319 {
43320 wxGBSpan * resultptr;
43321 resultptr = new wxGBSpan((wxGBSpan &)(result));
43322 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43323 }
43324 return resultobj;
43325 fail:
43326 return NULL;
43327 }
43328
43329
43330 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43331 PyObject *resultobj;
43332 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43333 size_t arg2 ;
43334 wxGBSpan result;
43335 PyObject * obj0 = 0 ;
43336 PyObject * obj1 = 0 ;
43337
43338 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43340 if (SWIG_arg_fail(1)) SWIG_fail;
43341 {
43342 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43343 if (SWIG_arg_fail(2)) SWIG_fail;
43344 }
43345 {
43346 PyThreadState* __tstate = wxPyBeginAllowThreads();
43347 result = (arg1)->GetItemSpan(arg2);
43348
43349 wxPyEndAllowThreads(__tstate);
43350 if (PyErr_Occurred()) SWIG_fail;
43351 }
43352 {
43353 wxGBSpan * resultptr;
43354 resultptr = new wxGBSpan((wxGBSpan &)(result));
43355 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43356 }
43357 return resultobj;
43358 fail:
43359 return NULL;
43360 }
43361
43362
43363 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43364 int argc;
43365 PyObject *argv[3];
43366 int ii;
43367
43368 argc = PyObject_Length(args);
43369 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43370 argv[ii] = PyTuple_GetItem(args,ii);
43371 }
43372 if (argc == 2) {
43373 int _v;
43374 {
43375 void *ptr;
43376 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43377 _v = 0;
43378 PyErr_Clear();
43379 } else {
43380 _v = 1;
43381 }
43382 }
43383 if (_v) {
43384 {
43385 void *ptr;
43386 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43387 _v = 0;
43388 PyErr_Clear();
43389 } else {
43390 _v = 1;
43391 }
43392 }
43393 if (_v) {
43394 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43395 }
43396 }
43397 }
43398 if (argc == 2) {
43399 int _v;
43400 {
43401 void *ptr;
43402 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43403 _v = 0;
43404 PyErr_Clear();
43405 } else {
43406 _v = 1;
43407 }
43408 }
43409 if (_v) {
43410 {
43411 void *ptr;
43412 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43413 _v = 0;
43414 PyErr_Clear();
43415 } else {
43416 _v = 1;
43417 }
43418 }
43419 if (_v) {
43420 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43421 }
43422 }
43423 }
43424 if (argc == 2) {
43425 int _v;
43426 {
43427 void *ptr;
43428 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43429 _v = 0;
43430 PyErr_Clear();
43431 } else {
43432 _v = 1;
43433 }
43434 }
43435 if (_v) {
43436 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43437 if (_v) {
43438 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43439 }
43440 }
43441 }
43442
43443 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43444 return NULL;
43445 }
43446
43447
43448 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43449 PyObject *resultobj;
43450 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43451 wxWindow *arg2 = (wxWindow *) 0 ;
43452 wxGBSpan *arg3 = 0 ;
43453 bool result;
43454 wxGBSpan temp3 ;
43455 PyObject * obj0 = 0 ;
43456 PyObject * obj1 = 0 ;
43457 PyObject * obj2 = 0 ;
43458
43459 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43461 if (SWIG_arg_fail(1)) SWIG_fail;
43462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43463 if (SWIG_arg_fail(2)) SWIG_fail;
43464 {
43465 arg3 = &temp3;
43466 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43467 }
43468 {
43469 PyThreadState* __tstate = wxPyBeginAllowThreads();
43470 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43471
43472 wxPyEndAllowThreads(__tstate);
43473 if (PyErr_Occurred()) SWIG_fail;
43474 }
43475 {
43476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43477 }
43478 return resultobj;
43479 fail:
43480 return NULL;
43481 }
43482
43483
43484 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43485 PyObject *resultobj;
43486 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43487 wxSizer *arg2 = (wxSizer *) 0 ;
43488 wxGBSpan *arg3 = 0 ;
43489 bool result;
43490 wxGBSpan temp3 ;
43491 PyObject * obj0 = 0 ;
43492 PyObject * obj1 = 0 ;
43493 PyObject * obj2 = 0 ;
43494
43495 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43497 if (SWIG_arg_fail(1)) SWIG_fail;
43498 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43499 if (SWIG_arg_fail(2)) SWIG_fail;
43500 {
43501 arg3 = &temp3;
43502 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43503 }
43504 {
43505 PyThreadState* __tstate = wxPyBeginAllowThreads();
43506 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43507
43508 wxPyEndAllowThreads(__tstate);
43509 if (PyErr_Occurred()) SWIG_fail;
43510 }
43511 {
43512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43513 }
43514 return resultobj;
43515 fail:
43516 return NULL;
43517 }
43518
43519
43520 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43521 PyObject *resultobj;
43522 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43523 size_t arg2 ;
43524 wxGBSpan *arg3 = 0 ;
43525 bool result;
43526 wxGBSpan temp3 ;
43527 PyObject * obj0 = 0 ;
43528 PyObject * obj1 = 0 ;
43529 PyObject * obj2 = 0 ;
43530
43531 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43533 if (SWIG_arg_fail(1)) SWIG_fail;
43534 {
43535 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43536 if (SWIG_arg_fail(2)) SWIG_fail;
43537 }
43538 {
43539 arg3 = &temp3;
43540 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43541 }
43542 {
43543 PyThreadState* __tstate = wxPyBeginAllowThreads();
43544 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43545
43546 wxPyEndAllowThreads(__tstate);
43547 if (PyErr_Occurred()) SWIG_fail;
43548 }
43549 {
43550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43551 }
43552 return resultobj;
43553 fail:
43554 return NULL;
43555 }
43556
43557
43558 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43559 int argc;
43560 PyObject *argv[4];
43561 int ii;
43562
43563 argc = PyObject_Length(args);
43564 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43565 argv[ii] = PyTuple_GetItem(args,ii);
43566 }
43567 if (argc == 3) {
43568 int _v;
43569 {
43570 void *ptr;
43571 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43572 _v = 0;
43573 PyErr_Clear();
43574 } else {
43575 _v = 1;
43576 }
43577 }
43578 if (_v) {
43579 {
43580 void *ptr;
43581 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43582 _v = 0;
43583 PyErr_Clear();
43584 } else {
43585 _v = 1;
43586 }
43587 }
43588 if (_v) {
43589 {
43590 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43591 }
43592 if (_v) {
43593 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43594 }
43595 }
43596 }
43597 }
43598 if (argc == 3) {
43599 int _v;
43600 {
43601 void *ptr;
43602 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43603 _v = 0;
43604 PyErr_Clear();
43605 } else {
43606 _v = 1;
43607 }
43608 }
43609 if (_v) {
43610 {
43611 void *ptr;
43612 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43613 _v = 0;
43614 PyErr_Clear();
43615 } else {
43616 _v = 1;
43617 }
43618 }
43619 if (_v) {
43620 {
43621 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43622 }
43623 if (_v) {
43624 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43625 }
43626 }
43627 }
43628 }
43629 if (argc == 3) {
43630 int _v;
43631 {
43632 void *ptr;
43633 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43634 _v = 0;
43635 PyErr_Clear();
43636 } else {
43637 _v = 1;
43638 }
43639 }
43640 if (_v) {
43641 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43642 if (_v) {
43643 {
43644 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43645 }
43646 if (_v) {
43647 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43648 }
43649 }
43650 }
43651 }
43652
43653 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43654 return NULL;
43655 }
43656
43657
43658 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43659 PyObject *resultobj;
43660 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43661 wxWindow *arg2 = (wxWindow *) 0 ;
43662 wxGBSizerItem *result;
43663 PyObject * obj0 = 0 ;
43664 PyObject * obj1 = 0 ;
43665
43666 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43668 if (SWIG_arg_fail(1)) SWIG_fail;
43669 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43670 if (SWIG_arg_fail(2)) SWIG_fail;
43671 {
43672 PyThreadState* __tstate = wxPyBeginAllowThreads();
43673 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43674
43675 wxPyEndAllowThreads(__tstate);
43676 if (PyErr_Occurred()) SWIG_fail;
43677 }
43678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43679 return resultobj;
43680 fail:
43681 return NULL;
43682 }
43683
43684
43685 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43686 PyObject *resultobj;
43687 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43688 wxSizer *arg2 = (wxSizer *) 0 ;
43689 wxGBSizerItem *result;
43690 PyObject * obj0 = 0 ;
43691 PyObject * obj1 = 0 ;
43692
43693 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43695 if (SWIG_arg_fail(1)) SWIG_fail;
43696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43697 if (SWIG_arg_fail(2)) SWIG_fail;
43698 {
43699 PyThreadState* __tstate = wxPyBeginAllowThreads();
43700 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43701
43702 wxPyEndAllowThreads(__tstate);
43703 if (PyErr_Occurred()) SWIG_fail;
43704 }
43705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43706 return resultobj;
43707 fail:
43708 return NULL;
43709 }
43710
43711
43712 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43713 int argc;
43714 PyObject *argv[3];
43715 int ii;
43716
43717 argc = PyObject_Length(args);
43718 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43719 argv[ii] = PyTuple_GetItem(args,ii);
43720 }
43721 if (argc == 2) {
43722 int _v;
43723 {
43724 void *ptr;
43725 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43726 _v = 0;
43727 PyErr_Clear();
43728 } else {
43729 _v = 1;
43730 }
43731 }
43732 if (_v) {
43733 {
43734 void *ptr;
43735 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43736 _v = 0;
43737 PyErr_Clear();
43738 } else {
43739 _v = 1;
43740 }
43741 }
43742 if (_v) {
43743 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43744 }
43745 }
43746 }
43747 if (argc == 2) {
43748 int _v;
43749 {
43750 void *ptr;
43751 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43752 _v = 0;
43753 PyErr_Clear();
43754 } else {
43755 _v = 1;
43756 }
43757 }
43758 if (_v) {
43759 {
43760 void *ptr;
43761 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43762 _v = 0;
43763 PyErr_Clear();
43764 } else {
43765 _v = 1;
43766 }
43767 }
43768 if (_v) {
43769 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43770 }
43771 }
43772 }
43773
43774 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43775 return NULL;
43776 }
43777
43778
43779 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43780 PyObject *resultobj;
43781 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43782 wxGBPosition *arg2 = 0 ;
43783 wxGBSizerItem *result;
43784 wxGBPosition temp2 ;
43785 PyObject * obj0 = 0 ;
43786 PyObject * obj1 = 0 ;
43787 char *kwnames[] = {
43788 (char *) "self",(char *) "pos", NULL
43789 };
43790
43791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43793 if (SWIG_arg_fail(1)) SWIG_fail;
43794 {
43795 arg2 = &temp2;
43796 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43797 }
43798 {
43799 PyThreadState* __tstate = wxPyBeginAllowThreads();
43800 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43801
43802 wxPyEndAllowThreads(__tstate);
43803 if (PyErr_Occurred()) SWIG_fail;
43804 }
43805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43806 return resultobj;
43807 fail:
43808 return NULL;
43809 }
43810
43811
43812 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43813 PyObject *resultobj;
43814 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43815 wxPoint *arg2 = 0 ;
43816 wxGBSizerItem *result;
43817 wxPoint temp2 ;
43818 PyObject * obj0 = 0 ;
43819 PyObject * obj1 = 0 ;
43820 char *kwnames[] = {
43821 (char *) "self",(char *) "pt", NULL
43822 };
43823
43824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43826 if (SWIG_arg_fail(1)) SWIG_fail;
43827 {
43828 arg2 = &temp2;
43829 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43830 }
43831 {
43832 PyThreadState* __tstate = wxPyBeginAllowThreads();
43833 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43834
43835 wxPyEndAllowThreads(__tstate);
43836 if (PyErr_Occurred()) SWIG_fail;
43837 }
43838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43839 return resultobj;
43840 fail:
43841 return NULL;
43842 }
43843
43844
43845 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43846 PyObject *resultobj;
43847 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43848 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43849 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43850 bool result;
43851 PyObject * obj0 = 0 ;
43852 PyObject * obj1 = 0 ;
43853 PyObject * obj2 = 0 ;
43854 char *kwnames[] = {
43855 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43856 };
43857
43858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43860 if (SWIG_arg_fail(1)) SWIG_fail;
43861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43862 if (SWIG_arg_fail(2)) SWIG_fail;
43863 if (obj2) {
43864 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43865 if (SWIG_arg_fail(3)) SWIG_fail;
43866 }
43867 {
43868 PyThreadState* __tstate = wxPyBeginAllowThreads();
43869 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43870
43871 wxPyEndAllowThreads(__tstate);
43872 if (PyErr_Occurred()) SWIG_fail;
43873 }
43874 {
43875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43876 }
43877 return resultobj;
43878 fail:
43879 return NULL;
43880 }
43881
43882
43883 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43884 PyObject *resultobj;
43885 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43886 wxGBPosition *arg2 = 0 ;
43887 wxGBSpan *arg3 = 0 ;
43888 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43889 bool result;
43890 wxGBPosition temp2 ;
43891 wxGBSpan temp3 ;
43892 PyObject * obj0 = 0 ;
43893 PyObject * obj1 = 0 ;
43894 PyObject * obj2 = 0 ;
43895 PyObject * obj3 = 0 ;
43896 char *kwnames[] = {
43897 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43898 };
43899
43900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43902 if (SWIG_arg_fail(1)) SWIG_fail;
43903 {
43904 arg2 = &temp2;
43905 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43906 }
43907 {
43908 arg3 = &temp3;
43909 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43910 }
43911 if (obj3) {
43912 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43913 if (SWIG_arg_fail(4)) SWIG_fail;
43914 }
43915 {
43916 PyThreadState* __tstate = wxPyBeginAllowThreads();
43917 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43918
43919 wxPyEndAllowThreads(__tstate);
43920 if (PyErr_Occurred()) SWIG_fail;
43921 }
43922 {
43923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43924 }
43925 return resultobj;
43926 fail:
43927 return NULL;
43928 }
43929
43930
43931 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43932 PyObject *obj;
43933 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43934 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43935 Py_INCREF(obj);
43936 return Py_BuildValue((char *)"");
43937 }
43938 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43939 PyObject *resultobj;
43940 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43941 wxRelationship arg2 ;
43942 wxWindow *arg3 = (wxWindow *) 0 ;
43943 wxEdge arg4 ;
43944 int arg5 = (int) 0 ;
43945 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43946 PyObject * obj0 = 0 ;
43947 PyObject * obj1 = 0 ;
43948 PyObject * obj2 = 0 ;
43949 PyObject * obj3 = 0 ;
43950 PyObject * obj4 = 0 ;
43951 PyObject * obj5 = 0 ;
43952 char *kwnames[] = {
43953 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43954 };
43955
43956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43958 if (SWIG_arg_fail(1)) SWIG_fail;
43959 {
43960 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43961 if (SWIG_arg_fail(2)) SWIG_fail;
43962 }
43963 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43964 if (SWIG_arg_fail(3)) SWIG_fail;
43965 {
43966 arg4 = (wxEdge)(SWIG_As_int(obj3));
43967 if (SWIG_arg_fail(4)) SWIG_fail;
43968 }
43969 if (obj4) {
43970 {
43971 arg5 = (int)(SWIG_As_int(obj4));
43972 if (SWIG_arg_fail(5)) SWIG_fail;
43973 }
43974 }
43975 if (obj5) {
43976 {
43977 arg6 = (int)(SWIG_As_int(obj5));
43978 if (SWIG_arg_fail(6)) SWIG_fail;
43979 }
43980 }
43981 {
43982 PyThreadState* __tstate = wxPyBeginAllowThreads();
43983 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43984
43985 wxPyEndAllowThreads(__tstate);
43986 if (PyErr_Occurred()) SWIG_fail;
43987 }
43988 Py_INCREF(Py_None); resultobj = Py_None;
43989 return resultobj;
43990 fail:
43991 return NULL;
43992 }
43993
43994
43995 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43996 PyObject *resultobj;
43997 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43998 wxWindow *arg2 = (wxWindow *) 0 ;
43999 int arg3 = (int) 0 ;
44000 PyObject * obj0 = 0 ;
44001 PyObject * obj1 = 0 ;
44002 PyObject * obj2 = 0 ;
44003 char *kwnames[] = {
44004 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44005 };
44006
44007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44009 if (SWIG_arg_fail(1)) SWIG_fail;
44010 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44011 if (SWIG_arg_fail(2)) SWIG_fail;
44012 if (obj2) {
44013 {
44014 arg3 = (int)(SWIG_As_int(obj2));
44015 if (SWIG_arg_fail(3)) SWIG_fail;
44016 }
44017 }
44018 {
44019 PyThreadState* __tstate = wxPyBeginAllowThreads();
44020 (arg1)->LeftOf(arg2,arg3);
44021
44022 wxPyEndAllowThreads(__tstate);
44023 if (PyErr_Occurred()) SWIG_fail;
44024 }
44025 Py_INCREF(Py_None); resultobj = Py_None;
44026 return resultobj;
44027 fail:
44028 return NULL;
44029 }
44030
44031
44032 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44033 PyObject *resultobj;
44034 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44035 wxWindow *arg2 = (wxWindow *) 0 ;
44036 int arg3 = (int) 0 ;
44037 PyObject * obj0 = 0 ;
44038 PyObject * obj1 = 0 ;
44039 PyObject * obj2 = 0 ;
44040 char *kwnames[] = {
44041 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44042 };
44043
44044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44046 if (SWIG_arg_fail(1)) SWIG_fail;
44047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44048 if (SWIG_arg_fail(2)) SWIG_fail;
44049 if (obj2) {
44050 {
44051 arg3 = (int)(SWIG_As_int(obj2));
44052 if (SWIG_arg_fail(3)) SWIG_fail;
44053 }
44054 }
44055 {
44056 PyThreadState* __tstate = wxPyBeginAllowThreads();
44057 (arg1)->RightOf(arg2,arg3);
44058
44059 wxPyEndAllowThreads(__tstate);
44060 if (PyErr_Occurred()) SWIG_fail;
44061 }
44062 Py_INCREF(Py_None); resultobj = Py_None;
44063 return resultobj;
44064 fail:
44065 return NULL;
44066 }
44067
44068
44069 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44070 PyObject *resultobj;
44071 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44072 wxWindow *arg2 = (wxWindow *) 0 ;
44073 int arg3 = (int) 0 ;
44074 PyObject * obj0 = 0 ;
44075 PyObject * obj1 = 0 ;
44076 PyObject * obj2 = 0 ;
44077 char *kwnames[] = {
44078 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44079 };
44080
44081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44083 if (SWIG_arg_fail(1)) SWIG_fail;
44084 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44085 if (SWIG_arg_fail(2)) SWIG_fail;
44086 if (obj2) {
44087 {
44088 arg3 = (int)(SWIG_As_int(obj2));
44089 if (SWIG_arg_fail(3)) SWIG_fail;
44090 }
44091 }
44092 {
44093 PyThreadState* __tstate = wxPyBeginAllowThreads();
44094 (arg1)->Above(arg2,arg3);
44095
44096 wxPyEndAllowThreads(__tstate);
44097 if (PyErr_Occurred()) SWIG_fail;
44098 }
44099 Py_INCREF(Py_None); resultobj = Py_None;
44100 return resultobj;
44101 fail:
44102 return NULL;
44103 }
44104
44105
44106 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44107 PyObject *resultobj;
44108 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44109 wxWindow *arg2 = (wxWindow *) 0 ;
44110 int arg3 = (int) 0 ;
44111 PyObject * obj0 = 0 ;
44112 PyObject * obj1 = 0 ;
44113 PyObject * obj2 = 0 ;
44114 char *kwnames[] = {
44115 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44116 };
44117
44118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44120 if (SWIG_arg_fail(1)) SWIG_fail;
44121 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44122 if (SWIG_arg_fail(2)) SWIG_fail;
44123 if (obj2) {
44124 {
44125 arg3 = (int)(SWIG_As_int(obj2));
44126 if (SWIG_arg_fail(3)) SWIG_fail;
44127 }
44128 }
44129 {
44130 PyThreadState* __tstate = wxPyBeginAllowThreads();
44131 (arg1)->Below(arg2,arg3);
44132
44133 wxPyEndAllowThreads(__tstate);
44134 if (PyErr_Occurred()) SWIG_fail;
44135 }
44136 Py_INCREF(Py_None); resultobj = Py_None;
44137 return resultobj;
44138 fail:
44139 return NULL;
44140 }
44141
44142
44143 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44144 PyObject *resultobj;
44145 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44146 wxWindow *arg2 = (wxWindow *) 0 ;
44147 wxEdge arg3 ;
44148 int arg4 = (int) 0 ;
44149 PyObject * obj0 = 0 ;
44150 PyObject * obj1 = 0 ;
44151 PyObject * obj2 = 0 ;
44152 PyObject * obj3 = 0 ;
44153 char *kwnames[] = {
44154 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44155 };
44156
44157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44159 if (SWIG_arg_fail(1)) SWIG_fail;
44160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44161 if (SWIG_arg_fail(2)) SWIG_fail;
44162 {
44163 arg3 = (wxEdge)(SWIG_As_int(obj2));
44164 if (SWIG_arg_fail(3)) SWIG_fail;
44165 }
44166 if (obj3) {
44167 {
44168 arg4 = (int)(SWIG_As_int(obj3));
44169 if (SWIG_arg_fail(4)) SWIG_fail;
44170 }
44171 }
44172 {
44173 PyThreadState* __tstate = wxPyBeginAllowThreads();
44174 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44175
44176 wxPyEndAllowThreads(__tstate);
44177 if (PyErr_Occurred()) SWIG_fail;
44178 }
44179 Py_INCREF(Py_None); resultobj = Py_None;
44180 return resultobj;
44181 fail:
44182 return NULL;
44183 }
44184
44185
44186 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44187 PyObject *resultobj;
44188 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44189 wxWindow *arg2 = (wxWindow *) 0 ;
44190 wxEdge arg3 ;
44191 int arg4 ;
44192 PyObject * obj0 = 0 ;
44193 PyObject * obj1 = 0 ;
44194 PyObject * obj2 = 0 ;
44195 PyObject * obj3 = 0 ;
44196 char *kwnames[] = {
44197 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44198 };
44199
44200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44202 if (SWIG_arg_fail(1)) SWIG_fail;
44203 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44204 if (SWIG_arg_fail(2)) SWIG_fail;
44205 {
44206 arg3 = (wxEdge)(SWIG_As_int(obj2));
44207 if (SWIG_arg_fail(3)) SWIG_fail;
44208 }
44209 {
44210 arg4 = (int)(SWIG_As_int(obj3));
44211 if (SWIG_arg_fail(4)) SWIG_fail;
44212 }
44213 {
44214 PyThreadState* __tstate = wxPyBeginAllowThreads();
44215 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44216
44217 wxPyEndAllowThreads(__tstate);
44218 if (PyErr_Occurred()) SWIG_fail;
44219 }
44220 Py_INCREF(Py_None); resultobj = Py_None;
44221 return resultobj;
44222 fail:
44223 return NULL;
44224 }
44225
44226
44227 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44228 PyObject *resultobj;
44229 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44230 int arg2 ;
44231 PyObject * obj0 = 0 ;
44232 PyObject * obj1 = 0 ;
44233 char *kwnames[] = {
44234 (char *) "self",(char *) "val", NULL
44235 };
44236
44237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44239 if (SWIG_arg_fail(1)) SWIG_fail;
44240 {
44241 arg2 = (int)(SWIG_As_int(obj1));
44242 if (SWIG_arg_fail(2)) SWIG_fail;
44243 }
44244 {
44245 PyThreadState* __tstate = wxPyBeginAllowThreads();
44246 (arg1)->Absolute(arg2);
44247
44248 wxPyEndAllowThreads(__tstate);
44249 if (PyErr_Occurred()) SWIG_fail;
44250 }
44251 Py_INCREF(Py_None); resultobj = Py_None;
44252 return resultobj;
44253 fail:
44254 return NULL;
44255 }
44256
44257
44258 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44259 PyObject *resultobj;
44260 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44261 PyObject * obj0 = 0 ;
44262 char *kwnames[] = {
44263 (char *) "self", NULL
44264 };
44265
44266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44268 if (SWIG_arg_fail(1)) SWIG_fail;
44269 {
44270 PyThreadState* __tstate = wxPyBeginAllowThreads();
44271 (arg1)->Unconstrained();
44272
44273 wxPyEndAllowThreads(__tstate);
44274 if (PyErr_Occurred()) SWIG_fail;
44275 }
44276 Py_INCREF(Py_None); resultobj = Py_None;
44277 return resultobj;
44278 fail:
44279 return NULL;
44280 }
44281
44282
44283 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44284 PyObject *resultobj;
44285 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44286 PyObject * obj0 = 0 ;
44287 char *kwnames[] = {
44288 (char *) "self", NULL
44289 };
44290
44291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44293 if (SWIG_arg_fail(1)) SWIG_fail;
44294 {
44295 PyThreadState* __tstate = wxPyBeginAllowThreads();
44296 (arg1)->AsIs();
44297
44298 wxPyEndAllowThreads(__tstate);
44299 if (PyErr_Occurred()) SWIG_fail;
44300 }
44301 Py_INCREF(Py_None); resultobj = Py_None;
44302 return resultobj;
44303 fail:
44304 return NULL;
44305 }
44306
44307
44308 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44309 PyObject *resultobj;
44310 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44311 wxWindow *result;
44312 PyObject * obj0 = 0 ;
44313 char *kwnames[] = {
44314 (char *) "self", NULL
44315 };
44316
44317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44319 if (SWIG_arg_fail(1)) SWIG_fail;
44320 {
44321 PyThreadState* __tstate = wxPyBeginAllowThreads();
44322 result = (wxWindow *)(arg1)->GetOtherWindow();
44323
44324 wxPyEndAllowThreads(__tstate);
44325 if (PyErr_Occurred()) SWIG_fail;
44326 }
44327 {
44328 resultobj = wxPyMake_wxObject(result, 0);
44329 }
44330 return resultobj;
44331 fail:
44332 return NULL;
44333 }
44334
44335
44336 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44337 PyObject *resultobj;
44338 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44339 wxEdge result;
44340 PyObject * obj0 = 0 ;
44341 char *kwnames[] = {
44342 (char *) "self", NULL
44343 };
44344
44345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44347 if (SWIG_arg_fail(1)) SWIG_fail;
44348 {
44349 PyThreadState* __tstate = wxPyBeginAllowThreads();
44350 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44351
44352 wxPyEndAllowThreads(__tstate);
44353 if (PyErr_Occurred()) SWIG_fail;
44354 }
44355 resultobj = SWIG_From_int((result));
44356 return resultobj;
44357 fail:
44358 return NULL;
44359 }
44360
44361
44362 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44363 PyObject *resultobj;
44364 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44365 wxEdge arg2 ;
44366 PyObject * obj0 = 0 ;
44367 PyObject * obj1 = 0 ;
44368 char *kwnames[] = {
44369 (char *) "self",(char *) "which", NULL
44370 };
44371
44372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44374 if (SWIG_arg_fail(1)) SWIG_fail;
44375 {
44376 arg2 = (wxEdge)(SWIG_As_int(obj1));
44377 if (SWIG_arg_fail(2)) SWIG_fail;
44378 }
44379 {
44380 PyThreadState* __tstate = wxPyBeginAllowThreads();
44381 (arg1)->SetEdge((wxEdge )arg2);
44382
44383 wxPyEndAllowThreads(__tstate);
44384 if (PyErr_Occurred()) SWIG_fail;
44385 }
44386 Py_INCREF(Py_None); resultobj = Py_None;
44387 return resultobj;
44388 fail:
44389 return NULL;
44390 }
44391
44392
44393 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44394 PyObject *resultobj;
44395 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44396 int arg2 ;
44397 PyObject * obj0 = 0 ;
44398 PyObject * obj1 = 0 ;
44399 char *kwnames[] = {
44400 (char *) "self",(char *) "v", NULL
44401 };
44402
44403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44405 if (SWIG_arg_fail(1)) SWIG_fail;
44406 {
44407 arg2 = (int)(SWIG_As_int(obj1));
44408 if (SWIG_arg_fail(2)) SWIG_fail;
44409 }
44410 {
44411 PyThreadState* __tstate = wxPyBeginAllowThreads();
44412 (arg1)->SetValue(arg2);
44413
44414 wxPyEndAllowThreads(__tstate);
44415 if (PyErr_Occurred()) SWIG_fail;
44416 }
44417 Py_INCREF(Py_None); resultobj = Py_None;
44418 return resultobj;
44419 fail:
44420 return NULL;
44421 }
44422
44423
44424 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44425 PyObject *resultobj;
44426 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44427 int result;
44428 PyObject * obj0 = 0 ;
44429 char *kwnames[] = {
44430 (char *) "self", NULL
44431 };
44432
44433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44435 if (SWIG_arg_fail(1)) SWIG_fail;
44436 {
44437 PyThreadState* __tstate = wxPyBeginAllowThreads();
44438 result = (int)(arg1)->GetMargin();
44439
44440 wxPyEndAllowThreads(__tstate);
44441 if (PyErr_Occurred()) SWIG_fail;
44442 }
44443 {
44444 resultobj = SWIG_From_int((int)(result));
44445 }
44446 return resultobj;
44447 fail:
44448 return NULL;
44449 }
44450
44451
44452 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44453 PyObject *resultobj;
44454 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44455 int arg2 ;
44456 PyObject * obj0 = 0 ;
44457 PyObject * obj1 = 0 ;
44458 char *kwnames[] = {
44459 (char *) "self",(char *) "m", NULL
44460 };
44461
44462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44464 if (SWIG_arg_fail(1)) SWIG_fail;
44465 {
44466 arg2 = (int)(SWIG_As_int(obj1));
44467 if (SWIG_arg_fail(2)) SWIG_fail;
44468 }
44469 {
44470 PyThreadState* __tstate = wxPyBeginAllowThreads();
44471 (arg1)->SetMargin(arg2);
44472
44473 wxPyEndAllowThreads(__tstate);
44474 if (PyErr_Occurred()) SWIG_fail;
44475 }
44476 Py_INCREF(Py_None); resultobj = Py_None;
44477 return resultobj;
44478 fail:
44479 return NULL;
44480 }
44481
44482
44483 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44484 PyObject *resultobj;
44485 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44486 int result;
44487 PyObject * obj0 = 0 ;
44488 char *kwnames[] = {
44489 (char *) "self", NULL
44490 };
44491
44492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44494 if (SWIG_arg_fail(1)) SWIG_fail;
44495 {
44496 PyThreadState* __tstate = wxPyBeginAllowThreads();
44497 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44498
44499 wxPyEndAllowThreads(__tstate);
44500 if (PyErr_Occurred()) SWIG_fail;
44501 }
44502 {
44503 resultobj = SWIG_From_int((int)(result));
44504 }
44505 return resultobj;
44506 fail:
44507 return NULL;
44508 }
44509
44510
44511 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44512 PyObject *resultobj;
44513 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44514 int result;
44515 PyObject * obj0 = 0 ;
44516 char *kwnames[] = {
44517 (char *) "self", NULL
44518 };
44519
44520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44522 if (SWIG_arg_fail(1)) SWIG_fail;
44523 {
44524 PyThreadState* __tstate = wxPyBeginAllowThreads();
44525 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44526
44527 wxPyEndAllowThreads(__tstate);
44528 if (PyErr_Occurred()) SWIG_fail;
44529 }
44530 {
44531 resultobj = SWIG_From_int((int)(result));
44532 }
44533 return resultobj;
44534 fail:
44535 return NULL;
44536 }
44537
44538
44539 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44540 PyObject *resultobj;
44541 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44542 int result;
44543 PyObject * obj0 = 0 ;
44544 char *kwnames[] = {
44545 (char *) "self", NULL
44546 };
44547
44548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44550 if (SWIG_arg_fail(1)) SWIG_fail;
44551 {
44552 PyThreadState* __tstate = wxPyBeginAllowThreads();
44553 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44554
44555 wxPyEndAllowThreads(__tstate);
44556 if (PyErr_Occurred()) SWIG_fail;
44557 }
44558 {
44559 resultobj = SWIG_From_int((int)(result));
44560 }
44561 return resultobj;
44562 fail:
44563 return NULL;
44564 }
44565
44566
44567 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44568 PyObject *resultobj;
44569 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44570 bool result;
44571 PyObject * obj0 = 0 ;
44572 char *kwnames[] = {
44573 (char *) "self", NULL
44574 };
44575
44576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44578 if (SWIG_arg_fail(1)) SWIG_fail;
44579 {
44580 PyThreadState* __tstate = wxPyBeginAllowThreads();
44581 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44582
44583 wxPyEndAllowThreads(__tstate);
44584 if (PyErr_Occurred()) SWIG_fail;
44585 }
44586 {
44587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44588 }
44589 return resultobj;
44590 fail:
44591 return NULL;
44592 }
44593
44594
44595 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44596 PyObject *resultobj;
44597 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44598 bool arg2 ;
44599 PyObject * obj0 = 0 ;
44600 PyObject * obj1 = 0 ;
44601 char *kwnames[] = {
44602 (char *) "self",(char *) "d", NULL
44603 };
44604
44605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44607 if (SWIG_arg_fail(1)) SWIG_fail;
44608 {
44609 arg2 = (bool)(SWIG_As_bool(obj1));
44610 if (SWIG_arg_fail(2)) SWIG_fail;
44611 }
44612 {
44613 PyThreadState* __tstate = wxPyBeginAllowThreads();
44614 (arg1)->SetDone(arg2);
44615
44616 wxPyEndAllowThreads(__tstate);
44617 if (PyErr_Occurred()) SWIG_fail;
44618 }
44619 Py_INCREF(Py_None); resultobj = Py_None;
44620 return resultobj;
44621 fail:
44622 return NULL;
44623 }
44624
44625
44626 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44627 PyObject *resultobj;
44628 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44629 wxRelationship result;
44630 PyObject * obj0 = 0 ;
44631 char *kwnames[] = {
44632 (char *) "self", NULL
44633 };
44634
44635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44637 if (SWIG_arg_fail(1)) SWIG_fail;
44638 {
44639 PyThreadState* __tstate = wxPyBeginAllowThreads();
44640 result = (wxRelationship)(arg1)->GetRelationship();
44641
44642 wxPyEndAllowThreads(__tstate);
44643 if (PyErr_Occurred()) SWIG_fail;
44644 }
44645 resultobj = SWIG_From_int((result));
44646 return resultobj;
44647 fail:
44648 return NULL;
44649 }
44650
44651
44652 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44653 PyObject *resultobj;
44654 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44655 wxRelationship arg2 ;
44656 PyObject * obj0 = 0 ;
44657 PyObject * obj1 = 0 ;
44658 char *kwnames[] = {
44659 (char *) "self",(char *) "r", NULL
44660 };
44661
44662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44664 if (SWIG_arg_fail(1)) SWIG_fail;
44665 {
44666 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44667 if (SWIG_arg_fail(2)) SWIG_fail;
44668 }
44669 {
44670 PyThreadState* __tstate = wxPyBeginAllowThreads();
44671 (arg1)->SetRelationship((wxRelationship )arg2);
44672
44673 wxPyEndAllowThreads(__tstate);
44674 if (PyErr_Occurred()) SWIG_fail;
44675 }
44676 Py_INCREF(Py_None); resultobj = Py_None;
44677 return resultobj;
44678 fail:
44679 return NULL;
44680 }
44681
44682
44683 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44684 PyObject *resultobj;
44685 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44686 wxWindow *arg2 = (wxWindow *) 0 ;
44687 bool result;
44688 PyObject * obj0 = 0 ;
44689 PyObject * obj1 = 0 ;
44690 char *kwnames[] = {
44691 (char *) "self",(char *) "otherW", NULL
44692 };
44693
44694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44696 if (SWIG_arg_fail(1)) SWIG_fail;
44697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44698 if (SWIG_arg_fail(2)) SWIG_fail;
44699 {
44700 PyThreadState* __tstate = wxPyBeginAllowThreads();
44701 result = (bool)(arg1)->ResetIfWin(arg2);
44702
44703 wxPyEndAllowThreads(__tstate);
44704 if (PyErr_Occurred()) SWIG_fail;
44705 }
44706 {
44707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44708 }
44709 return resultobj;
44710 fail:
44711 return NULL;
44712 }
44713
44714
44715 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44716 PyObject *resultobj;
44717 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44718 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44719 wxWindow *arg3 = (wxWindow *) 0 ;
44720 bool result;
44721 PyObject * obj0 = 0 ;
44722 PyObject * obj1 = 0 ;
44723 PyObject * obj2 = 0 ;
44724 char *kwnames[] = {
44725 (char *) "self",(char *) "constraints",(char *) "win", NULL
44726 };
44727
44728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44730 if (SWIG_arg_fail(1)) SWIG_fail;
44731 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44732 if (SWIG_arg_fail(2)) SWIG_fail;
44733 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44734 if (SWIG_arg_fail(3)) SWIG_fail;
44735 {
44736 PyThreadState* __tstate = wxPyBeginAllowThreads();
44737 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44738
44739 wxPyEndAllowThreads(__tstate);
44740 if (PyErr_Occurred()) SWIG_fail;
44741 }
44742 {
44743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44744 }
44745 return resultobj;
44746 fail:
44747 return NULL;
44748 }
44749
44750
44751 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44752 PyObject *resultobj;
44753 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44754 wxEdge arg2 ;
44755 wxWindow *arg3 = (wxWindow *) 0 ;
44756 wxWindow *arg4 = (wxWindow *) 0 ;
44757 int result;
44758 PyObject * obj0 = 0 ;
44759 PyObject * obj1 = 0 ;
44760 PyObject * obj2 = 0 ;
44761 PyObject * obj3 = 0 ;
44762 char *kwnames[] = {
44763 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44764 };
44765
44766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44768 if (SWIG_arg_fail(1)) SWIG_fail;
44769 {
44770 arg2 = (wxEdge)(SWIG_As_int(obj1));
44771 if (SWIG_arg_fail(2)) SWIG_fail;
44772 }
44773 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44774 if (SWIG_arg_fail(3)) SWIG_fail;
44775 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44776 if (SWIG_arg_fail(4)) SWIG_fail;
44777 {
44778 PyThreadState* __tstate = wxPyBeginAllowThreads();
44779 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44780
44781 wxPyEndAllowThreads(__tstate);
44782 if (PyErr_Occurred()) SWIG_fail;
44783 }
44784 {
44785 resultobj = SWIG_From_int((int)(result));
44786 }
44787 return resultobj;
44788 fail:
44789 return NULL;
44790 }
44791
44792
44793 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44794 PyObject *obj;
44795 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44796 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44797 Py_INCREF(obj);
44798 return Py_BuildValue((char *)"");
44799 }
44800 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44801 PyObject *resultobj;
44802 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44803 wxIndividualLayoutConstraint *result;
44804 PyObject * obj0 = 0 ;
44805 char *kwnames[] = {
44806 (char *) "self", NULL
44807 };
44808
44809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44811 if (SWIG_arg_fail(1)) SWIG_fail;
44812 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44813
44814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44815 return resultobj;
44816 fail:
44817 return NULL;
44818 }
44819
44820
44821 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44822 PyObject *resultobj;
44823 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44824 wxIndividualLayoutConstraint *result;
44825 PyObject * obj0 = 0 ;
44826 char *kwnames[] = {
44827 (char *) "self", NULL
44828 };
44829
44830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44832 if (SWIG_arg_fail(1)) SWIG_fail;
44833 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44834
44835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44836 return resultobj;
44837 fail:
44838 return NULL;
44839 }
44840
44841
44842 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44843 PyObject *resultobj;
44844 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44845 wxIndividualLayoutConstraint *result;
44846 PyObject * obj0 = 0 ;
44847 char *kwnames[] = {
44848 (char *) "self", NULL
44849 };
44850
44851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44853 if (SWIG_arg_fail(1)) SWIG_fail;
44854 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44855
44856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44857 return resultobj;
44858 fail:
44859 return NULL;
44860 }
44861
44862
44863 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44864 PyObject *resultobj;
44865 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44866 wxIndividualLayoutConstraint *result;
44867 PyObject * obj0 = 0 ;
44868 char *kwnames[] = {
44869 (char *) "self", NULL
44870 };
44871
44872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44874 if (SWIG_arg_fail(1)) SWIG_fail;
44875 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44876
44877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44878 return resultobj;
44879 fail:
44880 return NULL;
44881 }
44882
44883
44884 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44885 PyObject *resultobj;
44886 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44887 wxIndividualLayoutConstraint *result;
44888 PyObject * obj0 = 0 ;
44889 char *kwnames[] = {
44890 (char *) "self", NULL
44891 };
44892
44893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44895 if (SWIG_arg_fail(1)) SWIG_fail;
44896 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44897
44898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44899 return resultobj;
44900 fail:
44901 return NULL;
44902 }
44903
44904
44905 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44906 PyObject *resultobj;
44907 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44908 wxIndividualLayoutConstraint *result;
44909 PyObject * obj0 = 0 ;
44910 char *kwnames[] = {
44911 (char *) "self", NULL
44912 };
44913
44914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44916 if (SWIG_arg_fail(1)) SWIG_fail;
44917 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44918
44919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44920 return resultobj;
44921 fail:
44922 return NULL;
44923 }
44924
44925
44926 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44927 PyObject *resultobj;
44928 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44929 wxIndividualLayoutConstraint *result;
44930 PyObject * obj0 = 0 ;
44931 char *kwnames[] = {
44932 (char *) "self", NULL
44933 };
44934
44935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44937 if (SWIG_arg_fail(1)) SWIG_fail;
44938 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44939
44940 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44941 return resultobj;
44942 fail:
44943 return NULL;
44944 }
44945
44946
44947 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44948 PyObject *resultobj;
44949 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44950 wxIndividualLayoutConstraint *result;
44951 PyObject * obj0 = 0 ;
44952 char *kwnames[] = {
44953 (char *) "self", NULL
44954 };
44955
44956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44958 if (SWIG_arg_fail(1)) SWIG_fail;
44959 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44960
44961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44962 return resultobj;
44963 fail:
44964 return NULL;
44965 }
44966
44967
44968 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44969 PyObject *resultobj;
44970 wxLayoutConstraints *result;
44971 char *kwnames[] = {
44972 NULL
44973 };
44974
44975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44976 {
44977 PyThreadState* __tstate = wxPyBeginAllowThreads();
44978 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44979
44980 wxPyEndAllowThreads(__tstate);
44981 if (PyErr_Occurred()) SWIG_fail;
44982 }
44983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44984 return resultobj;
44985 fail:
44986 return NULL;
44987 }
44988
44989
44990 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44991 PyObject *resultobj;
44992 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44993 wxWindow *arg2 = (wxWindow *) 0 ;
44994 int *arg3 = (int *) 0 ;
44995 bool result;
44996 int temp3 ;
44997 int res3 = 0 ;
44998 PyObject * obj0 = 0 ;
44999 PyObject * obj1 = 0 ;
45000 char *kwnames[] = {
45001 (char *) "self",(char *) "win", NULL
45002 };
45003
45004 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45007 if (SWIG_arg_fail(1)) SWIG_fail;
45008 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45009 if (SWIG_arg_fail(2)) SWIG_fail;
45010 {
45011 PyThreadState* __tstate = wxPyBeginAllowThreads();
45012 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45013
45014 wxPyEndAllowThreads(__tstate);
45015 if (PyErr_Occurred()) SWIG_fail;
45016 }
45017 {
45018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45019 }
45020 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45021 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45022 return resultobj;
45023 fail:
45024 return NULL;
45025 }
45026
45027
45028 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45029 PyObject *resultobj;
45030 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45031 bool result;
45032 PyObject * obj0 = 0 ;
45033 char *kwnames[] = {
45034 (char *) "self", NULL
45035 };
45036
45037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45039 if (SWIG_arg_fail(1)) SWIG_fail;
45040 {
45041 PyThreadState* __tstate = wxPyBeginAllowThreads();
45042 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45043
45044 wxPyEndAllowThreads(__tstate);
45045 if (PyErr_Occurred()) SWIG_fail;
45046 }
45047 {
45048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45049 }
45050 return resultobj;
45051 fail:
45052 return NULL;
45053 }
45054
45055
45056 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45057 PyObject *obj;
45058 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45059 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45060 Py_INCREF(obj);
45061 return Py_BuildValue((char *)"");
45062 }
45063 static PyMethodDef SwigMethods[] = {
45064 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45065 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45066 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45069 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45090 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45103 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45118 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45172 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45200 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45219 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45221 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45229 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45230 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45242 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45254 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45258 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45264 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45274 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45284 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45288 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45367 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45369 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45371 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45373 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45375 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45377 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45379 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45381 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45383 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45385 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45387 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45389 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45391 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45405 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45423 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45426 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45429 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45441 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45446 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45452 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45458 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45521 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45528 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45564 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45574 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45580 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45582 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45584 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45587 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45591 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45594 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45597 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45599 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45604 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45612 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45616 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45619 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45621 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45625 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45642 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45644 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45647 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45649 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45653 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45657 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45668 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45671 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45674 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45678 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45685 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45690 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45695 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45699 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45744 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45764 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45771 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45775 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45785 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45957 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45997 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46011 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46014 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46069 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46096 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46140 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46148 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46167 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46168 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46205 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46235 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46238 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46242 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46245 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46255 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46267 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46279 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46289 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46299 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46313 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46320 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46321 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46322 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46323 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46324 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46329 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46356 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46368 { NULL, NULL, 0, NULL }
46369 };
46370
46371
46372 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46373
46374 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46375 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46376 }
46377 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46378 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46379 }
46380 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46381 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46382 }
46383 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46384 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46385 }
46386 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46387 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46388 }
46389 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46390 return (void *)((wxSizer *) ((wxGridSizer *) x));
46391 }
46392 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46393 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46394 }
46395 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46396 return (void *)((wxSizer *) ((wxPySizer *) x));
46397 }
46398 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46399 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46400 }
46401 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46402 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46403 }
46404 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46405 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46406 }
46407 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46408 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46409 }
46410 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46411 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46412 }
46413 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46414 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46415 }
46416 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46417 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46418 }
46419 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46420 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46421 }
46422 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46423 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46424 }
46425 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46426 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46427 }
46428 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46429 return (void *)((wxEvent *) ((wxPyEvent *) x));
46430 }
46431 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46432 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46433 }
46434 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46435 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46436 }
46437 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46438 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46439 }
46440 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46441 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46442 }
46443 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46444 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46445 }
46446 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46447 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46448 }
46449 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46450 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46451 }
46452 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46453 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46454 }
46455 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46456 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46457 }
46458 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46459 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46460 }
46461 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46462 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46463 }
46464 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46465 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46466 }
46467 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46468 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46469 }
46470 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46471 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46472 }
46473 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46474 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46475 }
46476 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46477 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46478 }
46479 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46480 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46481 }
46482 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46483 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46484 }
46485 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46486 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46487 }
46488 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46489 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46490 }
46491 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46492 return (void *)((wxEvent *) ((wxShowEvent *) x));
46493 }
46494 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46495 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46496 }
46497 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46498 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46499 }
46500 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46501 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46502 }
46503 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46504 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46505 }
46506 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46507 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46508 }
46509 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46510 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46511 }
46512 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46513 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46514 }
46515 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46516 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46517 }
46518 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46519 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46520 }
46521 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46522 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46523 }
46524 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46525 return (void *)((wxControl *) ((wxControlWithItems *) x));
46526 }
46527 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46528 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46529 }
46530 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46531 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46532 }
46533 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46534 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46535 }
46536 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46537 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46538 }
46539 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46540 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46541 }
46542 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46543 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46544 }
46545 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46546 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46547 }
46548 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46549 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46550 }
46551 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46552 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46553 }
46554 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46555 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46556 }
46557 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46558 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46559 }
46560 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46561 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46562 }
46563 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46564 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46565 }
46566 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46567 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46568 }
46569 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46570 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46571 }
46572 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46573 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46574 }
46575 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46576 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46577 }
46578 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46579 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46580 }
46581 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46582 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46583 }
46584 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46585 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46586 }
46587 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46588 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46589 }
46590 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46591 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46592 }
46593 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46594 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46595 }
46596 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46597 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46598 }
46599 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46600 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46601 }
46602 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46603 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46604 }
46605 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46606 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46607 }
46608 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46609 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46610 }
46611 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46612 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46613 }
46614 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46615 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46616 }
46617 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46618 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46619 }
46620 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46621 return (void *)((wxObject *) ((wxSizerItem *) x));
46622 }
46623 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46624 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46625 }
46626 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46627 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46628 }
46629 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46630 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46631 }
46632 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46633 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46634 }
46635 static void *_p_wxSizerTo_p_wxObject(void *x) {
46636 return (void *)((wxObject *) ((wxSizer *) x));
46637 }
46638 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46639 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46640 }
46641 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46642 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46643 }
46644 static void *_p_wxEventTo_p_wxObject(void *x) {
46645 return (void *)((wxObject *) ((wxEvent *) x));
46646 }
46647 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46648 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46649 }
46650 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46651 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46652 }
46653 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46654 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46655 }
46656 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46657 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46658 }
46659 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46660 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46661 }
46662 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46663 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46664 }
46665 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46666 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46667 }
46668 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46669 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46670 }
46671 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46672 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46673 }
46674 static void *_p_wxControlTo_p_wxObject(void *x) {
46675 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46676 }
46677 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46678 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46679 }
46680 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46681 return (void *)((wxObject *) ((wxFSFile *) x));
46682 }
46683 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46684 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46685 }
46686 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46687 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46688 }
46689 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46690 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46691 }
46692 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46693 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46694 }
46695 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46696 return (void *)((wxObject *) ((wxMenuItem *) x));
46697 }
46698 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46699 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46700 }
46701 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46702 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46703 }
46704 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46705 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46706 }
46707 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46708 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46709 }
46710 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46711 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46712 }
46713 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46714 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46715 }
46716 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46717 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46718 }
46719 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46720 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46721 }
46722 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46723 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46724 }
46725 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46726 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46727 }
46728 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46729 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46730 }
46731 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46732 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46733 }
46734 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46735 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46736 }
46737 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46738 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46739 }
46740 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46741 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46742 }
46743 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46744 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46745 }
46746 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46747 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46748 }
46749 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46750 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46751 }
46752 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46753 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46754 }
46755 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46756 return (void *)((wxObject *) ((wxImageHandler *) x));
46757 }
46758 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46759 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46760 }
46761 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46762 return (void *)((wxObject *) ((wxEvtHandler *) x));
46763 }
46764 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46765 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46766 }
46767 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46768 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46769 }
46770 static void *_p_wxImageTo_p_wxObject(void *x) {
46771 return (void *)((wxObject *) ((wxImage *) x));
46772 }
46773 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46774 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46775 }
46776 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46777 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46778 }
46779 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46780 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46781 }
46782 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46783 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46784 }
46785 static void *_p_wxWindowTo_p_wxObject(void *x) {
46786 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46787 }
46788 static void *_p_wxMenuTo_p_wxObject(void *x) {
46789 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46790 }
46791 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46792 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46793 }
46794 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46795 return (void *)((wxObject *) ((wxFileSystem *) x));
46796 }
46797 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46798 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46799 }
46800 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46801 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46802 }
46803 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46804 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46805 }
46806 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46807 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46808 }
46809 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46810 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46811 }
46812 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46813 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46814 }
46815 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46816 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46817 }
46818 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46819 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46820 }
46821 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46822 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46823 }
46824 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46825 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46826 }
46827 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46828 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46829 }
46830 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46831 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46832 }
46833 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46834 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46835 }
46836 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46837 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46838 }
46839 static void *_p_wxControlTo_p_wxWindow(void *x) {
46840 return (void *)((wxWindow *) ((wxControl *) x));
46841 }
46842 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46843 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46844 }
46845 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46846 return (void *)((wxWindow *) ((wxMenuBar *) x));
46847 }
46848 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46849 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46850 }
46851 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46852 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46853 }
46854 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46855 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46856 }
46857 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46858 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46859 }
46860 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46861 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46862 }
46863 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46864 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46865 }
46866 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46867 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46868 }
46869 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46870 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46871 }
46872 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46873 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46874 }
46875 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46876 return (void *)((wxValidator *) ((wxPyValidator *) x));
46877 }
46878 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}};
46879 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}};
46880 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}};
46881 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}};
46882 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}};
46883 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}};
46884 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}};
46885 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}};
46886 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}};
46887 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}};
46888 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}};
46889 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}};
46890 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}};
46891 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}};
46892 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}};
46893 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}};
46894 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}};
46895 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}};
46896 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}};
46897 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}};
46898 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}};
46899 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}};
46900 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}};
46901 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}};
46902 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}};
46903 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}};
46904 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}};
46905 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}};
46906 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}};
46907 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}};
46908 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}};
46909 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}};
46910 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}};
46911 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}};
46912 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}};
46913 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}};
46914 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}};
46915 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}};
46916 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}};
46917 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}};
46918 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}};
46919 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}};
46920 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}};
46921 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}};
46922 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}};
46923 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}};
46924 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}};
46925 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}};
46926 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}};
46927 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}};
46928 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}};
46929 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}};
46930 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}};
46931 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}};
46932 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}};
46933 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}};
46934 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}};
46935 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}};
46936 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}};
46937 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}};
46938 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}};
46939 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}};
46940 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}};
46941 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}};
46942 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}};
46943 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}};
46944 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}};
46945 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}};
46946 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}};
46947 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}};
46948 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}};
46949 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}};
46950 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}};
46951 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}};
46952 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}};
46953 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}};
46954 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}};
46955 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}};
46956 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}};
46957 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}};
46958 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}};
46959 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}};
46960 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}};
46961 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}};
46962 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}};
46963 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}};
46964 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}};
46965 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}};
46966 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}};
46967 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}};
46968 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}};
46969 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}};
46970 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}};
46971 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}};
46972 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}};
46973 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}};
46974 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}};
46975 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}};
46976 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}};
46977 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}};
46978 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}};
46979 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}};
46980 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}};
46981 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}};
46982 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}};
46983 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}};
46984 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}};
46985 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}};
46986 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}};
46987 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}};
46988 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}};
46989 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}};
46990 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}};
46991 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}};
46992 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}};
46993 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}};
46994 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}};
46995 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}};
46996 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}};
46997 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}};
46998 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}};
46999 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}};
47000 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}};
47001 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}};
47002 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}};
47003 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}};
47004 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}};
47005
47006 static swig_type_info *swig_types_initial[] = {
47007 _swigt__p_wxLayoutConstraints,
47008 _swigt__p_wxRealPoint,
47009 _swigt__p_wxSizerItem,
47010 _swigt__p_wxGBSizerItem,
47011 _swigt__p_wxScrollEvent,
47012 _swigt__p_wxEventLoop,
47013 _swigt__p_wxIndividualLayoutConstraint,
47014 _swigt__p_wxSizer,
47015 _swigt__p_wxBoxSizer,
47016 _swigt__p_wxStaticBoxSizer,
47017 _swigt__p_wxGridBagSizer,
47018 _swigt__p_wxAcceleratorEntry,
47019 _swigt__p_wxUpdateUIEvent,
47020 _swigt__p_wxEvent,
47021 _swigt__p_wxMenu,
47022 _swigt__p_wxGridSizer,
47023 _swigt__p_wxFlexGridSizer,
47024 _swigt__p_wxInitDialogEvent,
47025 _swigt__p_wxItemContainer,
47026 _swigt__p_wxNcPaintEvent,
47027 _swigt__p_wxPaintEvent,
47028 _swigt__p_wxSysColourChangedEvent,
47029 _swigt__p_wxMouseCaptureChangedEvent,
47030 _swigt__p_wxDisplayChangedEvent,
47031 _swigt__p_wxPaletteChangedEvent,
47032 _swigt__p_wxControl,
47033 _swigt__p_wxFont,
47034 _swigt__p_wxMenuBarBase,
47035 _swigt__p_wxSetCursorEvent,
47036 _swigt__p_wxFSFile,
47037 _swigt__p_wxCaret,
47038 _swigt__ptrdiff_t,
47039 _swigt__std__ptrdiff_t,
47040 _swigt__p_wxRegion,
47041 _swigt__p_wxPoint2D,
47042 _swigt__p_int,
47043 _swigt__p_wxSize,
47044 _swigt__p_wxDC,
47045 _swigt__p_wxPySizer,
47046 _swigt__p_wxVisualAttributes,
47047 _swigt__p_wxNotifyEvent,
47048 _swigt__p_wxPyEvent,
47049 _swigt__p_wxPropagationDisabler,
47050 _swigt__p_form_ops_t,
47051 _swigt__p_wxAppTraits,
47052 _swigt__p_wxArrayString,
47053 _swigt__p_wxShowEvent,
47054 _swigt__p_wxToolTip,
47055 _swigt__p_wxMoveEvent,
47056 _swigt__p_wxSizeEvent,
47057 _swigt__p_wxActivateEvent,
47058 _swigt__p_wxIconizeEvent,
47059 _swigt__p_wxMaximizeEvent,
47060 _swigt__p_wxQueryNewPaletteEvent,
47061 _swigt__p_wxWindowCreateEvent,
47062 _swigt__p_wxIdleEvent,
47063 _swigt__p_wxDateEvent,
47064 _swigt__p_wxMenuItem,
47065 _swigt__p_wxStaticBox,
47066 _swigt__p_long,
47067 _swigt__p_wxDuplexMode,
47068 _swigt__p_wxTIFFHandler,
47069 _swigt__p_wxXPMHandler,
47070 _swigt__p_wxPNMHandler,
47071 _swigt__p_wxJPEGHandler,
47072 _swigt__p_wxPCXHandler,
47073 _swigt__p_wxGIFHandler,
47074 _swigt__p_wxPNGHandler,
47075 _swigt__p_wxANIHandler,
47076 _swigt__p_wxMemoryFSHandler,
47077 _swigt__p_wxZipFSHandler,
47078 _swigt__p_wxInternetFSHandler,
47079 _swigt__p_wxPyFileSystemHandler,
47080 _swigt__p_wxEvtHandler,
47081 _swigt__p_wxCURHandler,
47082 _swigt__p_wxICOHandler,
47083 _swigt__p_wxBMPHandler,
47084 _swigt__p_wxImageHandler,
47085 _swigt__p_wxFileSystemHandler,
47086 _swigt__p_wxRect,
47087 _swigt__p_wxButton,
47088 _swigt__p_wxGBSpan,
47089 _swigt__p_wxPropagateOnce,
47090 _swigt__p_wxAcceleratorTable,
47091 _swigt__p_wxStdDialogButtonSizer,
47092 _swigt__p_char,
47093 _swigt__p_wxGBPosition,
47094 _swigt__p_wxImage,
47095 _swigt__p_wxFrame,
47096 _swigt__p_wxScrollWinEvent,
47097 _swigt__p_wxPaperSize,
47098 _swigt__p_wxImageHistogram,
47099 _swigt__p_wxPoint,
47100 _swigt__p_wxCursor,
47101 _swigt__p_wxObject,
47102 _swigt__p_wxInputStream,
47103 _swigt__p_wxOutputStream,
47104 _swigt__p_wxPyInputStream,
47105 _swigt__p_wxDateTime,
47106 _swigt__p_wxKeyEvent,
47107 _swigt__p_wxNavigationKeyEvent,
47108 _swigt__p_wxWindowDestroyEvent,
47109 _swigt__p_unsigned_long,
47110 _swigt__p_wxWindow,
47111 _swigt__p_wxMenuBar,
47112 _swigt__p_wxFileSystem,
47113 _swigt__p_wxBitmap,
47114 _swigt__unsigned_int,
47115 _swigt__p_unsigned_int,
47116 _swigt__p_wxMenuEvent,
47117 _swigt__p_wxContextMenuEvent,
47118 _swigt__p_unsigned_char,
47119 _swigt__p_wxEraseEvent,
47120 _swigt__p_wxMouseEvent,
47121 _swigt__p_wxCloseEvent,
47122 _swigt__p_wxPyApp,
47123 _swigt__p_wxCommandEvent,
47124 _swigt__p_wxPyCommandEvent,
47125 _swigt__p_wxPyDropTarget,
47126 _swigt__p_wxQuantize,
47127 _swigt__p_wxChildFocusEvent,
47128 _swigt__p_wxFocusEvent,
47129 _swigt__p_wxDropFilesEvent,
47130 _swigt__p_wxControlWithItems,
47131 _swigt__p_wxColour,
47132 _swigt__p_wxValidator,
47133 _swigt__p_wxPyValidator,
47134 0
47135 };
47136
47137
47138 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47139
47140 static swig_const_info swig_const_table[] = {
47141 {0, 0, 0, 0.0, 0, 0}};
47142
47143 #ifdef __cplusplus
47144 }
47145 #endif
47146
47147
47148 #ifdef __cplusplus
47149 extern "C" {
47150 #endif
47151
47152 /* Python-specific SWIG API */
47153 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47154 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47155 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47156
47157 /* -----------------------------------------------------------------------------
47158 * global variable support code.
47159 * ----------------------------------------------------------------------------- */
47160
47161 typedef struct swig_globalvar {
47162 char *name; /* Name of global variable */
47163 PyObject *(*get_attr)(); /* Return the current value */
47164 int (*set_attr)(PyObject *); /* Set the value */
47165 struct swig_globalvar *next;
47166 } swig_globalvar;
47167
47168 typedef struct swig_varlinkobject {
47169 PyObject_HEAD
47170 swig_globalvar *vars;
47171 } swig_varlinkobject;
47172
47173 static PyObject *
47174 swig_varlink_repr(swig_varlinkobject *v) {
47175 v = v;
47176 return PyString_FromString("<Swig global variables>");
47177 }
47178
47179 static int
47180 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47181 swig_globalvar *var;
47182 flags = flags;
47183 fprintf(fp,"Swig global variables { ");
47184 for (var = v->vars; var; var=var->next) {
47185 fprintf(fp,"%s", var->name);
47186 if (var->next) fprintf(fp,", ");
47187 }
47188 fprintf(fp," }\n");
47189 return 0;
47190 }
47191
47192 static PyObject *
47193 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47194 swig_globalvar *var = v->vars;
47195 while (var) {
47196 if (strcmp(var->name,n) == 0) {
47197 return (*var->get_attr)();
47198 }
47199 var = var->next;
47200 }
47201 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47202 return NULL;
47203 }
47204
47205 static int
47206 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47207 swig_globalvar *var = v->vars;
47208 while (var) {
47209 if (strcmp(var->name,n) == 0) {
47210 return (*var->set_attr)(p);
47211 }
47212 var = var->next;
47213 }
47214 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47215 return 1;
47216 }
47217
47218 static PyTypeObject varlinktype = {
47219 PyObject_HEAD_INIT(0)
47220 0, /* Number of items in variable part (ob_size) */
47221 (char *)"swigvarlink", /* Type name (tp_name) */
47222 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47223 0, /* Itemsize (tp_itemsize) */
47224 0, /* Deallocator (tp_dealloc) */
47225 (printfunc) swig_varlink_print, /* Print (tp_print) */
47226 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47227 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47228 0, /* tp_compare */
47229 (reprfunc) swig_varlink_repr, /* tp_repr */
47230 0, /* tp_as_number */
47231 0, /* tp_as_sequence */
47232 0, /* tp_as_mapping */
47233 0, /* tp_hash */
47234 0, /* tp_call */
47235 0, /* tp_str */
47236 0, /* tp_getattro */
47237 0, /* tp_setattro */
47238 0, /* tp_as_buffer */
47239 0, /* tp_flags */
47240 0, /* tp_doc */
47241 #if PY_VERSION_HEX >= 0x02000000
47242 0, /* tp_traverse */
47243 0, /* tp_clear */
47244 #endif
47245 #if PY_VERSION_HEX >= 0x02010000
47246 0, /* tp_richcompare */
47247 0, /* tp_weaklistoffset */
47248 #endif
47249 #if PY_VERSION_HEX >= 0x02020000
47250 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47251 #endif
47252 #if PY_VERSION_HEX >= 0x02030000
47253 0, /* tp_del */
47254 #endif
47255 #ifdef COUNT_ALLOCS
47256 0,0,0,0 /* tp_alloc -> tp_next */
47257 #endif
47258 };
47259
47260 /* Create a variable linking object for use later */
47261 static PyObject *
47262 SWIG_Python_newvarlink(void) {
47263 swig_varlinkobject *result = 0;
47264 result = PyMem_NEW(swig_varlinkobject,1);
47265 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47266 result->ob_type = &varlinktype;
47267 result->vars = 0;
47268 result->ob_refcnt = 0;
47269 Py_XINCREF((PyObject *) result);
47270 return ((PyObject*) result);
47271 }
47272
47273 static void
47274 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47275 swig_varlinkobject *v;
47276 swig_globalvar *gv;
47277 v= (swig_varlinkobject *) p;
47278 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47279 gv->name = (char *) malloc(strlen(name)+1);
47280 strcpy(gv->name,name);
47281 gv->get_attr = get_attr;
47282 gv->set_attr = set_attr;
47283 gv->next = v->vars;
47284 v->vars = gv;
47285 }
47286
47287 /* -----------------------------------------------------------------------------
47288 * constants/methods manipulation
47289 * ----------------------------------------------------------------------------- */
47290
47291 /* Install Constants */
47292 static void
47293 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47294 PyObject *obj = 0;
47295 size_t i;
47296 for (i = 0; constants[i].type; i++) {
47297 switch(constants[i].type) {
47298 case SWIG_PY_INT:
47299 obj = PyInt_FromLong(constants[i].lvalue);
47300 break;
47301 case SWIG_PY_FLOAT:
47302 obj = PyFloat_FromDouble(constants[i].dvalue);
47303 break;
47304 case SWIG_PY_STRING:
47305 if (constants[i].pvalue) {
47306 obj = PyString_FromString((char *) constants[i].pvalue);
47307 } else {
47308 Py_INCREF(Py_None);
47309 obj = Py_None;
47310 }
47311 break;
47312 case SWIG_PY_POINTER:
47313 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47314 break;
47315 case SWIG_PY_BINARY:
47316 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47317 break;
47318 default:
47319 obj = 0;
47320 break;
47321 }
47322 if (obj) {
47323 PyDict_SetItemString(d,constants[i].name,obj);
47324 Py_DECREF(obj);
47325 }
47326 }
47327 }
47328
47329 /* -----------------------------------------------------------------------------*/
47330 /* Fix SwigMethods to carry the callback ptrs when needed */
47331 /* -----------------------------------------------------------------------------*/
47332
47333 static void
47334 SWIG_Python_FixMethods(PyMethodDef *methods,
47335 swig_const_info *const_table,
47336 swig_type_info **types,
47337 swig_type_info **types_initial) {
47338 size_t i;
47339 for (i = 0; methods[i].ml_name; ++i) {
47340 char *c = methods[i].ml_doc;
47341 if (c && (c = strstr(c, "swig_ptr: "))) {
47342 int j;
47343 swig_const_info *ci = 0;
47344 char *name = c + 10;
47345 for (j = 0; const_table[j].type; j++) {
47346 if (strncmp(const_table[j].name, name,
47347 strlen(const_table[j].name)) == 0) {
47348 ci = &(const_table[j]);
47349 break;
47350 }
47351 }
47352 if (ci) {
47353 size_t shift = (ci->ptype) - types;
47354 swig_type_info *ty = types_initial[shift];
47355 size_t ldoc = (c - methods[i].ml_doc);
47356 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47357 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47358 char *buff = ndoc;
47359 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47360 strncpy(buff, methods[i].ml_doc, ldoc);
47361 buff += ldoc;
47362 strncpy(buff, "swig_ptr: ", 10);
47363 buff += 10;
47364 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47365 methods[i].ml_doc = ndoc;
47366 }
47367 }
47368 }
47369 }
47370
47371 /* -----------------------------------------------------------------------------*
47372 * Initialize type list
47373 * -----------------------------------------------------------------------------*/
47374
47375 #if PY_MAJOR_VERSION < 2
47376 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47377 is copied out of Python/modsupport.c in python version 2.3.4 */
47378 static int
47379 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47380 {
47381 PyObject *dict;
47382 if (!PyModule_Check(m)) {
47383 PyErr_SetString(PyExc_TypeError,
47384 "PyModule_AddObject() needs module as first arg");
47385 return -1;
47386 }
47387 if (!o) {
47388 PyErr_SetString(PyExc_TypeError,
47389 "PyModule_AddObject() needs non-NULL value");
47390 return -1;
47391 }
47392
47393 dict = PyModule_GetDict(m);
47394 if (dict == NULL) {
47395 /* Internal error -- modules must have a dict! */
47396 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47397 PyModule_GetName(m));
47398 return -1;
47399 }
47400 if (PyDict_SetItemString(dict, name, o))
47401 return -1;
47402 Py_DECREF(o);
47403 return 0;
47404 }
47405 #endif
47406
47407 static swig_type_info **
47408 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47409 static PyMethodDef swig_empty_runtime_method_table[] = {
47410 {
47411 NULL, NULL, 0, NULL
47412 }
47413 };/* Sentinel */
47414
47415 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47416 swig_empty_runtime_method_table);
47417 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47418 if (pointer && module) {
47419 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47420 }
47421 return type_list_handle;
47422 }
47423
47424 static swig_type_info **
47425 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47426 swig_type_info **type_pointer;
47427
47428 /* first check if module already created */
47429 type_pointer = SWIG_Python_GetTypeListHandle();
47430 if (type_pointer) {
47431 return type_pointer;
47432 } else {
47433 /* create a new module and variable */
47434 return SWIG_Python_SetTypeListHandle(type_list_handle);
47435 }
47436 }
47437
47438 #ifdef __cplusplus
47439 }
47440 #endif
47441
47442 /* -----------------------------------------------------------------------------*
47443 * Partial Init method
47444 * -----------------------------------------------------------------------------*/
47445
47446 #ifdef SWIG_LINK_RUNTIME
47447 #ifdef __cplusplus
47448 extern "C"
47449 #endif
47450 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47451 #endif
47452
47453 #ifdef __cplusplus
47454 extern "C"
47455 #endif
47456 SWIGEXPORT(void) SWIG_init(void) {
47457 static PyObject *SWIG_globals = 0;
47458 static int typeinit = 0;
47459 PyObject *m, *d;
47460 int i;
47461 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47462
47463 /* Fix SwigMethods to carry the callback ptrs when needed */
47464 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47465
47466 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47467 d = PyModule_GetDict(m);
47468
47469 if (!typeinit) {
47470 #ifdef SWIG_LINK_RUNTIME
47471 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47472 #else
47473 # ifndef SWIG_STATIC_RUNTIME
47474 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47475 # endif
47476 #endif
47477 for (i = 0; swig_types_initial[i]; i++) {
47478 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47479 }
47480 typeinit = 1;
47481 }
47482 SWIG_InstallConstants(d,swig_const_table);
47483
47484
47485 #ifndef wxPyUSE_EXPORT
47486 // Make our API structure a CObject so other modules can import it
47487 // from this module.
47488 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47489 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47490 Py_XDECREF(cobj);
47491 #endif
47492
47493 {
47494 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47495 }
47496 {
47497 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47498 }
47499 {
47500 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47501 }
47502 {
47503 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47504 }
47505 {
47506 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47507 }
47508 {
47509 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47510 }
47511 {
47512 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47513 }
47514 {
47515 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47516 }
47517 {
47518 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47519 }
47520 {
47521 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47522 }
47523 {
47524 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47525 }
47526 {
47527 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47528 }
47529 {
47530 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47531 }
47532 {
47533 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47534 }
47535 {
47536 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47537 }
47538 {
47539 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47540 }
47541 {
47542 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47543 }
47544 {
47545 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47546 }
47547 {
47548 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
47549 }
47550 {
47551 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
47552 }
47553 {
47554 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
47555 }
47556 {
47557 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
47558 }
47559 {
47560 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
47561 }
47562 {
47563 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47564 }
47565 {
47566 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47567 }
47568 {
47569 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47570 }
47571 {
47572 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47573 }
47574 {
47575 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47576 }
47577 {
47578 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47579 }
47580 {
47581 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47582 }
47583 {
47584 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47585 }
47586 {
47587 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47588 }
47589 {
47590 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47591 }
47592 {
47593 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47594 }
47595 {
47596 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47597 }
47598 {
47599 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47600 }
47601 {
47602 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47603 }
47604 {
47605 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47606 }
47607 {
47608 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47609 }
47610 {
47611 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47612 }
47613 {
47614 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47615 }
47616 {
47617 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47618 }
47619 {
47620 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47621 }
47622 {
47623 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47624 }
47625 {
47626 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47627 }
47628 {
47629 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47630 }
47631 {
47632 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47633 }
47634 {
47635 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47636 }
47637 {
47638 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47639 }
47640 {
47641 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47642 }
47643 {
47644 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47645 }
47646 {
47647 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47648 }
47649 {
47650 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47651 }
47652 {
47653 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47654 }
47655 {
47656 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47657 }
47658 {
47659 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47660 }
47661 {
47662 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47663 }
47664 {
47665 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47666 }
47667 {
47668 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47669 }
47670 {
47671 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47672 }
47673 {
47674 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47675 }
47676 {
47677 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47678 }
47679 {
47680 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47681 }
47682 {
47683 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47684 }
47685 {
47686 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47687 }
47688 {
47689 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47690 }
47691 {
47692 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47693 }
47694 {
47695 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47696 }
47697 {
47698 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47699 }
47700 {
47701 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47702 }
47703 {
47704 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47705 }
47706 {
47707 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47708 }
47709 {
47710 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47711 }
47712 {
47713 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47714 }
47715 {
47716 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47717 }
47718 {
47719 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47720 }
47721 {
47722 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47723 }
47724 {
47725 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47726 }
47727 {
47728 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47729 }
47730 {
47731 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47732 }
47733 {
47734 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47735 }
47736 {
47737 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47738 }
47739 {
47740 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47741 }
47742 {
47743 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47744 }
47745 {
47746 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47747 }
47748 {
47749 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47750 }
47751 {
47752 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47753 }
47754 {
47755 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47756 }
47757 {
47758 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47759 }
47760 {
47761 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47762 }
47763 {
47764 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47765 }
47766 {
47767 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47768 }
47769 {
47770 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47771 }
47772 {
47773 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47774 }
47775 {
47776 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47777 }
47778 {
47779 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47780 }
47781 {
47782 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47783 }
47784 {
47785 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47786 }
47787 {
47788 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47789 }
47790 {
47791 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47792 }
47793 {
47794 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47795 }
47796 {
47797 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47798 }
47799 {
47800 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47801 }
47802 {
47803 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47804 }
47805 {
47806 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47807 }
47808 {
47809 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47810 }
47811 {
47812 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47813 }
47814 {
47815 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47816 }
47817 {
47818 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47819 }
47820 {
47821 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47822 }
47823 {
47824 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47825 }
47826 {
47827 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47828 }
47829 {
47830 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47831 }
47832 {
47833 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47834 }
47835 {
47836 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47837 }
47838 {
47839 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47840 }
47841 {
47842 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47843 }
47844 {
47845 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47846 }
47847 {
47848 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47849 }
47850 {
47851 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47852 }
47853 {
47854 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47855 }
47856 {
47857 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47858 }
47859 {
47860 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47861 }
47862 {
47863 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47864 }
47865 {
47866 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47867 }
47868 {
47869 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47870 }
47871 {
47872 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47873 }
47874 {
47875 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47876 }
47877 {
47878 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47879 }
47880 {
47881 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47882 }
47883 {
47884 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47885 }
47886 {
47887 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47888 }
47889 {
47890 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47891 }
47892 {
47893 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47894 }
47895 {
47896 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47897 }
47898 {
47899 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47900 }
47901 {
47902 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47903 }
47904 {
47905 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47906 }
47907 {
47908 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47909 }
47910 {
47911 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47912 }
47913 {
47914 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47915 }
47916 {
47917 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47918 }
47919 {
47920 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47921 }
47922 {
47923 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47924 }
47925 {
47926 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47927 }
47928 {
47929 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47930 }
47931 {
47932 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47933 }
47934 {
47935 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47936 }
47937 {
47938 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47939 }
47940 {
47941 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47942 }
47943 {
47944 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47945 }
47946 {
47947 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47948 }
47949 {
47950 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47951 }
47952 {
47953 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47954 }
47955 {
47956 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47957 }
47958 {
47959 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47960 }
47961 {
47962 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47963 }
47964 {
47965 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47966 }
47967 {
47968 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47969 }
47970 {
47971 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47972 }
47973 {
47974 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47975 }
47976 {
47977 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47978 }
47979 {
47980 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47981 }
47982 {
47983 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47984 }
47985 {
47986 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47987 }
47988 {
47989 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47990 }
47991 {
47992 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47993 }
47994 {
47995 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47996 }
47997 {
47998 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47999 }
48000 {
48001 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48002 }
48003 {
48004 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48005 }
48006 {
48007 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48008 }
48009 {
48010 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48011 }
48012 {
48013 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48014 }
48015 {
48016 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48017 }
48018 {
48019 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48020 }
48021 {
48022 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48023 }
48024 {
48025 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48026 }
48027 {
48028 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48029 }
48030 {
48031 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48032 }
48033 {
48034 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48035 }
48036 {
48037 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48038 }
48039 {
48040 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48041 }
48042 {
48043 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48044 }
48045 {
48046 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48047 }
48048 {
48049 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48050 }
48051 {
48052 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48053 }
48054 {
48055 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48056 }
48057 {
48058 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48059 }
48060 {
48061 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48062 }
48063 {
48064 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48065 }
48066 {
48067 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48068 }
48069 {
48070 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48071 }
48072 {
48073 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48074 }
48075 {
48076 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48077 }
48078 {
48079 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48080 }
48081 {
48082 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48083 }
48084 {
48085 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48086 }
48087 {
48088 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48089 }
48090 {
48091 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48092 }
48093 {
48094 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48095 }
48096 {
48097 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48098 }
48099 {
48100 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48101 }
48102 {
48103 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48104 }
48105 {
48106 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48107 }
48108 {
48109 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48110 }
48111 {
48112 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48113 }
48114 {
48115 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48116 }
48117 {
48118 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48119 }
48120 {
48121 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48122 }
48123 {
48124 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48125 }
48126 {
48127 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48128 }
48129 {
48130 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48131 }
48132 {
48133 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48134 }
48135 {
48136 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48137 }
48138 {
48139 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48140 }
48141 {
48142 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48143 }
48144 {
48145 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48146 }
48147 {
48148 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48149 }
48150 {
48151 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48152 }
48153 {
48154 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48155 }
48156 {
48157 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48158 }
48159 {
48160 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48161 }
48162 {
48163 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48164 }
48165 {
48166 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48167 }
48168 {
48169 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48170 }
48171 {
48172 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48173 }
48174 {
48175 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48176 }
48177 {
48178 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48179 }
48180 {
48181 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48182 }
48183 {
48184 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48185 }
48186 {
48187 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48188 }
48189 {
48190 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48191 }
48192 {
48193 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48194 }
48195 {
48196 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48197 }
48198 {
48199 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48200 }
48201 {
48202 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48203 }
48204 {
48205 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48206 }
48207 {
48208 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48209 }
48210 {
48211 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48212 }
48213 {
48214 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48215 }
48216 {
48217 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48218 }
48219 {
48220 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48221 }
48222 {
48223 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48224 }
48225 {
48226 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48227 }
48228 {
48229 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48230 }
48231 {
48232 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48233 }
48234 {
48235 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48236 }
48237 {
48238 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48239 }
48240 {
48241 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48242 }
48243 {
48244 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48245 }
48246 {
48247 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48248 }
48249 {
48250 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48251 }
48252 {
48253 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48254 }
48255 {
48256 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48257 }
48258 {
48259 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48260 }
48261 {
48262 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48263 }
48264 {
48265 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48266 }
48267 {
48268 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48269 }
48270 {
48271 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48272 }
48273 {
48274 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48275 }
48276 {
48277 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48278 }
48279 {
48280 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48281 }
48282 {
48283 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48284 }
48285 {
48286 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48287 }
48288 {
48289 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48290 }
48291 {
48292 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48293 }
48294 {
48295 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48296 }
48297 {
48298 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48299 }
48300 {
48301 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48302 }
48303 {
48304 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48305 }
48306 {
48307 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48308 }
48309 {
48310 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48311 }
48312 {
48313 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48314 }
48315 {
48316 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48317 }
48318 {
48319 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48320 }
48321 {
48322 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48323 }
48324 {
48325 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48326 }
48327 {
48328 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48329 }
48330 {
48331 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48332 }
48333 {
48334 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48335 }
48336 {
48337 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48338 }
48339 {
48340 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48341 }
48342 {
48343 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48344 }
48345 {
48346 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48347 }
48348 {
48349 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48350 }
48351 {
48352 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48353 }
48354 {
48355 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48356 }
48357 {
48358 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48359 }
48360 {
48361 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48362 }
48363 {
48364 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48365 }
48366 {
48367 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48368 }
48369 {
48370 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48371 }
48372 {
48373 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48374 }
48375 {
48376 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48377 }
48378 {
48379 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48380 }
48381 {
48382 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48383 }
48384 {
48385 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48386 }
48387 {
48388 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48389 }
48390 {
48391 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48392 }
48393 {
48394 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48395 }
48396 {
48397 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48398 }
48399 {
48400 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48401 }
48402 {
48403 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48404 }
48405 {
48406 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48407 }
48408 {
48409 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48410 }
48411 {
48412 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48413 }
48414 {
48415 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48416 }
48417 {
48418 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48419 }
48420 {
48421 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48422 }
48423 {
48424 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48425 }
48426 {
48427 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48428 }
48429 {
48430 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48431 }
48432 {
48433 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48434 }
48435 {
48436 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48437 }
48438 {
48439 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48440 }
48441 {
48442 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48443 }
48444 {
48445 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48446 }
48447 {
48448 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48449 }
48450 {
48451 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48452 }
48453 {
48454 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48455 }
48456 {
48457 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48458 }
48459 {
48460 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48461 }
48462 {
48463 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48464 }
48465 {
48466 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48467 }
48468 {
48469 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48470 }
48471 {
48472 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48473 }
48474 {
48475 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48476 }
48477 {
48478 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48479 }
48480 {
48481 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48482 }
48483 {
48484 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48485 }
48486 {
48487 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48488 }
48489 {
48490 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48491 }
48492 {
48493 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48494 }
48495 {
48496 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48497 }
48498 {
48499 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48500 }
48501 {
48502 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48503 }
48504 {
48505 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48506 }
48507 {
48508 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48512 }
48513 {
48514 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48515 }
48516 {
48517 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48518 }
48519 {
48520 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48521 }
48522 {
48523 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48524 }
48525 {
48526 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48551 }
48552 {
48553 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48554 }
48555 {
48556 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48557 }
48558 {
48559 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48560 }
48561 {
48562 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48563 }
48564 {
48565 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48566 }
48567 {
48568 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48569 }
48570 {
48571 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48572 }
48573 {
48574 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48575 }
48576 {
48577 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48578 }
48579 {
48580 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48581 }
48582 {
48583 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48584 }
48585 {
48586 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48587 }
48588 {
48589 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48590 }
48591 {
48592 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48593 }
48594 {
48595 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48596 }
48597 {
48598 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48599 }
48600 {
48601 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48602 }
48603 {
48604 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48620 }
48621 {
48622 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48623 }
48624 {
48625 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48626 }
48627 {
48628 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48629 }
48630 {
48631 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48632 }
48633 {
48634 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48635 }
48636 {
48637 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48638 }
48639 {
48640 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48641 }
48642 {
48643 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48644 }
48645 {
48646 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48647 }
48648 {
48649 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48650 }
48651 {
48652 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48653 }
48654 {
48655 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48656 }
48657 {
48658 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48659 }
48660 {
48661 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48662 }
48663 {
48664 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48665 }
48666 {
48667 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48668 }
48669 {
48670 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48671 }
48672 {
48673 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48674 }
48675 {
48676 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48677 }
48678 {
48679 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48680 }
48681 {
48682 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48683 }
48684 {
48685 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48686 }
48687 {
48688 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48689 }
48690 {
48691 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48692 }
48693 {
48694 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48695 }
48696 {
48697 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48698 }
48699 {
48700 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48701 }
48702 {
48703 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48704 }
48705 {
48706 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48707 }
48708 {
48709 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48710 }
48711 {
48712 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48713 }
48714 {
48715 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48716 }
48717 {
48718 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48719 }
48720 {
48721 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48722 }
48723 {
48724 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48725 }
48726 {
48727 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48728 }
48729 {
48730 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48731 }
48732 {
48733 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48734 }
48735 {
48736 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48737 }
48738 {
48739 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48740 }
48741 {
48742 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48743 }
48744 {
48745 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48746 }
48747 {
48748 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48749 }
48750 {
48751 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48752 }
48753 {
48754 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48755 }
48756 {
48757 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48758 }
48759 {
48760 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48761 }
48762 {
48763 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48764 }
48765 {
48766 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48767 }
48768 {
48769 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48770 }
48771 {
48772 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48773 }
48774 {
48775 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48776 }
48777 {
48778 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48779 }
48780 {
48781 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48782 }
48783 {
48784 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48785 }
48786 {
48787 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48788 }
48789 {
48790 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48791 }
48792 {
48793 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48794 }
48795 {
48796 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48797 }
48798 {
48799 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48800 }
48801 {
48802 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48836 }
48837 {
48838 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48839 }
48840 {
48841 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48842 }
48843 {
48844 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48845 }
48846 {
48847 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48848 }
48849 {
48850 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48851 }
48852 {
48853 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48854 }
48855 {
48856 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48857 }
48858 {
48859 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48860 }
48861 {
48862 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48863 }
48864 {
48865 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48866 }
48867 {
48868 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48869 }
48870 {
48871 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48872 }
48873 {
48874 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48875 }
48876 {
48877 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48884 }
48885 {
48886 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48887 }
48888 {
48889 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48890 }
48891 {
48892 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48893 }
48894 {
48895 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48896 }
48897 {
48898 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48899 }
48900 {
48901 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48902 }
48903 {
48904 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48905 }
48906 {
48907 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48908 }
48909 {
48910 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48911 }
48912 {
48913 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48914 }
48915 {
48916 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48917 }
48918 {
48919 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48920 }
48921 {
48922 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48923 }
48924 {
48925 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48926 }
48927 {
48928 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48929 }
48930 {
48931 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48932 }
48933 {
48934 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48935 }
48936 {
48937 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48938 }
48939 {
48940 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48941 }
48942 {
48943 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48944 }
48945 {
48946 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48947 }
48948 {
48949 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48950 }
48951 {
48952 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48953 }
48954 {
48955 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48956 }
48957 {
48958 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48959 }
48960 {
48961 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48962 }
48963 {
48964 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48965 }
48966 {
48967 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48968 }
48969 {
48970 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48971 }
48972 {
48973 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48974 }
48975 {
48976 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48977 }
48978 {
48979 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48980 }
48981 {
48982 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48983 }
48984 {
48985 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48986 }
48987 {
48988 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48989 }
48990 {
48991 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48992 }
48993 {
48994 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48995 }
48996 {
48997 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48998 }
48999 {
49000 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49001 }
49002 {
49003 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49004 }
49005 {
49006 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49007 }
49008 {
49009 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49010 }
49011 {
49012 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49013 }
49014 {
49015 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49016 }
49017 {
49018 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49019 }
49020 {
49021 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49022 }
49023 {
49024 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49025 }
49026 {
49027 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49028 }
49029 {
49030 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49031 }
49032 {
49033 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49034 }
49035 {
49036 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49037 }
49038 {
49039 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49040 }
49041 {
49042 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49043 }
49044 {
49045 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49046 }
49047 {
49048 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49049 }
49050 {
49051 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49052 }
49053 {
49054 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49055 }
49056 {
49057 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49058 }
49059 {
49060 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49061 }
49062 {
49063 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49064 }
49065 {
49066 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49067 }
49068 {
49069 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49070 }
49071 {
49072 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49073 }
49074 {
49075 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49076 }
49077 {
49078 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49079 }
49080 {
49081 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49082 }
49083 {
49084 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49085 }
49086 {
49087 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49088 }
49089 {
49090 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49091 }
49092 {
49093 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49094 }
49095 {
49096 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49097 }
49098 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49099 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49100 {
49101 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49102 }
49103 {
49104 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49105 }
49106 {
49107 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49108 }
49109 {
49110 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49111 }
49112 {
49113 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49114 }
49115 {
49116 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49117 }
49118 {
49119 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49120 }
49121 {
49122 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49123 }
49124 {
49125 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49126 }
49127 {
49128 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49129 }
49130 {
49131 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49132 }
49133 {
49134 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49135 }
49136 {
49137 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49138 }
49139 {
49140 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49141 }
49142 {
49143 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49144 }
49145 {
49146 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49147 }
49148 {
49149 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49150 }
49151 {
49152 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49153 }
49154 {
49155 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49156 }
49157 {
49158 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49159 }
49160 {
49161 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49162 }
49163 {
49164 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49165 }
49166 {
49167 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49168 }
49169 {
49170 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49171 }
49172 {
49173 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49174 }
49175 {
49176 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49177 }
49178 {
49179 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49180 }
49181 {
49182 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49183 }
49184 {
49185 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49186 }
49187 {
49188 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49189 }
49190 {
49191 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49192 }
49193 {
49194 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49195 }
49196 {
49197 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49198 }
49199 {
49200 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49201 }
49202 {
49203 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49204 }
49205 {
49206 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49207 }
49208 {
49209 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49210 }
49211 {
49212 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49213 }
49214 {
49215 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49216 }
49217 {
49218 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49219 }
49220 {
49221 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49222 }
49223 {
49224 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49225 }
49226 {
49227 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49228 }
49229 {
49230 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49231 }
49232 {
49233 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49234 }
49235 {
49236 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49237 }
49238 {
49239 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49240 }
49241 {
49242 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49243 }
49244 {
49245 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49246 }
49247 {
49248 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49249 }
49250 {
49251 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49252 }
49253 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49254 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49255 {
49256 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49263 }
49264
49265 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49266
49267
49268 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49269
49270 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49271 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49272 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49273 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49274 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49275 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49276 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49277 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49278 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49279 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49280 {
49281 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49285 }
49286 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49287 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49288 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49289 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49290 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49291 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49292 {
49293 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49303 }
49304 {
49305 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49306 }
49307 {
49308 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49309 }
49310 {
49311 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49312 }
49313 {
49314 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49315 }
49316 {
49317 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49318 }
49319 {
49320 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49321 }
49322 {
49323 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49324 }
49325 {
49326 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49330 }
49331 {
49332 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49333 }
49334 {
49335 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49336 }
49337 {
49338 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49339 }
49340 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49341 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49342 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49343 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49344 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49345 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49346 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49347 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49348 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49349 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49350 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49351 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49352 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49353 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49354 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49355 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49356 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49357 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49358 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49359 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49360 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49361 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49362 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49363 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49364 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49365 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49366 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49367 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49368 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49369 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49370 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49371 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49372 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49373 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49374 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49375 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49376 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49377 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49378 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49379 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49380 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49381 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49382 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49383 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49384 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49385 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49386 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49387 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49388 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49389 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49390 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49391 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49392 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49393 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49394 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49395 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49396 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49397 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49398 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49399 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49400 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49401 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49402 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49403 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49404 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49405 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49406 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49407 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49408 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49409 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49410 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49411 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49412 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49413 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49414 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49415 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49416 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49417 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49418 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49419 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49420 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49421 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49422 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49423 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49424 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49425 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49426 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49427 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49428 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49429 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49430 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49431 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49432 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49433 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49434 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49435 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49436 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49437 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49438 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49439 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49440 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49441 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49442 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49443 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49444 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49445 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49446 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49447 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49448 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49449 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49450 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49451 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49452 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49453 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49454 {
49455 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49456 }
49457 {
49458 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49459 }
49460 {
49461 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49462 }
49463 {
49464 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49465 }
49466 {
49467 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49468 }
49469 {
49470 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49471 }
49472 {
49473 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49474 }
49475 {
49476 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49477 }
49478 {
49479 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49480 }
49481 {
49482 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49483 }
49484 {
49485 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49492 }
49493 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49494 {
49495 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49511 }
49512 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49513 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49514 {
49515 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49516 }
49517 {
49518 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49519 }
49520 {
49521 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49522 }
49523 {
49524 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49525 }
49526 {
49527 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49528 }
49529 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49530 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49531 {
49532 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49536 }
49537 {
49538 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49539 }
49540 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49541 {
49542 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49543 }
49544 {
49545 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49546 }
49547 {
49548 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49549 }
49550 {
49551 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49564 }
49565 {
49566 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49567 }
49568 {
49569 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49579 }
49580 {
49581 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49582 }
49583 {
49584 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49585 }
49586 {
49587 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49588 }
49589 {
49590 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49591 }
49592 {
49593 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49594 }
49595 {
49596 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49597 }
49598
49599 // Initialize threading, some globals and such
49600 __wxPyPreStart(d);
49601
49602
49603 // Although these are defined in __version__ they need to be here too so
49604 // that an assert can be done to ensure that the wxPython and the wxWindows
49605 // versions match.
49606 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49607 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49608 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49609
49610 }
49611
wxWidgets (Impactor)