projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Batch of changes:
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxMenuItem swig_types[56]
1398 #define SWIGTYPE_p_wxStaticBox swig_types[57]
1399 #define SWIGTYPE_p_long swig_types[58]
1400 #define SWIGTYPE_p_wxDuplexMode swig_types[59]
1401 #define SWIGTYPE_p_wxTIFFHandler swig_types[60]
1402 #define SWIGTYPE_p_wxXPMHandler swig_types[61]
1403 #define SWIGTYPE_p_wxPNMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxJPEGHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPCXHandler swig_types[64]
1406 #define SWIGTYPE_p_wxGIFHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPNGHandler swig_types[66]
1408 #define SWIGTYPE_p_wxANIHandler swig_types[67]
1409 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[68]
1410 #define SWIGTYPE_p_wxZipFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxInternetFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[71]
1413 #define SWIGTYPE_p_wxEvtHandler swig_types[72]
1414 #define SWIGTYPE_p_wxCURHandler swig_types[73]
1415 #define SWIGTYPE_p_wxICOHandler swig_types[74]
1416 #define SWIGTYPE_p_wxBMPHandler swig_types[75]
1417 #define SWIGTYPE_p_wxImageHandler swig_types[76]
1418 #define SWIGTYPE_p_wxFileSystemHandler swig_types[77]
1419 #define SWIGTYPE_p_wxRect swig_types[78]
1420 #define SWIGTYPE_p_wxButton swig_types[79]
1421 #define SWIGTYPE_p_wxGBSpan swig_types[80]
1422 #define SWIGTYPE_p_wxPropagateOnce swig_types[81]
1423 #define SWIGTYPE_p_wxAcceleratorTable swig_types[82]
1424 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[83]
1425 #define SWIGTYPE_p_char swig_types[84]
1426 #define SWIGTYPE_p_wxGBPosition swig_types[85]
1427 #define SWIGTYPE_p_wxImage swig_types[86]
1428 #define SWIGTYPE_p_wxFrame swig_types[87]
1429 #define SWIGTYPE_p_wxScrollWinEvent swig_types[88]
1430 #define SWIGTYPE_p_wxPaperSize swig_types[89]
1431 #define SWIGTYPE_p_wxImageHistogram swig_types[90]
1432 #define SWIGTYPE_p_wxPoint swig_types[91]
1433 #define SWIGTYPE_p_wxCursor swig_types[92]
1434 #define SWIGTYPE_p_wxObject swig_types[93]
1435 #define SWIGTYPE_p_wxInputStream swig_types[94]
1436 #define SWIGTYPE_p_wxOutputStream swig_types[95]
1437 #define SWIGTYPE_p_wxPyInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxDateTime swig_types[97]
1439 #define SWIGTYPE_p_wxKeyEvent swig_types[98]
1440 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[100]
1442 #define SWIGTYPE_p_unsigned_long swig_types[101]
1443 #define SWIGTYPE_p_wxWindow swig_types[102]
1444 #define SWIGTYPE_p_wxMenuBar swig_types[103]
1445 #define SWIGTYPE_p_wxFileSystem swig_types[104]
1446 #define SWIGTYPE_p_wxBitmap swig_types[105]
1447 #define SWIGTYPE_unsigned_int swig_types[106]
1448 #define SWIGTYPE_p_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_wxMenuEvent swig_types[108]
1450 #define SWIGTYPE_p_wxContextMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_unsigned_char swig_types[110]
1452 #define SWIGTYPE_p_wxEraseEvent swig_types[111]
1453 #define SWIGTYPE_p_wxMouseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxCloseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxPyApp swig_types[114]
1456 #define SWIGTYPE_p_wxCommandEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyDropTarget swig_types[117]
1459 #define SWIGTYPE_p_wxQuantize swig_types[118]
1460 #define SWIGTYPE_p_wxChildFocusEvent swig_types[119]
1461 #define SWIGTYPE_p_wxFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxDropFilesEvent swig_types[121]
1463 #define SWIGTYPE_p_wxControlWithItems swig_types[122]
1464 #define SWIGTYPE_p_wxColour swig_types[123]
1465 #define SWIGTYPE_p_wxValidator swig_types[124]
1466 #define SWIGTYPE_p_wxPyValidator swig_types[125]
1467 static swig_type_info *swig_types[127];
1468
1469 /* -------- TYPES TABLE (END) -------- */
1470
1471
1472 /*-----------------------------------------------
1473 @(target):= _core_.so
1474 ------------------------------------------------*/
1475 #define SWIG_init init_core_
1476
1477 #define SWIG_name "_core_"
1478
1479 #include "wx/wxPython/wxPython_int.h"
1480 #include "wx/wxPython/pyclasses.h"
1481
1482
1483 #ifndef wxPyUSE_EXPORT
1484 // Helper functions for dealing with SWIG objects and such. These are
1485 // located here so they know about the SWIG types and functions declared
1486 // in the wrapper code.
1487
1488 #include <wx/hashmap.h>
1489 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1490
1491
1492 // Maintains a hashmap of className to swig_type_info pointers. Given the
1493 // name of a class either looks up the type info in the cache, or scans the
1494 // SWIG tables for it.
1495 extern PyObject* wxPyPtrTypeMap;
1496 static
1497 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1498
1499 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1500
1501 if (typeInfoCache == NULL)
1502 typeInfoCache = new wxPyTypeInfoHashMap;
1503
1504 wxString name(className);
1505 swig_type_info* swigType = (*typeInfoCache)[name];
1506
1507 if (! swigType) {
1508 // it wasn't in the cache, so look it up from SWIG
1509 name.Append(wxT(" *"));
1510 swigType = SWIG_TypeQuery(name.mb_str());
1511
1512 // if it still wasn't found, try looking for a mapped name
1513 if (!swigType) {
1514 PyObject* item;
1515 name = className;
1516
1517 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1518 (char*)(const char*)name.mbc_str())) != NULL) {
1519 name = wxString(PyString_AsString(item), *wxConvCurrent);
1520 name.Append(wxT(" *"));
1521 swigType = SWIG_TypeQuery(name.mb_str());
1522 }
1523 }
1524 if (swigType) {
1525 // and add it to the map if found
1526 (*typeInfoCache)[className] = swigType;
1527 }
1528 }
1529 return swigType;
1530 }
1531
1532
1533 // Check if a class name is a type known to SWIG
1534 bool wxPyCheckSwigType(const wxChar* className) {
1535
1536 swig_type_info* swigType = wxPyFindSwigType(className);
1537 return swigType != NULL;
1538 }
1539
1540
1541 // Given a pointer to a C++ object and a class name, construct a Python proxy
1542 // object for it.
1543 PyObject* wxPyConstructObject(void* ptr,
1544 const wxChar* className,
1545 int setThisOwn) {
1546
1547 swig_type_info* swigType = wxPyFindSwigType(className);
1548 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1549
1550 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1551 }
1552
1553
1554 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1555 // Ensures that the proxy object is of the specified (or derived) type. If
1556 // not able to perform the conversion then a Python exception is set and the
1557 // error should be handled properly in the caller. Returns True on success.
1558 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1559 const wxChar* className) {
1560
1561 swig_type_info* swigType = wxPyFindSwigType(className);
1562 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1563
1564 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1565 }
1566
1567
1568 // Make a SWIGified pointer object suitable for a .this attribute
1569 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1570
1571 PyObject* robj = NULL;
1572
1573 swig_type_info* swigType = wxPyFindSwigType(className);
1574 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1575
1576 #ifdef SWIG_COBJECT_TYPES
1577 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1578 #else
1579 {
1580 char result[1024];
1581 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1582 PyString_FromString(result) : 0;
1583 }
1584 #endif
1585
1586 return robj;
1587 }
1588
1589
1590
1591
1592 // Export a C API in a struct. Other modules will be able to load this from
1593 // the wx._core_ module and will then have safe access to these functions,
1594 // even if they are located in another shared library.
1595 static wxPyCoreAPI API = {
1596
1597 wxPyCheckSwigType,
1598 wxPyConstructObject,
1599 wxPyConvertSwigPtr,
1600 wxPyMakeSwigPtr,
1601
1602 wxPyBeginAllowThreads,
1603 wxPyEndAllowThreads,
1604 wxPyBeginBlockThreads,
1605 wxPyEndBlockThreads,
1606
1607 wxPy_ConvertList,
1608
1609 wxString_in_helper,
1610 Py2wxString,
1611 wx2PyString,
1612
1613 byte_LIST_helper,
1614 int_LIST_helper,
1615 long_LIST_helper,
1616 string_LIST_helper,
1617 wxPoint_LIST_helper,
1618 wxBitmap_LIST_helper,
1619 wxString_LIST_helper,
1620 wxAcceleratorEntry_LIST_helper,
1621
1622 wxSize_helper,
1623 wxPoint_helper,
1624 wxRealPoint_helper,
1625 wxRect_helper,
1626 wxColour_helper,
1627 wxPoint2D_helper,
1628
1629 wxPySimple_typecheck,
1630 wxColour_typecheck,
1631
1632 wxPyCBH_setCallbackInfo,
1633 wxPyCBH_findCallback,
1634 wxPyCBH_callCallback,
1635 wxPyCBH_callCallbackObj,
1636 wxPyCBH_delete,
1637
1638 wxPyMake_wxObject,
1639 wxPyMake_wxSizer,
1640 wxPyPtrTypeMap_Add,
1641 wxPy2int_seq_helper,
1642 wxPy4int_seq_helper,
1643 wxArrayString2PyList_helper,
1644 wxArrayInt2PyList_helper,
1645
1646 wxPyClientData_dtor,
1647 wxPyUserData_dtor,
1648 wxPyOORClientData_dtor,
1649
1650 wxPyCBInputStream_create,
1651
1652 wxPyInstance_Check,
1653 wxPySwigInstance_Check,
1654
1655 wxPyCheckForApp
1656
1657 };
1658
1659 #endif
1660
1661
1662 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1663 #define SWIG_From_int PyInt_FromLong
1664 /*@@*/
1665
1666
1667 #if ! wxUSE_HOTKEY
1668 enum wxHotkeyModifier
1669 {
1670 wxMOD_NONE = 0,
1671 wxMOD_ALT = 1,
1672 wxMOD_CONTROL = 2,
1673 wxMOD_SHIFT = 4,
1674 wxMOD_WIN = 8
1675 };
1676 #define wxEVT_HOTKEY 9999
1677 #endif
1678
1679 static const wxString wxPyEmptyString(wxEmptyString);
1680 static wxString wxObject_GetClassName(wxObject *self){
1681 return self->GetClassInfo()->GetClassName();
1682 }
1683 static void wxObject_Destroy(wxObject *self){
1684 delete self;
1685 }
1686
1687 #ifndef __WXMAC__
1688 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1689 #endif
1690
1691
1692 #include <limits.h>
1693
1694
1695 SWIGINTERN int
1696 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1697 const char *errmsg)
1698 {
1699 if (value < min_value) {
1700 if (errmsg) {
1701 PyErr_Format(PyExc_OverflowError,
1702 "value %ld is less than '%s' minimum %ld",
1703 value, errmsg, min_value);
1704 }
1705 return 0;
1706 } else if (value > max_value) {
1707 if (errmsg) {
1708 PyErr_Format(PyExc_OverflowError,
1709 "value %ld is greater than '%s' maximum %ld",
1710 value, errmsg, max_value);
1711 }
1712 return 0;
1713 }
1714 return 1;
1715 }
1716
1717
1718 SWIGINTERN int
1719 SWIG_AsVal_long(PyObject* obj, long* val)
1720 {
1721 if (PyNumber_Check(obj)) {
1722 if (val) *val = PyInt_AsLong(obj);
1723 return 1;
1724 }
1725 else {
1726 SWIG_type_error("number", obj);
1727 }
1728 return 0;
1729 }
1730
1731
1732 #if INT_MAX != LONG_MAX
1733 SWIGINTERN int
1734 SWIG_AsVal_int(PyObject *obj, int *val)
1735 {
1736 const char* errmsg = val ? "int" : (char*)0;
1737 long v;
1738 if (SWIG_AsVal_long(obj, &v)) {
1739 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1740 if (val) *val = (int)(v);
1741 return 1;
1742 } else {
1743 return 0;
1744 }
1745 } else {
1746 PyErr_Clear();
1747 }
1748 if (val) {
1749 SWIG_type_error(errmsg, obj);
1750 }
1751 return 0;
1752 }
1753 #else
1754 SWIGINTERNSHORT int
1755 SWIG_AsVal_int(PyObject *obj, int *val)
1756 {
1757 return SWIG_AsVal_long(obj,(long*)val);
1758 }
1759 #endif
1760
1761
1762 SWIGINTERNSHORT int
1763 SWIG_As_int(PyObject* obj)
1764 {
1765 int v;
1766 if (!SWIG_AsVal_int(obj, &v)) {
1767 /*
1768 this is needed to make valgrind/purify happier.
1769 */
1770 memset((void*)&v, 0, sizeof(int));
1771 }
1772 return v;
1773 }
1774
1775
1776 SWIGINTERNSHORT int
1777 SWIG_Check_int(PyObject* obj)
1778 {
1779 return SWIG_AsVal_int(obj, (int*)0);
1780 }
1781
1782 static PyObject *wxSize_Get(wxSize *self){
1783 bool blocked = wxPyBeginBlockThreads();
1784 PyObject* tup = PyTuple_New(2);
1785 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1786 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1787 wxPyEndBlockThreads(blocked);
1788 return tup;
1789 }
1790
1791 SWIGINTERN int
1792 SWIG_AsVal_double(PyObject *obj, double* val)
1793 {
1794 if (PyNumber_Check(obj)) {
1795 if (val) *val = PyFloat_AsDouble(obj);
1796 return 1;
1797 }
1798 else {
1799 SWIG_type_error("number", obj);
1800 }
1801 return 0;
1802 }
1803
1804
1805 SWIGINTERNSHORT double
1806 SWIG_As_double(PyObject* obj)
1807 {
1808 double v;
1809 if (!SWIG_AsVal_double(obj, &v)) {
1810 /*
1811 this is needed to make valgrind/purify happier.
1812 */
1813 memset((void*)&v, 0, sizeof(double));
1814 }
1815 return v;
1816 }
1817
1818
1819 SWIGINTERNSHORT int
1820 SWIG_Check_double(PyObject* obj)
1821 {
1822 return SWIG_AsVal_double(obj, (double*)0);
1823 }
1824
1825
1826 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1827 #define SWIG_From_double PyFloat_FromDouble
1828 /*@@*/
1829
1830 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1831 self->x = x;
1832 self->y = y;
1833 }
1834 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1835 bool blocked = wxPyBeginBlockThreads();
1836 PyObject* tup = PyTuple_New(2);
1837 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1838 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1839 wxPyEndBlockThreads(blocked);
1840 return tup;
1841 }
1842
1843 SWIGINTERNSHORT long
1844 SWIG_As_long(PyObject* obj)
1845 {
1846 long v;
1847 if (!SWIG_AsVal_long(obj, &v)) {
1848 /*
1849 this is needed to make valgrind/purify happier.
1850 */
1851 memset((void*)&v, 0, sizeof(long));
1852 }
1853 return v;
1854 }
1855
1856
1857 SWIGINTERNSHORT int
1858 SWIG_Check_long(PyObject* obj)
1859 {
1860 return SWIG_AsVal_long(obj, (long*)0);
1861 }
1862
1863 static void wxPoint_Set(wxPoint *self,long x,long y){
1864 self->x = x;
1865 self->y = y;
1866 }
1867 static PyObject *wxPoint_Get(wxPoint *self){
1868 bool blocked = wxPyBeginBlockThreads();
1869 PyObject* tup = PyTuple_New(2);
1870 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1871 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1872 wxPyEndBlockThreads(blocked);
1873 return tup;
1874 }
1875 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1876 self->x = x;
1877 self->y = y;
1878 self->width = width;
1879 self->height = height;
1880 }
1881 static PyObject *wxRect_Get(wxRect *self){
1882 bool blocked = wxPyBeginBlockThreads();
1883 PyObject* tup = PyTuple_New(4);
1884 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1885 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1886 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1887 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1888 wxPyEndBlockThreads(blocked);
1889 return tup;
1890 }
1891
1892 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1893 wxRegion reg1(*r1);
1894 wxRegion reg2(*r2);
1895 wxRect dest(0,0,0,0);
1896 PyObject* obj;
1897
1898 reg1.Intersect(reg2);
1899 dest = reg1.GetBox();
1900
1901 if (dest != wxRect(0,0,0,0)) {
1902 bool blocked = wxPyBeginBlockThreads();
1903 wxRect* newRect = new wxRect(dest);
1904 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1905 wxPyEndBlockThreads(blocked);
1906 return obj;
1907 }
1908 Py_INCREF(Py_None);
1909 return Py_None;
1910 }
1911
1912
1913 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1914 PyObject* o2;
1915 PyObject* o3;
1916
1917 if (!target) {
1918 target = o;
1919 } else if (target == Py_None) {
1920 Py_DECREF(Py_None);
1921 target = o;
1922 } else {
1923 if (!PyTuple_Check(target)) {
1924 o2 = target;
1925 target = PyTuple_New(1);
1926 PyTuple_SetItem(target, 0, o2);
1927 }
1928 o3 = PyTuple_New(1);
1929 PyTuple_SetItem(o3, 0, o);
1930
1931 o2 = target;
1932 target = PySequence_Concat(o2, o3);
1933 Py_DECREF(o2);
1934 Py_DECREF(o3);
1935 }
1936 return target;
1937 }
1938
1939
1940 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1941 self->m_x = x;
1942 self->m_y = y;
1943 }
1944 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1945 bool blocked = wxPyBeginBlockThreads();
1946 PyObject* tup = PyTuple_New(2);
1947 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1948 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1949 wxPyEndBlockThreads(blocked);
1950 return tup;
1951 }
1952
1953 #include "wx/wxPython/pyistream.h"
1954
1955 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1956 wxInputStream* wxis = wxPyCBInputStream::create(p);
1957 if (wxis)
1958 return new wxPyInputStream(wxis);
1959 else
1960 return NULL;
1961 }
1962
1963 SWIGINTERNSHORT PyObject*
1964 SWIG_From_char(char c)
1965 {
1966 return PyString_FromStringAndSize(&c,1);
1967 }
1968
1969
1970 SWIGINTERNSHORT PyObject*
1971 SWIG_From_unsigned_SS_long(unsigned long value)
1972 {
1973 return (value > LONG_MAX) ?
1974 PyLong_FromUnsignedLong(value)
1975 : PyInt_FromLong((long)(value));
1976 }
1977
1978
1979 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1980 SWIGINTERN int
1981 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1982 {
1983 static swig_type_info* pchar_info = 0;
1984 char* vptr = 0;
1985 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1986 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1987 if (cptr) *cptr = vptr;
1988 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1989 return SWIG_OLDOBJ;
1990 } else {
1991 PyErr_Clear();
1992 if (PyString_Check(obj)) {
1993 if (cptr) {
1994 *cptr = PyString_AS_STRING(obj);
1995 if (psize) {
1996 *psize = PyString_GET_SIZE(obj) + 1;
1997 }
1998 }
1999 return SWIG_PYSTR;
2000 }
2001 }
2002 if (cptr) {
2003 SWIG_type_error("char *", obj);
2004 }
2005 return 0;
2006 }
2007
2008
2009 SWIGINTERN int
2010 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2011 {
2012 char* cptr; size_t csize;
2013 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2014 /* in C you can do:
2015
2016 char x[5] = "hello";
2017
2018 ie, assing the array using an extra '0' char.
2019 */
2020 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2021 if (csize <= size) {
2022 if (val) {
2023 if (csize) memcpy(val, cptr, csize);
2024 if (csize < size) memset(val + csize, 0, size - csize);
2025 }
2026 return 1;
2027 }
2028 }
2029 if (val) {
2030 PyErr_Format(PyExc_TypeError,
2031 "a char array of maximum size %lu is expected",
2032 (unsigned long) size);
2033 }
2034 return 0;
2035 }
2036
2037
2038 SWIGINTERN int
2039 SWIG_AsVal_char(PyObject *obj, char *val)
2040 {
2041 const char* errmsg = val ? "char" : (char*)0;
2042 long v;
2043 if (SWIG_AsVal_long(obj, &v)) {
2044 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2045 if (val) *val = (char)(v);
2046 return 1;
2047 } else {
2048 return 0;
2049 }
2050 } else {
2051 PyErr_Clear();
2052 return SWIG_AsCharArray(obj, val, 1);
2053 }
2054 }
2055
2056
2057 SWIGINTERNSHORT char
2058 SWIG_As_char(PyObject* obj)
2059 {
2060 char v;
2061 if (!SWIG_AsVal_char(obj, &v)) {
2062 /*
2063 this is needed to make valgrind/purify happier.
2064 */
2065 memset((void*)&v, 0, sizeof(char));
2066 }
2067 return v;
2068 }
2069
2070
2071 SWIGINTERNSHORT int
2072 SWIG_Check_char(PyObject* obj)
2073 {
2074 return SWIG_AsVal_char(obj, (char*)0);
2075 }
2076
2077
2078 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2079 #define SWIG_From_long PyInt_FromLong
2080 /*@@*/
2081
2082 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2083 // We use only strings for the streams, not unicode
2084 PyObject* str = PyObject_Str(obj);
2085 if (! str) {
2086 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2087 return;
2088 }
2089 self->Write(PyString_AS_STRING(str),
2090 PyString_GET_SIZE(str));
2091 Py_DECREF(str);
2092 }
2093
2094 #include "wx/wxPython/pyistream.h"
2095
2096
2097 class wxPyFileSystemHandler : public wxFileSystemHandler
2098 {
2099 public:
2100 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2101
2102 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2103 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2104 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2105 DEC_PYCALLBACK_STRING__pure(FindNext);
2106
2107 wxString GetProtocol(const wxString& location) {
2108 return wxFileSystemHandler::GetProtocol(location);
2109 }
2110
2111 wxString GetLeftLocation(const wxString& location) {
2112 return wxFileSystemHandler::GetLeftLocation(location);
2113 }
2114
2115 wxString GetAnchor(const wxString& location) {
2116 return wxFileSystemHandler::GetAnchor(location);
2117 }
2118
2119 wxString GetRightLocation(const wxString& location) {
2120 return wxFileSystemHandler::GetRightLocation(location);
2121 }
2122
2123 wxString GetMimeTypeFromExt(const wxString& location) {
2124 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2125 }
2126
2127 PYPRIVATE;
2128 };
2129
2130
2131 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2132 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2133 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2134 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2135
2136
2137 SWIGINTERN int
2138 SWIG_AsVal_bool(PyObject *obj, bool *val)
2139 {
2140 if (obj == Py_True) {
2141 if (val) *val = true;
2142 return 1;
2143 }
2144 if (obj == Py_False) {
2145 if (val) *val = false;
2146 return 1;
2147 }
2148 int res = 0;
2149 if (SWIG_AsVal_int(obj, &res)) {
2150 if (val) *val = res ? true : false;
2151 return 1;
2152 } else {
2153 PyErr_Clear();
2154 }
2155 if (val) {
2156 SWIG_type_error("bool", obj);
2157 }
2158 return 0;
2159 }
2160
2161
2162 SWIGINTERNSHORT bool
2163 SWIG_As_bool(PyObject* obj)
2164 {
2165 bool v;
2166 if (!SWIG_AsVal_bool(obj, &v)) {
2167 /*
2168 this is needed to make valgrind/purify happier.
2169 */
2170 memset((void*)&v, 0, sizeof(bool));
2171 }
2172 return v;
2173 }
2174
2175
2176 SWIGINTERNSHORT int
2177 SWIG_Check_bool(PyObject* obj)
2178 {
2179 return SWIG_AsVal_bool(obj, (bool*)0);
2180 }
2181
2182 static wxString FileSystem_URLToFileName(wxString const &url){
2183 wxFileName fname = wxFileSystem::URLToFileName(url);
2184 return fname.GetFullPath();
2185 }
2186
2187 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2188 wxImage& image,
2189 long type) {
2190 wxMemoryFSHandler::AddFile(filename, image, type);
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2194 const wxBitmap& bitmap,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2200 PyObject* data) {
2201 if (! PyString_Check(data)) {
2202 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2203 "Expected string object"));
2204 return;
2205 }
2206
2207 bool blocked = wxPyBeginBlockThreads();
2208 void* ptr = (void*)PyString_AsString(data);
2209 size_t size = PyString_Size(data);
2210 wxPyEndBlockThreads(blocked);
2211
2212 wxMemoryFSHandler::AddFile(filename, ptr, size);
2213 }
2214
2215
2216 #include "wx/wxPython/pyistream.h"
2217
2218
2219 SWIGINTERN int
2220 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2221 {
2222 long v = 0;
2223 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2224 SWIG_type_error("unsigned number", obj);
2225 }
2226 else if (val)
2227 *val = (unsigned long)v;
2228 return 1;
2229 }
2230
2231
2232 SWIGINTERNSHORT int
2233 SWIG_CheckUnsignedLongInRange(unsigned long value,
2234 unsigned long max_value,
2235 const char *errmsg)
2236 {
2237 if (value > max_value) {
2238 if (errmsg) {
2239 PyErr_Format(PyExc_OverflowError,
2240 "value %lu is greater than '%s' minimum %lu",
2241 value, errmsg, max_value);
2242 }
2243 return 0;
2244 }
2245 return 1;
2246 }
2247
2248
2249 SWIGINTERN int
2250 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2251 {
2252 const char* errmsg = val ? "unsigned char" : (char*)0;
2253 unsigned long v;
2254 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2255 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2256 if (val) *val = (unsigned char)(v);
2257 return 1;
2258 } else {
2259 return 0;
2260 }
2261 } else {
2262 PyErr_Clear();
2263 }
2264 if (val) {
2265 SWIG_type_error(errmsg, obj);
2266 }
2267 return 0;
2268 }
2269
2270
2271 SWIGINTERNSHORT unsigned char
2272 SWIG_As_unsigned_SS_char(PyObject* obj)
2273 {
2274 unsigned char v;
2275 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2276 /*
2277 this is needed to make valgrind/purify happier.
2278 */
2279 memset((void*)&v, 0, sizeof(unsigned char));
2280 }
2281 return v;
2282 }
2283
2284
2285 SWIGINTERNSHORT int
2286 SWIG_Check_unsigned_SS_char(PyObject* obj)
2287 {
2288 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2289 }
2290
2291
2292 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2293 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2294 /*@@*/
2295
2296
2297 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2298 if (width > 0 && height > 0)
2299 return new wxImage(width, height, clear);
2300 else
2301 return new wxImage;
2302 }
2303 static wxImage *new_wxImage(wxBitmap const &bitmap){
2304 return new wxImage(bitmap.ConvertToImage());
2305 }
2306 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2307 // Copy the source data so the wxImage can clean it up later
2308 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2309 if (copy == NULL) {
2310 PyErr_NoMemory();
2311 return NULL;
2312 }
2313 memcpy(copy, data, width*height*3);
2314 return new wxImage(width, height, copy, false);
2315 }
2316 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2317 // Copy the source data so the wxImage can clean it up later
2318 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2319 if (dcopy == NULL) {
2320 PyErr_NoMemory();
2321 return NULL;
2322 }
2323 memcpy(dcopy, data, width*height*3);
2324 unsigned char* acopy = (unsigned char*)malloc(width*height);
2325 if (acopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(acopy, alpha, width*height);
2330
2331 return new wxImage(width, height, dcopy, acopy, false);
2332 }
2333 static wxSize wxImage_GetSize(wxImage *self){
2334 wxSize size(self->GetWidth(), self->GetHeight());
2335 return size;
2336 }
2337 static PyObject *wxImage_GetData(wxImage *self){
2338 unsigned char* data = self->GetData();
2339 int len = self->GetWidth() * self->GetHeight() * 3;
2340 PyObject* rv;
2341 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2342 return rv;
2343 }
2344 static void wxImage_SetData(wxImage *self,PyObject *data){
2345 unsigned char* dataPtr;
2346
2347 if (! PyString_Check(data)) {
2348 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2349 "Expected string object"));
2350 return /* NULL */ ;
2351 }
2352
2353 size_t len = self->GetWidth() * self->GetHeight() * 3;
2354 dataPtr = (unsigned char*) malloc(len);
2355 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2356 self->SetData(dataPtr);
2357 // wxImage takes ownership of dataPtr...
2358 }
2359 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2360 unsigned char* data = self->GetData();
2361 int len = self->GetWidth() * self->GetHeight() * 3;
2362 PyObject* rv;
2363 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2364 return rv;
2365 }
2366 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2367 unsigned char* buffer;
2368 int size;
2369
2370 bool blocked = wxPyBeginBlockThreads();
2371 if (!PyArg_Parse(data, "t#", &buffer, &size))
2372 goto done;
2373
2374 if (size != self->GetWidth() * self->GetHeight() * 3) {
2375 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2376 goto done;
2377 }
2378 self->SetData(buffer);
2379 done:
2380 wxPyEndBlockThreads(blocked);
2381 }
2382 static PyObject *wxImage_GetAlphaData(wxImage *self){
2383 unsigned char* data = self->GetAlpha();
2384 if (! data) {
2385 RETURN_NONE();
2386 } else {
2387 int len = self->GetWidth() * self->GetHeight();
2388 PyObject* rv;
2389 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2390 return rv;
2391 }
2392 }
2393 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2394 unsigned char* dataPtr;
2395
2396 if (! PyString_Check(data)) {
2397 PyErr_SetString(PyExc_TypeError, "Expected string object");
2398 return /* NULL */ ;
2399 }
2400
2401 size_t len = self->GetWidth() * self->GetHeight();
2402 dataPtr = (unsigned char*) malloc(len);
2403 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2404 self->SetAlpha(dataPtr);
2405 // wxImage takes ownership of dataPtr...
2406 }
2407 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2408 unsigned char* data = self->GetAlpha();
2409 int len = self->GetWidth() * self->GetHeight();
2410 PyObject* rv;
2411 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2412 return rv;
2413 }
2414 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2415 unsigned char* buffer;
2416 int size;
2417
2418 bool blocked = wxPyBeginBlockThreads();
2419 if (!PyArg_Parse(data, "t#", &buffer, &size))
2420 goto done;
2421
2422 if (size != self->GetWidth() * self->GetHeight()) {
2423 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2424 goto done;
2425 }
2426 self->SetAlpha(buffer);
2427 done:
2428 wxPyEndBlockThreads(blocked);
2429 }
2430
2431 SWIGINTERNSHORT unsigned long
2432 SWIG_As_unsigned_SS_long(PyObject* obj)
2433 {
2434 unsigned long v;
2435 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2436 /*
2437 this is needed to make valgrind/purify happier.
2438 */
2439 memset((void*)&v, 0, sizeof(unsigned long));
2440 }
2441 return v;
2442 }
2443
2444
2445 SWIGINTERNSHORT int
2446 SWIG_Check_unsigned_SS_long(PyObject* obj)
2447 {
2448 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2449 }
2450
2451 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2452 wxBitmap bitmap(*self, depth);
2453 return bitmap;
2454 }
2455 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2456 wxImage mono = self->ConvertToMono( red, green, blue );
2457 wxBitmap bitmap( mono, 1 );
2458 return bitmap;
2459 }
2460 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2461 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2462 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2463 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2464 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2465
2466 #include <wx/quantize.h>
2467
2468 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2469 return wxQuantize::Quantize(src, dest,
2470 //NULL, // palette
2471 desiredNoColours,
2472 NULL, // eightBitData
2473 flags);
2474 }
2475 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2476 if (PyCallable_Check(func)) {
2477 self->Connect(id, lastId, eventType,
2478 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2479 new wxPyCallback(func));
2480 }
2481 else if (func == Py_None) {
2482 self->Disconnect(id, lastId, eventType,
2483 (wxObjectEventFunction)
2484 &wxPyCallback::EventThunker);
2485 }
2486 else {
2487 wxPyBLOCK_THREADS(
2488 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2489 }
2490 }
2491 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2492 return self->Disconnect(id, lastId, eventType,
2493 (wxObjectEventFunction)
2494 &wxPyCallback::EventThunker);
2495 }
2496 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2497 if (_self && _self != Py_None) {
2498 self->SetClientObject(new wxPyOORClientData(_self, incref));
2499 }
2500 else {
2501 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2502 if (data) {
2503 self->SetClientObject(NULL); // This will delete it too
2504 }
2505 }
2506 }
2507
2508 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2509 #if wxUSE_UNICODE
2510 return self->GetUnicodeKey();
2511 #else
2512 return 0;
2513 #endif
2514 }
2515
2516 #if UINT_MAX < LONG_MAX
2517 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2518 #define SWIG_From_unsigned_SS_int SWIG_From_long
2519 /*@@*/
2520 #else
2521 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2522 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2523 /*@@*/
2524 #endif
2525
2526
2527 #if UINT_MAX != ULONG_MAX
2528 SWIGINTERN int
2529 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2530 {
2531 const char* errmsg = val ? "unsigned int" : (char*)0;
2532 unsigned long v;
2533 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2534 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2535 if (val) *val = (unsigned int)(v);
2536 return 1;
2537 }
2538 } else {
2539 PyErr_Clear();
2540 }
2541 if (val) {
2542 SWIG_type_error(errmsg, obj);
2543 }
2544 return 0;
2545 }
2546 #else
2547 SWIGINTERNSHORT unsigned int
2548 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2549 {
2550 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2551 }
2552 #endif
2553
2554
2555 SWIGINTERNSHORT unsigned int
2556 SWIG_As_unsigned_SS_int(PyObject* obj)
2557 {
2558 unsigned int v;
2559 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2560 /*
2561 this is needed to make valgrind/purify happier.
2562 */
2563 memset((void*)&v, 0, sizeof(unsigned int));
2564 }
2565 return v;
2566 }
2567
2568
2569 SWIGINTERNSHORT int
2570 SWIG_Check_unsigned_SS_int(PyObject* obj)
2571 {
2572 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2573 }
2574
2575 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2576 self->m_size = size;
2577 }
2578 static void wxMoveEvent_SetPosition(wxMoveEvent *self,wxPoint pos){
2579 self->m_pos = pos;
2580 }
2581 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2582 int count = self->GetNumberOfFiles();
2583 wxString* files = self->GetFiles();
2584 PyObject* list = PyList_New(count);
2585
2586 if (!list) {
2587 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2588 return NULL;
2589 }
2590
2591 for (int i=0; i<count; i++) {
2592 PyList_SetItem(list, i, wx2PyString(files[i]));
2593 }
2594 return list;
2595 }
2596
2597
2598 static wxPyApp *new_wxPyApp(){
2599 wxPythonApp = new wxPyApp();
2600 return wxPythonApp;
2601 }
2602 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2603
2604 void wxApp_CleanUp() {
2605 __wxPyCleanup();
2606 }
2607
2608
2609 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2610
2611
2612 SWIGINTERNSHORT int
2613 SWIG_AsCharPtr(PyObject *obj, char **val)
2614 {
2615 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2616 return 1;
2617 }
2618 if (val) {
2619 PyErr_Clear();
2620 SWIG_type_error("char *", obj);
2621 }
2622 return 0;
2623 }
2624
2625
2626 SWIGINTERN PyObject *
2627 SWIG_FromCharPtr(const char* cptr)
2628 {
2629 if (cptr) {
2630 size_t size = strlen(cptr);
2631 if (size > INT_MAX) {
2632 return SWIG_NewPointerObj((char*)(cptr),
2633 SWIG_TypeQuery("char *"), 0);
2634 } else {
2635 if (size != 0) {
2636 return PyString_FromStringAndSize(cptr, size);
2637 } else {
2638 return PyString_FromString(cptr);
2639 }
2640 }
2641 }
2642 Py_INCREF(Py_None);
2643 return Py_None;
2644 }
2645
2646
2647 #ifdef __WXMAC__
2648
2649 // A dummy class that raises an exception if used...
2650 class wxEventLoop
2651 {
2652 public:
2653 wxEventLoop() { wxPyRaiseNotImplemented(); }
2654 int Run() { return 0; }
2655 void Exit(int rc = 0) {}
2656 bool Pending() const { return false; }
2657 bool Dispatch() { return false; }
2658 bool IsRunning() const { return false; }
2659 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2660 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2661 };
2662
2663 #else
2664
2665 #include <wx/evtloop.h>
2666
2667 #endif
2668
2669
2670
2671 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2672 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2673 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2674 static PyObject *wxWindow_GetChildren(wxWindow *self){
2675 wxWindowList& list = self->GetChildren();
2676 return wxPy_ConvertList(&list);
2677 }
2678 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2679 #if wxUSE_HOTKEY
2680 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2681 #else
2682 return false;
2683 #endif
2684 }
2685 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2686
2687
2688
2689 return false;
2690
2691 }
2692 static long wxWindow_GetHandle(wxWindow *self){
2693 return wxPyGetWinHandle(self);
2694 }
2695 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2696 self->AssociateHandle((WXWidget)handle);
2697 }
2698
2699 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2700 return wxWindow::FindWindowById(id, parent);
2701 }
2702
2703 wxWindow* wxFindWindowByName( const wxString& name,
2704 const wxWindow *parent = NULL ) {
2705 return wxWindow::FindWindowByName(name, parent);
2706 }
2707
2708 wxWindow* wxFindWindowByLabel( const wxString& label,
2709 const wxWindow *parent = NULL ) {
2710 return wxWindow::FindWindowByLabel(label, parent);
2711 }
2712
2713
2714 #ifdef __WXMSW__
2715 #include <wx/msw/private.h> // to get wxGetWindowId
2716 #endif
2717
2718
2719 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2720 #ifdef __WXMSW__
2721 WXHWND hWnd = (WXHWND)_hWnd;
2722 long id = wxGetWindowId(hWnd);
2723 wxWindow* win = new wxWindow;
2724 parent->AddChild(win);
2725 win->SetEventHandler(win);
2726 win->SetHWND(hWnd);
2727 win->SetId(id);
2728 win->SubclassWin(hWnd);
2729 win->AdoptAttributesFromHWND();
2730 win->SetupColours();
2731 return win;
2732 #else
2733 wxPyRaiseNotImplemented();
2734 return NULL;
2735 #endif
2736 }
2737
2738
2739 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2740 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2741 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2742
2743 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2744
2745 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2746 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2747 wxMenuItemList& list = self->GetMenuItems();
2748 return wxPy_ConvertList(&list);
2749 }
2750 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2751 static const wxString wxPyControlNameStr(wxControlNameStr);
2752 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2753 if (clientData) {
2754 wxPyClientData* data = new wxPyClientData(clientData);
2755 return self->Append(item, data);
2756 } else
2757 return self->Append(item);
2758 }
2759 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2760 if (clientData) {
2761 wxPyClientData* data = new wxPyClientData(clientData);
2762 return self->Insert(item, pos, data);
2763 } else
2764 return self->Insert(item, pos);
2765 }
2766 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2767 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2768 if (data) {
2769 Py_INCREF(data->m_obj);
2770 return data->m_obj;
2771 } else {
2772 Py_INCREF(Py_None);
2773 return Py_None;
2774 }
2775 }
2776 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2777 wxPyClientData* data = new wxPyClientData(clientData);
2778 self->SetClientObject(n, data);
2779 }
2780
2781
2782 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2783 wxPyUserData* data = NULL;
2784 if ( userData ) {
2785 bool blocked = wxPyBeginBlockThreads();
2786 data = new wxPyUserData(userData);
2787 wxPyEndBlockThreads(blocked);
2788 }
2789 return new wxSizerItem(window, proportion, flag, border, data);
2790 }
2791 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2792 wxPyUserData* data = NULL;
2793 if ( userData ) {
2794 bool blocked = wxPyBeginBlockThreads();
2795 data = new wxPyUserData(userData);
2796 wxPyEndBlockThreads(blocked);
2797 }
2798 return new wxSizerItem(width, height, proportion, flag, border, data);
2799 }
2800 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2801 wxPyUserData* data = NULL;
2802 if ( userData ) {
2803 bool blocked = wxPyBeginBlockThreads();
2804 data = new wxPyUserData(userData);
2805 wxPyEndBlockThreads(blocked);
2806 }
2807 return new wxSizerItem(sizer, proportion, flag, border, data);
2808 }
2809
2810 #include <float.h>
2811 SWIGINTERN int
2812 SWIG_CheckDoubleInRange(double value, double min_value,
2813 double max_value, const char* errmsg)
2814 {
2815 if (value < min_value) {
2816 if (errmsg) {
2817 PyErr_Format(PyExc_OverflowError,
2818 "value %g is less than %s minimum %g",
2819 value, errmsg, min_value);
2820 }
2821 return 0;
2822 } else if (value > max_value) {
2823 if (errmsg) {
2824 PyErr_Format(PyExc_OverflowError,
2825 "value %g is greater than %s maximum %g",
2826 value, errmsg, max_value);
2827 }
2828 return 0;
2829 }
2830 return 1;
2831 }
2832
2833
2834 SWIGINTERN int
2835 SWIG_AsVal_float(PyObject *obj, float *val)
2836 {
2837 const char* errmsg = val ? "float" : (char*)0;
2838 double v;
2839 if (SWIG_AsVal_double(obj, &v)) {
2840 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2841 if (val) *val = (float)(v);
2842 return 1;
2843 } else {
2844 return 0;
2845 }
2846 } else {
2847 PyErr_Clear();
2848 }
2849 if (val) {
2850 SWIG_type_error(errmsg, obj);
2851 }
2852 return 0;
2853 }
2854
2855
2856 SWIGINTERNSHORT float
2857 SWIG_As_float(PyObject* obj)
2858 {
2859 float v;
2860 if (!SWIG_AsVal_float(obj, &v)) {
2861 /*
2862 this is needed to make valgrind/purify happier.
2863 */
2864 memset((void*)&v, 0, sizeof(float));
2865 }
2866 return v;
2867 }
2868
2869
2870 SWIGINTERNSHORT int
2871 SWIG_Check_float(PyObject* obj)
2872 {
2873 return SWIG_AsVal_float(obj, (float*)0);
2874 }
2875
2876
2877 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2878 #define SWIG_From_float PyFloat_FromDouble
2879 /*@@*/
2880
2881 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2882 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2883 if (data) {
2884 Py_INCREF(data->m_obj);
2885 return data->m_obj;
2886 } else {
2887 Py_INCREF(Py_None);
2888 return Py_None;
2889 }
2890 }
2891
2892 // Figure out the type of the sizer item
2893
2894 struct wxPySizerItemInfo {
2895 wxPySizerItemInfo()
2896 : window(NULL), sizer(NULL), gotSize(false),
2897 size(wxDefaultSize), gotPos(false), pos(-1)
2898 {}
2899
2900 wxWindow* window;
2901 wxSizer* sizer;
2902 bool gotSize;
2903 wxSize size;
2904 bool gotPos;
2905 int pos;
2906 };
2907
2908 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2909
2910 wxPySizerItemInfo info;
2911 wxSize size;
2912 wxSize* sizePtr = &size;
2913
2914 // Find out what the type of the item is
2915 // try wxWindow
2916 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2917 PyErr_Clear();
2918 info.window = NULL;
2919
2920 // try wxSizer
2921 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2922 PyErr_Clear();
2923 info.sizer = NULL;
2924
2925 // try wxSize or (w,h)
2926 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2927 info.size = *sizePtr;
2928 info.gotSize = true;
2929 }
2930
2931 // or a single int
2932 if (checkIdx && PyInt_Check(item)) {
2933 info.pos = PyInt_AsLong(item);
2934 info.gotPos = true;
2935 }
2936 }
2937 }
2938
2939 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2940 // no expected type, figure out what kind of error message to generate
2941 if ( !checkSize && !checkIdx )
2942 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2943 else if ( checkSize && !checkIdx )
2944 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2945 else if ( !checkSize && checkIdx)
2946 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2947 else
2948 // can this one happen?
2949 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2950 }
2951
2952 return info;
2953 }
2954
2955 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2956 if (!self->GetClientObject())
2957 self->SetClientObject(new wxPyOORClientData(_self));
2958 }
2959 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2960
2961 wxPyUserData* data = NULL;
2962 bool blocked = wxPyBeginBlockThreads();
2963 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2964 if ( userData && (info.window || info.sizer || info.gotSize) )
2965 data = new wxPyUserData(userData);
2966 wxPyEndBlockThreads(blocked);
2967
2968 // Now call the real Add method if a valid item type was found
2969 if ( info.window )
2970 return self->Add(info.window, proportion, flag, border, data);
2971 else if ( info.sizer )
2972 return self->Add(info.sizer, proportion, flag, border, data);
2973 else if (info.gotSize)
2974 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2975 proportion, flag, border, data);
2976 else
2977 return NULL;
2978 }
2979 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2980
2981 wxPyUserData* data = NULL;
2982 bool blocked = wxPyBeginBlockThreads();
2983 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2984 if ( userData && (info.window || info.sizer || info.gotSize) )
2985 data = new wxPyUserData(userData);
2986 wxPyEndBlockThreads(blocked);
2987
2988 // Now call the real Insert method if a valid item type was found
2989 if ( info.window )
2990 return self->Insert(before, info.window, proportion, flag, border, data);
2991 else if ( info.sizer )
2992 return self->Insert(before, info.sizer, proportion, flag, border, data);
2993 else if (info.gotSize)
2994 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
2995 proportion, flag, border, data);
2996 else
2997 return NULL;
2998 }
2999 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3000
3001 wxPyUserData* data = NULL;
3002 bool blocked = wxPyBeginBlockThreads();
3003 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3004 if ( userData && (info.window || info.sizer || info.gotSize) )
3005 data = new wxPyUserData(userData);
3006 wxPyEndBlockThreads(blocked);
3007
3008 // Now call the real Prepend method if a valid item type was found
3009 if ( info.window )
3010 return self->Prepend(info.window, proportion, flag, border, data);
3011 else if ( info.sizer )
3012 return self->Prepend(info.sizer, proportion, flag, border, data);
3013 else if (info.gotSize)
3014 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3015 proportion, flag, border, data);
3016 else
3017 return NULL;
3018 }
3019 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3020 bool blocked = wxPyBeginBlockThreads();
3021 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3022 wxPyEndBlockThreads(blocked);
3023 if ( info.window )
3024 return self->Remove(info.window);
3025 else if ( info.sizer )
3026 return self->Remove(info.sizer);
3027 else if ( info.gotPos )
3028 return self->Remove(info.pos);
3029 else
3030 return false;
3031 }
3032 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3033 bool blocked = wxPyBeginBlockThreads();
3034 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3035 wxPyEndBlockThreads(blocked);
3036 if ( info.window )
3037 return self->Detach(info.window);
3038 else if ( info.sizer )
3039 return self->Detach(info.sizer);
3040 else if ( info.gotPos )
3041 return self->Detach(info.pos);
3042 else
3043 return false;
3044 }
3045 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3046 bool blocked = wxPyBeginBlockThreads();
3047 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3048 wxPyEndBlockThreads(blocked);
3049 if ( info.window )
3050 return self->GetItem(info.window);
3051 else if ( info.sizer )
3052 return self->GetItem(info.sizer);
3053 else if ( info.gotPos )
3054 return self->GetItem(info.pos);
3055 else
3056 return NULL;
3057 }
3058 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3059 bool blocked = wxPyBeginBlockThreads();
3060 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3061 wxPyEndBlockThreads(blocked);
3062 if ( info.window )
3063 self->SetItemMinSize(info.window, size);
3064 else if ( info.sizer )
3065 self->SetItemMinSize(info.sizer, size);
3066 else if ( info.gotPos )
3067 self->SetItemMinSize(info.pos, size);
3068 }
3069 static PyObject *wxSizer_GetChildren(wxSizer *self){
3070 wxSizerItemList& list = self->GetChildren();
3071 return wxPy_ConvertList(&list);
3072 }
3073 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3074 bool blocked = wxPyBeginBlockThreads();
3075 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3076 wxPyEndBlockThreads(blocked);
3077 if ( info.window )
3078 return self->Show(info.window, show, recursive);
3079 else if ( info.sizer )
3080 return self->Show(info.sizer, show, recursive);
3081 else if ( info.gotPos )
3082 return self->Show(info.pos, show);
3083 else
3084 return false;
3085 }
3086 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3087 bool blocked = wxPyBeginBlockThreads();
3088 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3089 wxPyEndBlockThreads(blocked);
3090 if ( info.window )
3091 return self->IsShown(info.window);
3092 else if ( info.sizer )
3093 return self->IsShown(info.sizer);
3094 else if ( info.gotPos )
3095 return self->IsShown(info.pos);
3096 else
3097 return false;
3098 }
3099
3100 // See pyclasses.h
3101 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3102 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3103 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3104
3105
3106
3107
3108 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3109 {
3110 if (source == Py_None) {
3111 **obj = wxGBPosition(-1,-1);
3112 return true;
3113 }
3114 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3115 }
3116
3117 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3118 {
3119 if (source == Py_None) {
3120 **obj = wxGBSpan(-1,-1);
3121 return true;
3122 }
3123 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3124 }
3125
3126
3127 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3128 self->SetRow(row);
3129 self->SetCol(col);
3130 }
3131 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3132 bool blocked = wxPyBeginBlockThreads();
3133 PyObject* tup = PyTuple_New(2);
3134 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3135 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3136 wxPyEndBlockThreads(blocked);
3137 return tup;
3138 }
3139 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3140 self->SetRowspan(rowspan);
3141 self->SetColspan(colspan);
3142 }
3143 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3144 bool blocked = wxPyBeginBlockThreads();
3145 PyObject* tup = PyTuple_New(2);
3146 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3147 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3148 wxPyEndBlockThreads(blocked);
3149 return tup;
3150 }
3151 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3152 wxPyUserData* data = NULL;
3153 if ( userData ) {
3154 bool blocked = wxPyBeginBlockThreads();
3155 data = new wxPyUserData(userData);
3156 wxPyEndBlockThreads(blocked);
3157 }
3158 return new wxGBSizerItem(window, pos, span, flag, border, data);
3159 }
3160 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3161 wxPyUserData* data = NULL;
3162 if ( userData ) {
3163 bool blocked = wxPyBeginBlockThreads();
3164 data = new wxPyUserData(userData);
3165 wxPyEndBlockThreads(blocked);
3166 }
3167 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3168 }
3169 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3170 wxPyUserData* data = NULL;
3171 if ( userData ) {
3172 bool blocked = wxPyBeginBlockThreads();
3173 data = new wxPyUserData(userData);
3174 wxPyEndBlockThreads(blocked);
3175 }
3176 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3177 }
3178 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3179 int row, col;
3180 self->GetEndPos(row, col);
3181 return wxGBPosition(row, col);
3182 }
3183 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3184
3185 wxPyUserData* data = NULL;
3186 bool blocked = wxPyBeginBlockThreads();
3187 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3188 if ( userData && (info.window || info.sizer || info.gotSize) )
3189 data = new wxPyUserData(userData);
3190 wxPyEndBlockThreads(blocked);
3191
3192 // Now call the real Add method if a valid item type was found
3193 if ( info.window )
3194 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3195 else if ( info.sizer )
3196 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3197 else if (info.gotSize)
3198 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3199 pos, span, flag, border, data);
3200 return NULL;
3201 }
3202
3203
3204 #ifdef __cplusplus
3205 extern "C" {
3206 #endif
3207 static int _wrap_EmptyString_set(PyObject *) {
3208 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3209 return 1;
3210 }
3211
3212
3213 static PyObject *_wrap_EmptyString_get(void) {
3214 PyObject *pyobj;
3215
3216 {
3217 #if wxUSE_UNICODE
3218 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3219 #else
3220 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3221 #endif
3222 }
3223 return pyobj;
3224 }
3225
3226
3227 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3228 PyObject *resultobj;
3229 wxObject *arg1 = (wxObject *) 0 ;
3230 wxString result;
3231 PyObject * obj0 = 0 ;
3232 char *kwnames[] = {
3233 (char *) "self", NULL
3234 };
3235
3236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3238 if (SWIG_arg_fail(1)) SWIG_fail;
3239 {
3240 PyThreadState* __tstate = wxPyBeginAllowThreads();
3241 result = wxObject_GetClassName(arg1);
3242
3243 wxPyEndAllowThreads(__tstate);
3244 if (PyErr_Occurred()) SWIG_fail;
3245 }
3246 {
3247 #if wxUSE_UNICODE
3248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3249 #else
3250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3251 #endif
3252 }
3253 return resultobj;
3254 fail:
3255 return NULL;
3256 }
3257
3258
3259 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3260 PyObject *resultobj;
3261 wxObject *arg1 = (wxObject *) 0 ;
3262 PyObject * obj0 = 0 ;
3263 char *kwnames[] = {
3264 (char *) "self", NULL
3265 };
3266
3267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3269 if (SWIG_arg_fail(1)) SWIG_fail;
3270 {
3271 PyThreadState* __tstate = wxPyBeginAllowThreads();
3272 wxObject_Destroy(arg1);
3273
3274 wxPyEndAllowThreads(__tstate);
3275 if (PyErr_Occurred()) SWIG_fail;
3276 }
3277 Py_INCREF(Py_None); resultobj = Py_None;
3278 return resultobj;
3279 fail:
3280 return NULL;
3281 }
3282
3283
3284 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3285 PyObject *obj;
3286 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3287 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3288 Py_INCREF(obj);
3289 return Py_BuildValue((char *)"");
3290 }
3291 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3292 PyObject *resultobj;
3293 wxSize *arg1 = (wxSize *) 0 ;
3294 int arg2 ;
3295 PyObject * obj0 = 0 ;
3296 PyObject * obj1 = 0 ;
3297 char *kwnames[] = {
3298 (char *) "self",(char *) "x", NULL
3299 };
3300
3301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3303 if (SWIG_arg_fail(1)) SWIG_fail;
3304 {
3305 arg2 = (int)(SWIG_As_int(obj1));
3306 if (SWIG_arg_fail(2)) SWIG_fail;
3307 }
3308 if (arg1) (arg1)->x = arg2;
3309
3310 Py_INCREF(Py_None); resultobj = Py_None;
3311 return resultobj;
3312 fail:
3313 return NULL;
3314 }
3315
3316
3317 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3318 PyObject *resultobj;
3319 wxSize *arg1 = (wxSize *) 0 ;
3320 int result;
3321 PyObject * obj0 = 0 ;
3322 char *kwnames[] = {
3323 (char *) "self", NULL
3324 };
3325
3326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3328 if (SWIG_arg_fail(1)) SWIG_fail;
3329 result = (int) ((arg1)->x);
3330
3331 {
3332 resultobj = SWIG_From_int((int)(result));
3333 }
3334 return resultobj;
3335 fail:
3336 return NULL;
3337 }
3338
3339
3340 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3341 PyObject *resultobj;
3342 wxSize *arg1 = (wxSize *) 0 ;
3343 int arg2 ;
3344 PyObject * obj0 = 0 ;
3345 PyObject * obj1 = 0 ;
3346 char *kwnames[] = {
3347 (char *) "self",(char *) "y", NULL
3348 };
3349
3350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3352 if (SWIG_arg_fail(1)) SWIG_fail;
3353 {
3354 arg2 = (int)(SWIG_As_int(obj1));
3355 if (SWIG_arg_fail(2)) SWIG_fail;
3356 }
3357 if (arg1) (arg1)->y = arg2;
3358
3359 Py_INCREF(Py_None); resultobj = Py_None;
3360 return resultobj;
3361 fail:
3362 return NULL;
3363 }
3364
3365
3366 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3367 PyObject *resultobj;
3368 wxSize *arg1 = (wxSize *) 0 ;
3369 int result;
3370 PyObject * obj0 = 0 ;
3371 char *kwnames[] = {
3372 (char *) "self", NULL
3373 };
3374
3375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3377 if (SWIG_arg_fail(1)) SWIG_fail;
3378 result = (int) ((arg1)->y);
3379
3380 {
3381 resultobj = SWIG_From_int((int)(result));
3382 }
3383 return resultobj;
3384 fail:
3385 return NULL;
3386 }
3387
3388
3389 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3390 PyObject *resultobj;
3391 int arg1 = (int) 0 ;
3392 int arg2 = (int) 0 ;
3393 wxSize *result;
3394 PyObject * obj0 = 0 ;
3395 PyObject * obj1 = 0 ;
3396 char *kwnames[] = {
3397 (char *) "w",(char *) "h", NULL
3398 };
3399
3400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3401 if (obj0) {
3402 {
3403 arg1 = (int)(SWIG_As_int(obj0));
3404 if (SWIG_arg_fail(1)) SWIG_fail;
3405 }
3406 }
3407 if (obj1) {
3408 {
3409 arg2 = (int)(SWIG_As_int(obj1));
3410 if (SWIG_arg_fail(2)) SWIG_fail;
3411 }
3412 }
3413 {
3414 PyThreadState* __tstate = wxPyBeginAllowThreads();
3415 result = (wxSize *)new wxSize(arg1,arg2);
3416
3417 wxPyEndAllowThreads(__tstate);
3418 if (PyErr_Occurred()) SWIG_fail;
3419 }
3420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3421 return resultobj;
3422 fail:
3423 return NULL;
3424 }
3425
3426
3427 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3428 PyObject *resultobj;
3429 wxSize *arg1 = (wxSize *) 0 ;
3430 PyObject * obj0 = 0 ;
3431 char *kwnames[] = {
3432 (char *) "self", NULL
3433 };
3434
3435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3437 if (SWIG_arg_fail(1)) SWIG_fail;
3438 {
3439 PyThreadState* __tstate = wxPyBeginAllowThreads();
3440 delete arg1;
3441
3442 wxPyEndAllowThreads(__tstate);
3443 if (PyErr_Occurred()) SWIG_fail;
3444 }
3445 Py_INCREF(Py_None); resultobj = Py_None;
3446 return resultobj;
3447 fail:
3448 return NULL;
3449 }
3450
3451
3452 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3453 PyObject *resultobj;
3454 wxSize *arg1 = (wxSize *) 0 ;
3455 wxSize *arg2 = 0 ;
3456 bool result;
3457 wxSize temp2 ;
3458 PyObject * obj0 = 0 ;
3459 PyObject * obj1 = 0 ;
3460 char *kwnames[] = {
3461 (char *) "self",(char *) "sz", NULL
3462 };
3463
3464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3466 if (SWIG_arg_fail(1)) SWIG_fail;
3467 {
3468 arg2 = &temp2;
3469 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3470 }
3471 {
3472 PyThreadState* __tstate = wxPyBeginAllowThreads();
3473 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3474
3475 wxPyEndAllowThreads(__tstate);
3476 if (PyErr_Occurred()) SWIG_fail;
3477 }
3478 {
3479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3480 }
3481 return resultobj;
3482 fail:
3483 return NULL;
3484 }
3485
3486
3487 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3488 PyObject *resultobj;
3489 wxSize *arg1 = (wxSize *) 0 ;
3490 wxSize *arg2 = 0 ;
3491 bool result;
3492 wxSize temp2 ;
3493 PyObject * obj0 = 0 ;
3494 PyObject * obj1 = 0 ;
3495 char *kwnames[] = {
3496 (char *) "self",(char *) "sz", NULL
3497 };
3498
3499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3501 if (SWIG_arg_fail(1)) SWIG_fail;
3502 {
3503 arg2 = &temp2;
3504 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3505 }
3506 {
3507 PyThreadState* __tstate = wxPyBeginAllowThreads();
3508 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3509
3510 wxPyEndAllowThreads(__tstate);
3511 if (PyErr_Occurred()) SWIG_fail;
3512 }
3513 {
3514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3515 }
3516 return resultobj;
3517 fail:
3518 return NULL;
3519 }
3520
3521
3522 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3523 PyObject *resultobj;
3524 wxSize *arg1 = (wxSize *) 0 ;
3525 wxSize *arg2 = 0 ;
3526 wxSize result;
3527 wxSize temp2 ;
3528 PyObject * obj0 = 0 ;
3529 PyObject * obj1 = 0 ;
3530 char *kwnames[] = {
3531 (char *) "self",(char *) "sz", NULL
3532 };
3533
3534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3536 if (SWIG_arg_fail(1)) SWIG_fail;
3537 {
3538 arg2 = &temp2;
3539 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3540 }
3541 {
3542 PyThreadState* __tstate = wxPyBeginAllowThreads();
3543 result = (arg1)->operator +((wxSize const &)*arg2);
3544
3545 wxPyEndAllowThreads(__tstate);
3546 if (PyErr_Occurred()) SWIG_fail;
3547 }
3548 {
3549 wxSize * resultptr;
3550 resultptr = new wxSize((wxSize &)(result));
3551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3552 }
3553 return resultobj;
3554 fail:
3555 return NULL;
3556 }
3557
3558
3559 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3560 PyObject *resultobj;
3561 wxSize *arg1 = (wxSize *) 0 ;
3562 wxSize *arg2 = 0 ;
3563 wxSize result;
3564 wxSize temp2 ;
3565 PyObject * obj0 = 0 ;
3566 PyObject * obj1 = 0 ;
3567 char *kwnames[] = {
3568 (char *) "self",(char *) "sz", NULL
3569 };
3570
3571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3573 if (SWIG_arg_fail(1)) SWIG_fail;
3574 {
3575 arg2 = &temp2;
3576 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3577 }
3578 {
3579 PyThreadState* __tstate = wxPyBeginAllowThreads();
3580 result = (arg1)->operator -((wxSize const &)*arg2);
3581
3582 wxPyEndAllowThreads(__tstate);
3583 if (PyErr_Occurred()) SWIG_fail;
3584 }
3585 {
3586 wxSize * resultptr;
3587 resultptr = new wxSize((wxSize &)(result));
3588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3589 }
3590 return resultobj;
3591 fail:
3592 return NULL;
3593 }
3594
3595
3596 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3597 PyObject *resultobj;
3598 wxSize *arg1 = (wxSize *) 0 ;
3599 wxSize *arg2 = 0 ;
3600 wxSize temp2 ;
3601 PyObject * obj0 = 0 ;
3602 PyObject * obj1 = 0 ;
3603 char *kwnames[] = {
3604 (char *) "self",(char *) "sz", NULL
3605 };
3606
3607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3609 if (SWIG_arg_fail(1)) SWIG_fail;
3610 {
3611 arg2 = &temp2;
3612 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3613 }
3614 {
3615 PyThreadState* __tstate = wxPyBeginAllowThreads();
3616 (arg1)->IncTo((wxSize const &)*arg2);
3617
3618 wxPyEndAllowThreads(__tstate);
3619 if (PyErr_Occurred()) SWIG_fail;
3620 }
3621 Py_INCREF(Py_None); resultobj = Py_None;
3622 return resultobj;
3623 fail:
3624 return NULL;
3625 }
3626
3627
3628 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3629 PyObject *resultobj;
3630 wxSize *arg1 = (wxSize *) 0 ;
3631 wxSize *arg2 = 0 ;
3632 wxSize temp2 ;
3633 PyObject * obj0 = 0 ;
3634 PyObject * obj1 = 0 ;
3635 char *kwnames[] = {
3636 (char *) "self",(char *) "sz", NULL
3637 };
3638
3639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3641 if (SWIG_arg_fail(1)) SWIG_fail;
3642 {
3643 arg2 = &temp2;
3644 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3645 }
3646 {
3647 PyThreadState* __tstate = wxPyBeginAllowThreads();
3648 (arg1)->DecTo((wxSize const &)*arg2);
3649
3650 wxPyEndAllowThreads(__tstate);
3651 if (PyErr_Occurred()) SWIG_fail;
3652 }
3653 Py_INCREF(Py_None); resultobj = Py_None;
3654 return resultobj;
3655 fail:
3656 return NULL;
3657 }
3658
3659
3660 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3661 PyObject *resultobj;
3662 wxSize *arg1 = (wxSize *) 0 ;
3663 int arg2 ;
3664 int arg3 ;
3665 PyObject * obj0 = 0 ;
3666 PyObject * obj1 = 0 ;
3667 PyObject * obj2 = 0 ;
3668 char *kwnames[] = {
3669 (char *) "self",(char *) "w",(char *) "h", NULL
3670 };
3671
3672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3674 if (SWIG_arg_fail(1)) SWIG_fail;
3675 {
3676 arg2 = (int)(SWIG_As_int(obj1));
3677 if (SWIG_arg_fail(2)) SWIG_fail;
3678 }
3679 {
3680 arg3 = (int)(SWIG_As_int(obj2));
3681 if (SWIG_arg_fail(3)) SWIG_fail;
3682 }
3683 {
3684 PyThreadState* __tstate = wxPyBeginAllowThreads();
3685 (arg1)->Set(arg2,arg3);
3686
3687 wxPyEndAllowThreads(__tstate);
3688 if (PyErr_Occurred()) SWIG_fail;
3689 }
3690 Py_INCREF(Py_None); resultobj = Py_None;
3691 return resultobj;
3692 fail:
3693 return NULL;
3694 }
3695
3696
3697 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3698 PyObject *resultobj;
3699 wxSize *arg1 = (wxSize *) 0 ;
3700 int arg2 ;
3701 PyObject * obj0 = 0 ;
3702 PyObject * obj1 = 0 ;
3703 char *kwnames[] = {
3704 (char *) "self",(char *) "w", NULL
3705 };
3706
3707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3709 if (SWIG_arg_fail(1)) SWIG_fail;
3710 {
3711 arg2 = (int)(SWIG_As_int(obj1));
3712 if (SWIG_arg_fail(2)) SWIG_fail;
3713 }
3714 {
3715 PyThreadState* __tstate = wxPyBeginAllowThreads();
3716 (arg1)->SetWidth(arg2);
3717
3718 wxPyEndAllowThreads(__tstate);
3719 if (PyErr_Occurred()) SWIG_fail;
3720 }
3721 Py_INCREF(Py_None); resultobj = Py_None;
3722 return resultobj;
3723 fail:
3724 return NULL;
3725 }
3726
3727
3728 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3729 PyObject *resultobj;
3730 wxSize *arg1 = (wxSize *) 0 ;
3731 int arg2 ;
3732 PyObject * obj0 = 0 ;
3733 PyObject * obj1 = 0 ;
3734 char *kwnames[] = {
3735 (char *) "self",(char *) "h", NULL
3736 };
3737
3738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3740 if (SWIG_arg_fail(1)) SWIG_fail;
3741 {
3742 arg2 = (int)(SWIG_As_int(obj1));
3743 if (SWIG_arg_fail(2)) SWIG_fail;
3744 }
3745 {
3746 PyThreadState* __tstate = wxPyBeginAllowThreads();
3747 (arg1)->SetHeight(arg2);
3748
3749 wxPyEndAllowThreads(__tstate);
3750 if (PyErr_Occurred()) SWIG_fail;
3751 }
3752 Py_INCREF(Py_None); resultobj = Py_None;
3753 return resultobj;
3754 fail:
3755 return NULL;
3756 }
3757
3758
3759 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3760 PyObject *resultobj;
3761 wxSize *arg1 = (wxSize *) 0 ;
3762 int result;
3763 PyObject * obj0 = 0 ;
3764 char *kwnames[] = {
3765 (char *) "self", NULL
3766 };
3767
3768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3770 if (SWIG_arg_fail(1)) SWIG_fail;
3771 {
3772 PyThreadState* __tstate = wxPyBeginAllowThreads();
3773 result = (int)((wxSize const *)arg1)->GetWidth();
3774
3775 wxPyEndAllowThreads(__tstate);
3776 if (PyErr_Occurred()) SWIG_fail;
3777 }
3778 {
3779 resultobj = SWIG_From_int((int)(result));
3780 }
3781 return resultobj;
3782 fail:
3783 return NULL;
3784 }
3785
3786
3787 static PyObject *_wrap_Size_GetHeight(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_GetHeight",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)->GetHeight();
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_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3816 PyObject *resultobj;
3817 wxSize *arg1 = (wxSize *) 0 ;
3818 bool result;
3819 PyObject * obj0 = 0 ;
3820 char *kwnames[] = {
3821 (char *) "self", NULL
3822 };
3823
3824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",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 = (bool)((wxSize const *)arg1)->IsFullySpecified();
3830
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 {
3835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3836 }
3837 return resultobj;
3838 fail:
3839 return NULL;
3840 }
3841
3842
3843 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3844 PyObject *resultobj;
3845 wxSize *arg1 = (wxSize *) 0 ;
3846 wxSize *arg2 = 0 ;
3847 wxSize temp2 ;
3848 PyObject * obj0 = 0 ;
3849 PyObject * obj1 = 0 ;
3850 char *kwnames[] = {
3851 (char *) "self",(char *) "size", NULL
3852 };
3853
3854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3856 if (SWIG_arg_fail(1)) SWIG_fail;
3857 {
3858 arg2 = &temp2;
3859 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3860 }
3861 {
3862 PyThreadState* __tstate = wxPyBeginAllowThreads();
3863 (arg1)->SetDefaults((wxSize const &)*arg2);
3864
3865 wxPyEndAllowThreads(__tstate);
3866 if (PyErr_Occurred()) SWIG_fail;
3867 }
3868 Py_INCREF(Py_None); resultobj = Py_None;
3869 return resultobj;
3870 fail:
3871 return NULL;
3872 }
3873
3874
3875 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3876 PyObject *resultobj;
3877 wxSize *arg1 = (wxSize *) 0 ;
3878 PyObject *result;
3879 PyObject * obj0 = 0 ;
3880 char *kwnames[] = {
3881 (char *) "self", NULL
3882 };
3883
3884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3886 if (SWIG_arg_fail(1)) SWIG_fail;
3887 {
3888 PyThreadState* __tstate = wxPyBeginAllowThreads();
3889 result = (PyObject *)wxSize_Get(arg1);
3890
3891 wxPyEndAllowThreads(__tstate);
3892 if (PyErr_Occurred()) SWIG_fail;
3893 }
3894 resultobj = result;
3895 return resultobj;
3896 fail:
3897 return NULL;
3898 }
3899
3900
3901 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3902 PyObject *obj;
3903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3904 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3905 Py_INCREF(obj);
3906 return Py_BuildValue((char *)"");
3907 }
3908 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3909 PyObject *resultobj;
3910 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3911 double arg2 ;
3912 PyObject * obj0 = 0 ;
3913 PyObject * obj1 = 0 ;
3914 char *kwnames[] = {
3915 (char *) "self",(char *) "x", NULL
3916 };
3917
3918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3920 if (SWIG_arg_fail(1)) SWIG_fail;
3921 {
3922 arg2 = (double)(SWIG_As_double(obj1));
3923 if (SWIG_arg_fail(2)) SWIG_fail;
3924 }
3925 if (arg1) (arg1)->x = arg2;
3926
3927 Py_INCREF(Py_None); resultobj = Py_None;
3928 return resultobj;
3929 fail:
3930 return NULL;
3931 }
3932
3933
3934 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3935 PyObject *resultobj;
3936 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3937 double result;
3938 PyObject * obj0 = 0 ;
3939 char *kwnames[] = {
3940 (char *) "self", NULL
3941 };
3942
3943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3945 if (SWIG_arg_fail(1)) SWIG_fail;
3946 result = (double) ((arg1)->x);
3947
3948 {
3949 resultobj = SWIG_From_double((double)(result));
3950 }
3951 return resultobj;
3952 fail:
3953 return NULL;
3954 }
3955
3956
3957 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3958 PyObject *resultobj;
3959 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3960 double arg2 ;
3961 PyObject * obj0 = 0 ;
3962 PyObject * obj1 = 0 ;
3963 char *kwnames[] = {
3964 (char *) "self",(char *) "y", NULL
3965 };
3966
3967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3969 if (SWIG_arg_fail(1)) SWIG_fail;
3970 {
3971 arg2 = (double)(SWIG_As_double(obj1));
3972 if (SWIG_arg_fail(2)) SWIG_fail;
3973 }
3974 if (arg1) (arg1)->y = arg2;
3975
3976 Py_INCREF(Py_None); resultobj = Py_None;
3977 return resultobj;
3978 fail:
3979 return NULL;
3980 }
3981
3982
3983 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3984 PyObject *resultobj;
3985 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3986 double result;
3987 PyObject * obj0 = 0 ;
3988 char *kwnames[] = {
3989 (char *) "self", NULL
3990 };
3991
3992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
3993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3994 if (SWIG_arg_fail(1)) SWIG_fail;
3995 result = (double) ((arg1)->y);
3996
3997 {
3998 resultobj = SWIG_From_double((double)(result));
3999 }
4000 return resultobj;
4001 fail:
4002 return NULL;
4003 }
4004
4005
4006 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4007 PyObject *resultobj;
4008 double arg1 = (double) 0.0 ;
4009 double arg2 = (double) 0.0 ;
4010 wxRealPoint *result;
4011 PyObject * obj0 = 0 ;
4012 PyObject * obj1 = 0 ;
4013 char *kwnames[] = {
4014 (char *) "x",(char *) "y", NULL
4015 };
4016
4017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4018 if (obj0) {
4019 {
4020 arg1 = (double)(SWIG_As_double(obj0));
4021 if (SWIG_arg_fail(1)) SWIG_fail;
4022 }
4023 }
4024 if (obj1) {
4025 {
4026 arg2 = (double)(SWIG_As_double(obj1));
4027 if (SWIG_arg_fail(2)) SWIG_fail;
4028 }
4029 }
4030 {
4031 PyThreadState* __tstate = wxPyBeginAllowThreads();
4032 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4033
4034 wxPyEndAllowThreads(__tstate);
4035 if (PyErr_Occurred()) SWIG_fail;
4036 }
4037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4038 return resultobj;
4039 fail:
4040 return NULL;
4041 }
4042
4043
4044 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4045 PyObject *resultobj;
4046 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4047 PyObject * obj0 = 0 ;
4048 char *kwnames[] = {
4049 (char *) "self", NULL
4050 };
4051
4052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4054 if (SWIG_arg_fail(1)) SWIG_fail;
4055 {
4056 PyThreadState* __tstate = wxPyBeginAllowThreads();
4057 delete arg1;
4058
4059 wxPyEndAllowThreads(__tstate);
4060 if (PyErr_Occurred()) SWIG_fail;
4061 }
4062 Py_INCREF(Py_None); resultobj = Py_None;
4063 return resultobj;
4064 fail:
4065 return NULL;
4066 }
4067
4068
4069 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4070 PyObject *resultobj;
4071 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4072 wxRealPoint *arg2 = 0 ;
4073 bool result;
4074 wxRealPoint temp2 ;
4075 PyObject * obj0 = 0 ;
4076 PyObject * obj1 = 0 ;
4077 char *kwnames[] = {
4078 (char *) "self",(char *) "pt", NULL
4079 };
4080
4081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4083 if (SWIG_arg_fail(1)) SWIG_fail;
4084 {
4085 arg2 = &temp2;
4086 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4087 }
4088 {
4089 PyThreadState* __tstate = wxPyBeginAllowThreads();
4090 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4091
4092 wxPyEndAllowThreads(__tstate);
4093 if (PyErr_Occurred()) SWIG_fail;
4094 }
4095 {
4096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4097 }
4098 return resultobj;
4099 fail:
4100 return NULL;
4101 }
4102
4103
4104 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4105 PyObject *resultobj;
4106 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4107 wxRealPoint *arg2 = 0 ;
4108 bool result;
4109 wxRealPoint temp2 ;
4110 PyObject * obj0 = 0 ;
4111 PyObject * obj1 = 0 ;
4112 char *kwnames[] = {
4113 (char *) "self",(char *) "pt", NULL
4114 };
4115
4116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4118 if (SWIG_arg_fail(1)) SWIG_fail;
4119 {
4120 arg2 = &temp2;
4121 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4122 }
4123 {
4124 PyThreadState* __tstate = wxPyBeginAllowThreads();
4125 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4126
4127 wxPyEndAllowThreads(__tstate);
4128 if (PyErr_Occurred()) SWIG_fail;
4129 }
4130 {
4131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4132 }
4133 return resultobj;
4134 fail:
4135 return NULL;
4136 }
4137
4138
4139 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4140 PyObject *resultobj;
4141 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4142 wxRealPoint *arg2 = 0 ;
4143 wxRealPoint result;
4144 wxRealPoint temp2 ;
4145 PyObject * obj0 = 0 ;
4146 PyObject * obj1 = 0 ;
4147 char *kwnames[] = {
4148 (char *) "self",(char *) "pt", NULL
4149 };
4150
4151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4153 if (SWIG_arg_fail(1)) SWIG_fail;
4154 {
4155 arg2 = &temp2;
4156 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4157 }
4158 {
4159 PyThreadState* __tstate = wxPyBeginAllowThreads();
4160 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4161
4162 wxPyEndAllowThreads(__tstate);
4163 if (PyErr_Occurred()) SWIG_fail;
4164 }
4165 {
4166 wxRealPoint * resultptr;
4167 resultptr = new wxRealPoint((wxRealPoint &)(result));
4168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4169 }
4170 return resultobj;
4171 fail:
4172 return NULL;
4173 }
4174
4175
4176 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4177 PyObject *resultobj;
4178 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4179 wxRealPoint *arg2 = 0 ;
4180 wxRealPoint result;
4181 wxRealPoint temp2 ;
4182 PyObject * obj0 = 0 ;
4183 PyObject * obj1 = 0 ;
4184 char *kwnames[] = {
4185 (char *) "self",(char *) "pt", NULL
4186 };
4187
4188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4190 if (SWIG_arg_fail(1)) SWIG_fail;
4191 {
4192 arg2 = &temp2;
4193 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4194 }
4195 {
4196 PyThreadState* __tstate = wxPyBeginAllowThreads();
4197 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4198
4199 wxPyEndAllowThreads(__tstate);
4200 if (PyErr_Occurred()) SWIG_fail;
4201 }
4202 {
4203 wxRealPoint * resultptr;
4204 resultptr = new wxRealPoint((wxRealPoint &)(result));
4205 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4206 }
4207 return resultobj;
4208 fail:
4209 return NULL;
4210 }
4211
4212
4213 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4214 PyObject *resultobj;
4215 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4216 double arg2 ;
4217 double arg3 ;
4218 PyObject * obj0 = 0 ;
4219 PyObject * obj1 = 0 ;
4220 PyObject * obj2 = 0 ;
4221 char *kwnames[] = {
4222 (char *) "self",(char *) "x",(char *) "y", NULL
4223 };
4224
4225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4227 if (SWIG_arg_fail(1)) SWIG_fail;
4228 {
4229 arg2 = (double)(SWIG_As_double(obj1));
4230 if (SWIG_arg_fail(2)) SWIG_fail;
4231 }
4232 {
4233 arg3 = (double)(SWIG_As_double(obj2));
4234 if (SWIG_arg_fail(3)) SWIG_fail;
4235 }
4236 {
4237 PyThreadState* __tstate = wxPyBeginAllowThreads();
4238 wxRealPoint_Set(arg1,arg2,arg3);
4239
4240 wxPyEndAllowThreads(__tstate);
4241 if (PyErr_Occurred()) SWIG_fail;
4242 }
4243 Py_INCREF(Py_None); resultobj = Py_None;
4244 return resultobj;
4245 fail:
4246 return NULL;
4247 }
4248
4249
4250 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4251 PyObject *resultobj;
4252 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4253 PyObject *result;
4254 PyObject * obj0 = 0 ;
4255 char *kwnames[] = {
4256 (char *) "self", NULL
4257 };
4258
4259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4261 if (SWIG_arg_fail(1)) SWIG_fail;
4262 {
4263 PyThreadState* __tstate = wxPyBeginAllowThreads();
4264 result = (PyObject *)wxRealPoint_Get(arg1);
4265
4266 wxPyEndAllowThreads(__tstate);
4267 if (PyErr_Occurred()) SWIG_fail;
4268 }
4269 resultobj = result;
4270 return resultobj;
4271 fail:
4272 return NULL;
4273 }
4274
4275
4276 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4277 PyObject *obj;
4278 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4279 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4280 Py_INCREF(obj);
4281 return Py_BuildValue((char *)"");
4282 }
4283 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4284 PyObject *resultobj;
4285 wxPoint *arg1 = (wxPoint *) 0 ;
4286 int arg2 ;
4287 PyObject * obj0 = 0 ;
4288 PyObject * obj1 = 0 ;
4289 char *kwnames[] = {
4290 (char *) "self",(char *) "x", NULL
4291 };
4292
4293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4295 if (SWIG_arg_fail(1)) SWIG_fail;
4296 {
4297 arg2 = (int)(SWIG_As_int(obj1));
4298 if (SWIG_arg_fail(2)) SWIG_fail;
4299 }
4300 if (arg1) (arg1)->x = arg2;
4301
4302 Py_INCREF(Py_None); resultobj = Py_None;
4303 return resultobj;
4304 fail:
4305 return NULL;
4306 }
4307
4308
4309 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4310 PyObject *resultobj;
4311 wxPoint *arg1 = (wxPoint *) 0 ;
4312 int result;
4313 PyObject * obj0 = 0 ;
4314 char *kwnames[] = {
4315 (char *) "self", NULL
4316 };
4317
4318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4320 if (SWIG_arg_fail(1)) SWIG_fail;
4321 result = (int) ((arg1)->x);
4322
4323 {
4324 resultobj = SWIG_From_int((int)(result));
4325 }
4326 return resultobj;
4327 fail:
4328 return NULL;
4329 }
4330
4331
4332 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4333 PyObject *resultobj;
4334 wxPoint *arg1 = (wxPoint *) 0 ;
4335 int arg2 ;
4336 PyObject * obj0 = 0 ;
4337 PyObject * obj1 = 0 ;
4338 char *kwnames[] = {
4339 (char *) "self",(char *) "y", NULL
4340 };
4341
4342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4344 if (SWIG_arg_fail(1)) SWIG_fail;
4345 {
4346 arg2 = (int)(SWIG_As_int(obj1));
4347 if (SWIG_arg_fail(2)) SWIG_fail;
4348 }
4349 if (arg1) (arg1)->y = arg2;
4350
4351 Py_INCREF(Py_None); resultobj = Py_None;
4352 return resultobj;
4353 fail:
4354 return NULL;
4355 }
4356
4357
4358 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4359 PyObject *resultobj;
4360 wxPoint *arg1 = (wxPoint *) 0 ;
4361 int result;
4362 PyObject * obj0 = 0 ;
4363 char *kwnames[] = {
4364 (char *) "self", NULL
4365 };
4366
4367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4369 if (SWIG_arg_fail(1)) SWIG_fail;
4370 result = (int) ((arg1)->y);
4371
4372 {
4373 resultobj = SWIG_From_int((int)(result));
4374 }
4375 return resultobj;
4376 fail:
4377 return NULL;
4378 }
4379
4380
4381 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4382 PyObject *resultobj;
4383 int arg1 = (int) 0 ;
4384 int arg2 = (int) 0 ;
4385 wxPoint *result;
4386 PyObject * obj0 = 0 ;
4387 PyObject * obj1 = 0 ;
4388 char *kwnames[] = {
4389 (char *) "x",(char *) "y", NULL
4390 };
4391
4392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4393 if (obj0) {
4394 {
4395 arg1 = (int)(SWIG_As_int(obj0));
4396 if (SWIG_arg_fail(1)) SWIG_fail;
4397 }
4398 }
4399 if (obj1) {
4400 {
4401 arg2 = (int)(SWIG_As_int(obj1));
4402 if (SWIG_arg_fail(2)) SWIG_fail;
4403 }
4404 }
4405 {
4406 PyThreadState* __tstate = wxPyBeginAllowThreads();
4407 result = (wxPoint *)new wxPoint(arg1,arg2);
4408
4409 wxPyEndAllowThreads(__tstate);
4410 if (PyErr_Occurred()) SWIG_fail;
4411 }
4412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4413 return resultobj;
4414 fail:
4415 return NULL;
4416 }
4417
4418
4419 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4420 PyObject *resultobj;
4421 wxPoint *arg1 = (wxPoint *) 0 ;
4422 PyObject * obj0 = 0 ;
4423 char *kwnames[] = {
4424 (char *) "self", NULL
4425 };
4426
4427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4429 if (SWIG_arg_fail(1)) SWIG_fail;
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 delete arg1;
4433
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 Py_INCREF(Py_None); resultobj = Py_None;
4438 return resultobj;
4439 fail:
4440 return NULL;
4441 }
4442
4443
4444 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4445 PyObject *resultobj;
4446 wxPoint *arg1 = (wxPoint *) 0 ;
4447 wxPoint *arg2 = 0 ;
4448 bool result;
4449 wxPoint temp2 ;
4450 PyObject * obj0 = 0 ;
4451 PyObject * obj1 = 0 ;
4452 char *kwnames[] = {
4453 (char *) "self",(char *) "pt", NULL
4454 };
4455
4456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4458 if (SWIG_arg_fail(1)) SWIG_fail;
4459 {
4460 arg2 = &temp2;
4461 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4462 }
4463 {
4464 PyThreadState* __tstate = wxPyBeginAllowThreads();
4465 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4466
4467 wxPyEndAllowThreads(__tstate);
4468 if (PyErr_Occurred()) SWIG_fail;
4469 }
4470 {
4471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4472 }
4473 return resultobj;
4474 fail:
4475 return NULL;
4476 }
4477
4478
4479 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4480 PyObject *resultobj;
4481 wxPoint *arg1 = (wxPoint *) 0 ;
4482 wxPoint *arg2 = 0 ;
4483 bool result;
4484 wxPoint temp2 ;
4485 PyObject * obj0 = 0 ;
4486 PyObject * obj1 = 0 ;
4487 char *kwnames[] = {
4488 (char *) "self",(char *) "pt", NULL
4489 };
4490
4491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4493 if (SWIG_arg_fail(1)) SWIG_fail;
4494 {
4495 arg2 = &temp2;
4496 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4497 }
4498 {
4499 PyThreadState* __tstate = wxPyBeginAllowThreads();
4500 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4501
4502 wxPyEndAllowThreads(__tstate);
4503 if (PyErr_Occurred()) SWIG_fail;
4504 }
4505 {
4506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4507 }
4508 return resultobj;
4509 fail:
4510 return NULL;
4511 }
4512
4513
4514 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4515 PyObject *resultobj;
4516 wxPoint *arg1 = (wxPoint *) 0 ;
4517 wxPoint *arg2 = 0 ;
4518 wxPoint result;
4519 wxPoint temp2 ;
4520 PyObject * obj0 = 0 ;
4521 PyObject * obj1 = 0 ;
4522 char *kwnames[] = {
4523 (char *) "self",(char *) "pt", NULL
4524 };
4525
4526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4528 if (SWIG_arg_fail(1)) SWIG_fail;
4529 {
4530 arg2 = &temp2;
4531 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4532 }
4533 {
4534 PyThreadState* __tstate = wxPyBeginAllowThreads();
4535 result = (arg1)->operator +((wxPoint const &)*arg2);
4536
4537 wxPyEndAllowThreads(__tstate);
4538 if (PyErr_Occurred()) SWIG_fail;
4539 }
4540 {
4541 wxPoint * resultptr;
4542 resultptr = new wxPoint((wxPoint &)(result));
4543 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4544 }
4545 return resultobj;
4546 fail:
4547 return NULL;
4548 }
4549
4550
4551 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4552 PyObject *resultobj;
4553 wxPoint *arg1 = (wxPoint *) 0 ;
4554 wxPoint *arg2 = 0 ;
4555 wxPoint result;
4556 wxPoint temp2 ;
4557 PyObject * obj0 = 0 ;
4558 PyObject * obj1 = 0 ;
4559 char *kwnames[] = {
4560 (char *) "self",(char *) "pt", NULL
4561 };
4562
4563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4565 if (SWIG_arg_fail(1)) SWIG_fail;
4566 {
4567 arg2 = &temp2;
4568 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4569 }
4570 {
4571 PyThreadState* __tstate = wxPyBeginAllowThreads();
4572 result = (arg1)->operator -((wxPoint const &)*arg2);
4573
4574 wxPyEndAllowThreads(__tstate);
4575 if (PyErr_Occurred()) SWIG_fail;
4576 }
4577 {
4578 wxPoint * resultptr;
4579 resultptr = new wxPoint((wxPoint &)(result));
4580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4581 }
4582 return resultobj;
4583 fail:
4584 return NULL;
4585 }
4586
4587
4588 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4589 PyObject *resultobj;
4590 wxPoint *arg1 = (wxPoint *) 0 ;
4591 wxPoint *arg2 = 0 ;
4592 wxPoint *result;
4593 wxPoint temp2 ;
4594 PyObject * obj0 = 0 ;
4595 PyObject * obj1 = 0 ;
4596 char *kwnames[] = {
4597 (char *) "self",(char *) "pt", NULL
4598 };
4599
4600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4602 if (SWIG_arg_fail(1)) SWIG_fail;
4603 {
4604 arg2 = &temp2;
4605 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4606 }
4607 {
4608 PyThreadState* __tstate = wxPyBeginAllowThreads();
4609 {
4610 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4611 result = (wxPoint *) &_result_ref;
4612 }
4613
4614 wxPyEndAllowThreads(__tstate);
4615 if (PyErr_Occurred()) SWIG_fail;
4616 }
4617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4618 return resultobj;
4619 fail:
4620 return NULL;
4621 }
4622
4623
4624 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4625 PyObject *resultobj;
4626 wxPoint *arg1 = (wxPoint *) 0 ;
4627 wxPoint *arg2 = 0 ;
4628 wxPoint *result;
4629 wxPoint temp2 ;
4630 PyObject * obj0 = 0 ;
4631 PyObject * obj1 = 0 ;
4632 char *kwnames[] = {
4633 (char *) "self",(char *) "pt", NULL
4634 };
4635
4636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4638 if (SWIG_arg_fail(1)) SWIG_fail;
4639 {
4640 arg2 = &temp2;
4641 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4642 }
4643 {
4644 PyThreadState* __tstate = wxPyBeginAllowThreads();
4645 {
4646 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4647 result = (wxPoint *) &_result_ref;
4648 }
4649
4650 wxPyEndAllowThreads(__tstate);
4651 if (PyErr_Occurred()) SWIG_fail;
4652 }
4653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4654 return resultobj;
4655 fail:
4656 return NULL;
4657 }
4658
4659
4660 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj;
4662 wxPoint *arg1 = (wxPoint *) 0 ;
4663 long arg2 ;
4664 long arg3 ;
4665 PyObject * obj0 = 0 ;
4666 PyObject * obj1 = 0 ;
4667 PyObject * obj2 = 0 ;
4668 char *kwnames[] = {
4669 (char *) "self",(char *) "x",(char *) "y", NULL
4670 };
4671
4672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4674 if (SWIG_arg_fail(1)) SWIG_fail;
4675 {
4676 arg2 = (long)(SWIG_As_long(obj1));
4677 if (SWIG_arg_fail(2)) SWIG_fail;
4678 }
4679 {
4680 arg3 = (long)(SWIG_As_long(obj2));
4681 if (SWIG_arg_fail(3)) SWIG_fail;
4682 }
4683 {
4684 PyThreadState* __tstate = wxPyBeginAllowThreads();
4685 wxPoint_Set(arg1,arg2,arg3);
4686
4687 wxPyEndAllowThreads(__tstate);
4688 if (PyErr_Occurred()) SWIG_fail;
4689 }
4690 Py_INCREF(Py_None); resultobj = Py_None;
4691 return resultobj;
4692 fail:
4693 return NULL;
4694 }
4695
4696
4697 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4698 PyObject *resultobj;
4699 wxPoint *arg1 = (wxPoint *) 0 ;
4700 PyObject *result;
4701 PyObject * obj0 = 0 ;
4702 char *kwnames[] = {
4703 (char *) "self", NULL
4704 };
4705
4706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4708 if (SWIG_arg_fail(1)) SWIG_fail;
4709 {
4710 PyThreadState* __tstate = wxPyBeginAllowThreads();
4711 result = (PyObject *)wxPoint_Get(arg1);
4712
4713 wxPyEndAllowThreads(__tstate);
4714 if (PyErr_Occurred()) SWIG_fail;
4715 }
4716 resultobj = result;
4717 return resultobj;
4718 fail:
4719 return NULL;
4720 }
4721
4722
4723 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4724 PyObject *obj;
4725 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4726 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4727 Py_INCREF(obj);
4728 return Py_BuildValue((char *)"");
4729 }
4730 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4731 PyObject *resultobj;
4732 int arg1 = (int) 0 ;
4733 int arg2 = (int) 0 ;
4734 int arg3 = (int) 0 ;
4735 int arg4 = (int) 0 ;
4736 wxRect *result;
4737 PyObject * obj0 = 0 ;
4738 PyObject * obj1 = 0 ;
4739 PyObject * obj2 = 0 ;
4740 PyObject * obj3 = 0 ;
4741 char *kwnames[] = {
4742 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4743 };
4744
4745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4746 if (obj0) {
4747 {
4748 arg1 = (int)(SWIG_As_int(obj0));
4749 if (SWIG_arg_fail(1)) SWIG_fail;
4750 }
4751 }
4752 if (obj1) {
4753 {
4754 arg2 = (int)(SWIG_As_int(obj1));
4755 if (SWIG_arg_fail(2)) SWIG_fail;
4756 }
4757 }
4758 if (obj2) {
4759 {
4760 arg3 = (int)(SWIG_As_int(obj2));
4761 if (SWIG_arg_fail(3)) SWIG_fail;
4762 }
4763 }
4764 if (obj3) {
4765 {
4766 arg4 = (int)(SWIG_As_int(obj3));
4767 if (SWIG_arg_fail(4)) SWIG_fail;
4768 }
4769 }
4770 {
4771 PyThreadState* __tstate = wxPyBeginAllowThreads();
4772 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4773
4774 wxPyEndAllowThreads(__tstate);
4775 if (PyErr_Occurred()) SWIG_fail;
4776 }
4777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4778 return resultobj;
4779 fail:
4780 return NULL;
4781 }
4782
4783
4784 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4785 PyObject *resultobj;
4786 wxPoint *arg1 = 0 ;
4787 wxPoint *arg2 = 0 ;
4788 wxRect *result;
4789 wxPoint temp1 ;
4790 wxPoint temp2 ;
4791 PyObject * obj0 = 0 ;
4792 PyObject * obj1 = 0 ;
4793 char *kwnames[] = {
4794 (char *) "topLeft",(char *) "bottomRight", NULL
4795 };
4796
4797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4798 {
4799 arg1 = &temp1;
4800 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4801 }
4802 {
4803 arg2 = &temp2;
4804 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4805 }
4806 {
4807 PyThreadState* __tstate = wxPyBeginAllowThreads();
4808 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4809
4810 wxPyEndAllowThreads(__tstate);
4811 if (PyErr_Occurred()) SWIG_fail;
4812 }
4813 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4814 return resultobj;
4815 fail:
4816 return NULL;
4817 }
4818
4819
4820 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4821 PyObject *resultobj;
4822 wxPoint *arg1 = 0 ;
4823 wxSize *arg2 = 0 ;
4824 wxRect *result;
4825 wxPoint temp1 ;
4826 wxSize temp2 ;
4827 PyObject * obj0 = 0 ;
4828 PyObject * obj1 = 0 ;
4829 char *kwnames[] = {
4830 (char *) "pos",(char *) "size", NULL
4831 };
4832
4833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4834 {
4835 arg1 = &temp1;
4836 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4837 }
4838 {
4839 arg2 = &temp2;
4840 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4841 }
4842 {
4843 PyThreadState* __tstate = wxPyBeginAllowThreads();
4844 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4845
4846 wxPyEndAllowThreads(__tstate);
4847 if (PyErr_Occurred()) SWIG_fail;
4848 }
4849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4850 return resultobj;
4851 fail:
4852 return NULL;
4853 }
4854
4855
4856 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4857 PyObject *resultobj;
4858 wxSize *arg1 = 0 ;
4859 wxRect *result;
4860 wxSize temp1 ;
4861 PyObject * obj0 = 0 ;
4862 char *kwnames[] = {
4863 (char *) "size", NULL
4864 };
4865
4866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4867 {
4868 arg1 = &temp1;
4869 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4870 }
4871 {
4872 PyThreadState* __tstate = wxPyBeginAllowThreads();
4873 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4874
4875 wxPyEndAllowThreads(__tstate);
4876 if (PyErr_Occurred()) SWIG_fail;
4877 }
4878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4879 return resultobj;
4880 fail:
4881 return NULL;
4882 }
4883
4884
4885 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4886 PyObject *resultobj;
4887 wxRect *arg1 = (wxRect *) 0 ;
4888 PyObject * obj0 = 0 ;
4889 char *kwnames[] = {
4890 (char *) "self", NULL
4891 };
4892
4893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4895 if (SWIG_arg_fail(1)) SWIG_fail;
4896 {
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 delete arg1;
4899
4900 wxPyEndAllowThreads(__tstate);
4901 if (PyErr_Occurred()) SWIG_fail;
4902 }
4903 Py_INCREF(Py_None); resultobj = Py_None;
4904 return resultobj;
4905 fail:
4906 return NULL;
4907 }
4908
4909
4910 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4911 PyObject *resultobj;
4912 wxRect *arg1 = (wxRect *) 0 ;
4913 int result;
4914 PyObject * obj0 = 0 ;
4915 char *kwnames[] = {
4916 (char *) "self", NULL
4917 };
4918
4919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4921 if (SWIG_arg_fail(1)) SWIG_fail;
4922 {
4923 PyThreadState* __tstate = wxPyBeginAllowThreads();
4924 result = (int)((wxRect const *)arg1)->GetX();
4925
4926 wxPyEndAllowThreads(__tstate);
4927 if (PyErr_Occurred()) SWIG_fail;
4928 }
4929 {
4930 resultobj = SWIG_From_int((int)(result));
4931 }
4932 return resultobj;
4933 fail:
4934 return NULL;
4935 }
4936
4937
4938 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4939 PyObject *resultobj;
4940 wxRect *arg1 = (wxRect *) 0 ;
4941 int arg2 ;
4942 PyObject * obj0 = 0 ;
4943 PyObject * obj1 = 0 ;
4944 char *kwnames[] = {
4945 (char *) "self",(char *) "x", NULL
4946 };
4947
4948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4950 if (SWIG_arg_fail(1)) SWIG_fail;
4951 {
4952 arg2 = (int)(SWIG_As_int(obj1));
4953 if (SWIG_arg_fail(2)) SWIG_fail;
4954 }
4955 {
4956 PyThreadState* __tstate = wxPyBeginAllowThreads();
4957 (arg1)->SetX(arg2);
4958
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 Py_INCREF(Py_None); resultobj = Py_None;
4963 return resultobj;
4964 fail:
4965 return NULL;
4966 }
4967
4968
4969 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4970 PyObject *resultobj;
4971 wxRect *arg1 = (wxRect *) 0 ;
4972 int result;
4973 PyObject * obj0 = 0 ;
4974 char *kwnames[] = {
4975 (char *) "self", NULL
4976 };
4977
4978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4980 if (SWIG_arg_fail(1)) SWIG_fail;
4981 {
4982 PyThreadState* __tstate = wxPyBeginAllowThreads();
4983 result = (int)(arg1)->GetY();
4984
4985 wxPyEndAllowThreads(__tstate);
4986 if (PyErr_Occurred()) SWIG_fail;
4987 }
4988 {
4989 resultobj = SWIG_From_int((int)(result));
4990 }
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
4998 PyObject *resultobj;
4999 wxRect *arg1 = (wxRect *) 0 ;
5000 int arg2 ;
5001 PyObject * obj0 = 0 ;
5002 PyObject * obj1 = 0 ;
5003 char *kwnames[] = {
5004 (char *) "self",(char *) "y", NULL
5005 };
5006
5007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5009 if (SWIG_arg_fail(1)) SWIG_fail;
5010 {
5011 arg2 = (int)(SWIG_As_int(obj1));
5012 if (SWIG_arg_fail(2)) SWIG_fail;
5013 }
5014 {
5015 PyThreadState* __tstate = wxPyBeginAllowThreads();
5016 (arg1)->SetY(arg2);
5017
5018 wxPyEndAllowThreads(__tstate);
5019 if (PyErr_Occurred()) SWIG_fail;
5020 }
5021 Py_INCREF(Py_None); resultobj = Py_None;
5022 return resultobj;
5023 fail:
5024 return NULL;
5025 }
5026
5027
5028 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5029 PyObject *resultobj;
5030 wxRect *arg1 = (wxRect *) 0 ;
5031 int result;
5032 PyObject * obj0 = 0 ;
5033 char *kwnames[] = {
5034 (char *) "self", NULL
5035 };
5036
5037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5039 if (SWIG_arg_fail(1)) SWIG_fail;
5040 {
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 result = (int)((wxRect const *)arg1)->GetWidth();
5043
5044 wxPyEndAllowThreads(__tstate);
5045 if (PyErr_Occurred()) SWIG_fail;
5046 }
5047 {
5048 resultobj = SWIG_From_int((int)(result));
5049 }
5050 return resultobj;
5051 fail:
5052 return NULL;
5053 }
5054
5055
5056 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5057 PyObject *resultobj;
5058 wxRect *arg1 = (wxRect *) 0 ;
5059 int arg2 ;
5060 PyObject * obj0 = 0 ;
5061 PyObject * obj1 = 0 ;
5062 char *kwnames[] = {
5063 (char *) "self",(char *) "w", NULL
5064 };
5065
5066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5068 if (SWIG_arg_fail(1)) SWIG_fail;
5069 {
5070 arg2 = (int)(SWIG_As_int(obj1));
5071 if (SWIG_arg_fail(2)) SWIG_fail;
5072 }
5073 {
5074 PyThreadState* __tstate = wxPyBeginAllowThreads();
5075 (arg1)->SetWidth(arg2);
5076
5077 wxPyEndAllowThreads(__tstate);
5078 if (PyErr_Occurred()) SWIG_fail;
5079 }
5080 Py_INCREF(Py_None); resultobj = Py_None;
5081 return resultobj;
5082 fail:
5083 return NULL;
5084 }
5085
5086
5087 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5088 PyObject *resultobj;
5089 wxRect *arg1 = (wxRect *) 0 ;
5090 int result;
5091 PyObject * obj0 = 0 ;
5092 char *kwnames[] = {
5093 (char *) "self", NULL
5094 };
5095
5096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5098 if (SWIG_arg_fail(1)) SWIG_fail;
5099 {
5100 PyThreadState* __tstate = wxPyBeginAllowThreads();
5101 result = (int)((wxRect const *)arg1)->GetHeight();
5102
5103 wxPyEndAllowThreads(__tstate);
5104 if (PyErr_Occurred()) SWIG_fail;
5105 }
5106 {
5107 resultobj = SWIG_From_int((int)(result));
5108 }
5109 return resultobj;
5110 fail:
5111 return NULL;
5112 }
5113
5114
5115 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5116 PyObject *resultobj;
5117 wxRect *arg1 = (wxRect *) 0 ;
5118 int arg2 ;
5119 PyObject * obj0 = 0 ;
5120 PyObject * obj1 = 0 ;
5121 char *kwnames[] = {
5122 (char *) "self",(char *) "h", NULL
5123 };
5124
5125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5127 if (SWIG_arg_fail(1)) SWIG_fail;
5128 {
5129 arg2 = (int)(SWIG_As_int(obj1));
5130 if (SWIG_arg_fail(2)) SWIG_fail;
5131 }
5132 {
5133 PyThreadState* __tstate = wxPyBeginAllowThreads();
5134 (arg1)->SetHeight(arg2);
5135
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 Py_INCREF(Py_None); resultobj = Py_None;
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5147 PyObject *resultobj;
5148 wxRect *arg1 = (wxRect *) 0 ;
5149 wxPoint result;
5150 PyObject * obj0 = 0 ;
5151 char *kwnames[] = {
5152 (char *) "self", NULL
5153 };
5154
5155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5157 if (SWIG_arg_fail(1)) SWIG_fail;
5158 {
5159 PyThreadState* __tstate = wxPyBeginAllowThreads();
5160 result = ((wxRect const *)arg1)->GetPosition();
5161
5162 wxPyEndAllowThreads(__tstate);
5163 if (PyErr_Occurred()) SWIG_fail;
5164 }
5165 {
5166 wxPoint * resultptr;
5167 resultptr = new wxPoint((wxPoint &)(result));
5168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5169 }
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5177 PyObject *resultobj;
5178 wxRect *arg1 = (wxRect *) 0 ;
5179 wxPoint *arg2 = 0 ;
5180 wxPoint temp2 ;
5181 PyObject * obj0 = 0 ;
5182 PyObject * obj1 = 0 ;
5183 char *kwnames[] = {
5184 (char *) "self",(char *) "p", NULL
5185 };
5186
5187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5189 if (SWIG_arg_fail(1)) SWIG_fail;
5190 {
5191 arg2 = &temp2;
5192 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5193 }
5194 {
5195 PyThreadState* __tstate = wxPyBeginAllowThreads();
5196 (arg1)->SetPosition((wxPoint const &)*arg2);
5197
5198 wxPyEndAllowThreads(__tstate);
5199 if (PyErr_Occurred()) SWIG_fail;
5200 }
5201 Py_INCREF(Py_None); resultobj = Py_None;
5202 return resultobj;
5203 fail:
5204 return NULL;
5205 }
5206
5207
5208 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5209 PyObject *resultobj;
5210 wxRect *arg1 = (wxRect *) 0 ;
5211 wxSize result;
5212 PyObject * obj0 = 0 ;
5213 char *kwnames[] = {
5214 (char *) "self", NULL
5215 };
5216
5217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5219 if (SWIG_arg_fail(1)) SWIG_fail;
5220 {
5221 PyThreadState* __tstate = wxPyBeginAllowThreads();
5222 result = ((wxRect const *)arg1)->GetSize();
5223
5224 wxPyEndAllowThreads(__tstate);
5225 if (PyErr_Occurred()) SWIG_fail;
5226 }
5227 {
5228 wxSize * resultptr;
5229 resultptr = new wxSize((wxSize &)(result));
5230 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5231 }
5232 return resultobj;
5233 fail:
5234 return NULL;
5235 }
5236
5237
5238 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5239 PyObject *resultobj;
5240 wxRect *arg1 = (wxRect *) 0 ;
5241 wxSize *arg2 = 0 ;
5242 wxSize temp2 ;
5243 PyObject * obj0 = 0 ;
5244 PyObject * obj1 = 0 ;
5245 char *kwnames[] = {
5246 (char *) "self",(char *) "s", NULL
5247 };
5248
5249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5251 if (SWIG_arg_fail(1)) SWIG_fail;
5252 {
5253 arg2 = &temp2;
5254 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5255 }
5256 {
5257 PyThreadState* __tstate = wxPyBeginAllowThreads();
5258 (arg1)->SetSize((wxSize const &)*arg2);
5259
5260 wxPyEndAllowThreads(__tstate);
5261 if (PyErr_Occurred()) SWIG_fail;
5262 }
5263 Py_INCREF(Py_None); resultobj = Py_None;
5264 return resultobj;
5265 fail:
5266 return NULL;
5267 }
5268
5269
5270 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5271 PyObject *resultobj;
5272 wxRect *arg1 = (wxRect *) 0 ;
5273 wxPoint result;
5274 PyObject * obj0 = 0 ;
5275 char *kwnames[] = {
5276 (char *) "self", NULL
5277 };
5278
5279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5281 if (SWIG_arg_fail(1)) SWIG_fail;
5282 {
5283 PyThreadState* __tstate = wxPyBeginAllowThreads();
5284 result = ((wxRect const *)arg1)->GetTopLeft();
5285
5286 wxPyEndAllowThreads(__tstate);
5287 if (PyErr_Occurred()) SWIG_fail;
5288 }
5289 {
5290 wxPoint * resultptr;
5291 resultptr = new wxPoint((wxPoint &)(result));
5292 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5293 }
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj;
5302 wxRect *arg1 = (wxRect *) 0 ;
5303 wxPoint *arg2 = 0 ;
5304 wxPoint temp2 ;
5305 PyObject * obj0 = 0 ;
5306 PyObject * obj1 = 0 ;
5307 char *kwnames[] = {
5308 (char *) "self",(char *) "p", NULL
5309 };
5310
5311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5313 if (SWIG_arg_fail(1)) SWIG_fail;
5314 {
5315 arg2 = &temp2;
5316 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5317 }
5318 {
5319 PyThreadState* __tstate = wxPyBeginAllowThreads();
5320 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5321
5322 wxPyEndAllowThreads(__tstate);
5323 if (PyErr_Occurred()) SWIG_fail;
5324 }
5325 Py_INCREF(Py_None); resultobj = Py_None;
5326 return resultobj;
5327 fail:
5328 return NULL;
5329 }
5330
5331
5332 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5333 PyObject *resultobj;
5334 wxRect *arg1 = (wxRect *) 0 ;
5335 wxPoint result;
5336 PyObject * obj0 = 0 ;
5337 char *kwnames[] = {
5338 (char *) "self", NULL
5339 };
5340
5341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5343 if (SWIG_arg_fail(1)) SWIG_fail;
5344 {
5345 PyThreadState* __tstate = wxPyBeginAllowThreads();
5346 result = ((wxRect const *)arg1)->GetBottomRight();
5347
5348 wxPyEndAllowThreads(__tstate);
5349 if (PyErr_Occurred()) SWIG_fail;
5350 }
5351 {
5352 wxPoint * resultptr;
5353 resultptr = new wxPoint((wxPoint &)(result));
5354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5355 }
5356 return resultobj;
5357 fail:
5358 return NULL;
5359 }
5360
5361
5362 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5363 PyObject *resultobj;
5364 wxRect *arg1 = (wxRect *) 0 ;
5365 wxPoint *arg2 = 0 ;
5366 wxPoint temp2 ;
5367 PyObject * obj0 = 0 ;
5368 PyObject * obj1 = 0 ;
5369 char *kwnames[] = {
5370 (char *) "self",(char *) "p", NULL
5371 };
5372
5373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5375 if (SWIG_arg_fail(1)) SWIG_fail;
5376 {
5377 arg2 = &temp2;
5378 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5379 }
5380 {
5381 PyThreadState* __tstate = wxPyBeginAllowThreads();
5382 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5383
5384 wxPyEndAllowThreads(__tstate);
5385 if (PyErr_Occurred()) SWIG_fail;
5386 }
5387 Py_INCREF(Py_None); resultobj = Py_None;
5388 return resultobj;
5389 fail:
5390 return NULL;
5391 }
5392
5393
5394 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5395 PyObject *resultobj;
5396 wxRect *arg1 = (wxRect *) 0 ;
5397 int result;
5398 PyObject * obj0 = 0 ;
5399 char *kwnames[] = {
5400 (char *) "self", NULL
5401 };
5402
5403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5405 if (SWIG_arg_fail(1)) SWIG_fail;
5406 {
5407 PyThreadState* __tstate = wxPyBeginAllowThreads();
5408 result = (int)((wxRect const *)arg1)->GetLeft();
5409
5410 wxPyEndAllowThreads(__tstate);
5411 if (PyErr_Occurred()) SWIG_fail;
5412 }
5413 {
5414 resultobj = SWIG_From_int((int)(result));
5415 }
5416 return resultobj;
5417 fail:
5418 return NULL;
5419 }
5420
5421
5422 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5423 PyObject *resultobj;
5424 wxRect *arg1 = (wxRect *) 0 ;
5425 int result;
5426 PyObject * obj0 = 0 ;
5427 char *kwnames[] = {
5428 (char *) "self", NULL
5429 };
5430
5431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5433 if (SWIG_arg_fail(1)) SWIG_fail;
5434 {
5435 PyThreadState* __tstate = wxPyBeginAllowThreads();
5436 result = (int)((wxRect const *)arg1)->GetTop();
5437
5438 wxPyEndAllowThreads(__tstate);
5439 if (PyErr_Occurred()) SWIG_fail;
5440 }
5441 {
5442 resultobj = SWIG_From_int((int)(result));
5443 }
5444 return resultobj;
5445 fail:
5446 return NULL;
5447 }
5448
5449
5450 static PyObject *_wrap_Rect_GetBottom(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_GetBottom",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)->GetBottom();
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_GetRight(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_GetRight",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)->GetRight();
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_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj;
5508 wxRect *arg1 = (wxRect *) 0 ;
5509 int arg2 ;
5510 PyObject * obj0 = 0 ;
5511 PyObject * obj1 = 0 ;
5512 char *kwnames[] = {
5513 (char *) "self",(char *) "left", NULL
5514 };
5515
5516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5518 if (SWIG_arg_fail(1)) SWIG_fail;
5519 {
5520 arg2 = (int)(SWIG_As_int(obj1));
5521 if (SWIG_arg_fail(2)) SWIG_fail;
5522 }
5523 {
5524 PyThreadState* __tstate = wxPyBeginAllowThreads();
5525 (arg1)->SetLeft(arg2);
5526
5527 wxPyEndAllowThreads(__tstate);
5528 if (PyErr_Occurred()) SWIG_fail;
5529 }
5530 Py_INCREF(Py_None); resultobj = Py_None;
5531 return resultobj;
5532 fail:
5533 return NULL;
5534 }
5535
5536
5537 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5538 PyObject *resultobj;
5539 wxRect *arg1 = (wxRect *) 0 ;
5540 int arg2 ;
5541 PyObject * obj0 = 0 ;
5542 PyObject * obj1 = 0 ;
5543 char *kwnames[] = {
5544 (char *) "self",(char *) "right", NULL
5545 };
5546
5547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5549 if (SWIG_arg_fail(1)) SWIG_fail;
5550 {
5551 arg2 = (int)(SWIG_As_int(obj1));
5552 if (SWIG_arg_fail(2)) SWIG_fail;
5553 }
5554 {
5555 PyThreadState* __tstate = wxPyBeginAllowThreads();
5556 (arg1)->SetRight(arg2);
5557
5558 wxPyEndAllowThreads(__tstate);
5559 if (PyErr_Occurred()) SWIG_fail;
5560 }
5561 Py_INCREF(Py_None); resultobj = Py_None;
5562 return resultobj;
5563 fail:
5564 return NULL;
5565 }
5566
5567
5568 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5569 PyObject *resultobj;
5570 wxRect *arg1 = (wxRect *) 0 ;
5571 int arg2 ;
5572 PyObject * obj0 = 0 ;
5573 PyObject * obj1 = 0 ;
5574 char *kwnames[] = {
5575 (char *) "self",(char *) "top", NULL
5576 };
5577
5578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5580 if (SWIG_arg_fail(1)) SWIG_fail;
5581 {
5582 arg2 = (int)(SWIG_As_int(obj1));
5583 if (SWIG_arg_fail(2)) SWIG_fail;
5584 }
5585 {
5586 PyThreadState* __tstate = wxPyBeginAllowThreads();
5587 (arg1)->SetTop(arg2);
5588
5589 wxPyEndAllowThreads(__tstate);
5590 if (PyErr_Occurred()) SWIG_fail;
5591 }
5592 Py_INCREF(Py_None); resultobj = Py_None;
5593 return resultobj;
5594 fail:
5595 return NULL;
5596 }
5597
5598
5599 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5600 PyObject *resultobj;
5601 wxRect *arg1 = (wxRect *) 0 ;
5602 int arg2 ;
5603 PyObject * obj0 = 0 ;
5604 PyObject * obj1 = 0 ;
5605 char *kwnames[] = {
5606 (char *) "self",(char *) "bottom", NULL
5607 };
5608
5609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5611 if (SWIG_arg_fail(1)) SWIG_fail;
5612 {
5613 arg2 = (int)(SWIG_As_int(obj1));
5614 if (SWIG_arg_fail(2)) SWIG_fail;
5615 }
5616 {
5617 PyThreadState* __tstate = wxPyBeginAllowThreads();
5618 (arg1)->SetBottom(arg2);
5619
5620 wxPyEndAllowThreads(__tstate);
5621 if (PyErr_Occurred()) SWIG_fail;
5622 }
5623 Py_INCREF(Py_None); resultobj = Py_None;
5624 return resultobj;
5625 fail:
5626 return NULL;
5627 }
5628
5629
5630 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5631 PyObject *resultobj;
5632 wxRect *arg1 = (wxRect *) 0 ;
5633 int arg2 ;
5634 int arg3 ;
5635 wxRect *result;
5636 PyObject * obj0 = 0 ;
5637 PyObject * obj1 = 0 ;
5638 PyObject * obj2 = 0 ;
5639 char *kwnames[] = {
5640 (char *) "self",(char *) "dx",(char *) "dy", NULL
5641 };
5642
5643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5645 if (SWIG_arg_fail(1)) SWIG_fail;
5646 {
5647 arg2 = (int)(SWIG_As_int(obj1));
5648 if (SWIG_arg_fail(2)) SWIG_fail;
5649 }
5650 {
5651 arg3 = (int)(SWIG_As_int(obj2));
5652 if (SWIG_arg_fail(3)) SWIG_fail;
5653 }
5654 {
5655 PyThreadState* __tstate = wxPyBeginAllowThreads();
5656 {
5657 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5658 result = (wxRect *) &_result_ref;
5659 }
5660
5661 wxPyEndAllowThreads(__tstate);
5662 if (PyErr_Occurred()) SWIG_fail;
5663 }
5664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5672 PyObject *resultobj;
5673 wxRect *arg1 = (wxRect *) 0 ;
5674 int arg2 ;
5675 int arg3 ;
5676 wxRect *result;
5677 PyObject * obj0 = 0 ;
5678 PyObject * obj1 = 0 ;
5679 PyObject * obj2 = 0 ;
5680 char *kwnames[] = {
5681 (char *) "self",(char *) "dx",(char *) "dy", NULL
5682 };
5683
5684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5686 if (SWIG_arg_fail(1)) SWIG_fail;
5687 {
5688 arg2 = (int)(SWIG_As_int(obj1));
5689 if (SWIG_arg_fail(2)) SWIG_fail;
5690 }
5691 {
5692 arg3 = (int)(SWIG_As_int(obj2));
5693 if (SWIG_arg_fail(3)) SWIG_fail;
5694 }
5695 {
5696 PyThreadState* __tstate = wxPyBeginAllowThreads();
5697 {
5698 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5699 result = (wxRect *) &_result_ref;
5700 }
5701
5702 wxPyEndAllowThreads(__tstate);
5703 if (PyErr_Occurred()) SWIG_fail;
5704 }
5705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5706 return resultobj;
5707 fail:
5708 return NULL;
5709 }
5710
5711
5712 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5713 PyObject *resultobj;
5714 wxRect *arg1 = (wxRect *) 0 ;
5715 int arg2 ;
5716 int arg3 ;
5717 PyObject * obj0 = 0 ;
5718 PyObject * obj1 = 0 ;
5719 PyObject * obj2 = 0 ;
5720 char *kwnames[] = {
5721 (char *) "self",(char *) "dx",(char *) "dy", NULL
5722 };
5723
5724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5726 if (SWIG_arg_fail(1)) SWIG_fail;
5727 {
5728 arg2 = (int)(SWIG_As_int(obj1));
5729 if (SWIG_arg_fail(2)) SWIG_fail;
5730 }
5731 {
5732 arg3 = (int)(SWIG_As_int(obj2));
5733 if (SWIG_arg_fail(3)) SWIG_fail;
5734 }
5735 {
5736 PyThreadState* __tstate = wxPyBeginAllowThreads();
5737 (arg1)->Offset(arg2,arg3);
5738
5739 wxPyEndAllowThreads(__tstate);
5740 if (PyErr_Occurred()) SWIG_fail;
5741 }
5742 Py_INCREF(Py_None); resultobj = Py_None;
5743 return resultobj;
5744 fail:
5745 return NULL;
5746 }
5747
5748
5749 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5750 PyObject *resultobj;
5751 wxRect *arg1 = (wxRect *) 0 ;
5752 wxPoint *arg2 = 0 ;
5753 wxPoint temp2 ;
5754 PyObject * obj0 = 0 ;
5755 PyObject * obj1 = 0 ;
5756 char *kwnames[] = {
5757 (char *) "self",(char *) "pt", NULL
5758 };
5759
5760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5762 if (SWIG_arg_fail(1)) SWIG_fail;
5763 {
5764 arg2 = &temp2;
5765 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5766 }
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 (arg1)->Offset((wxPoint const &)*arg2);
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 Py_INCREF(Py_None); resultobj = Py_None;
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj;
5783 wxRect *arg1 = (wxRect *) 0 ;
5784 wxRect *arg2 = 0 ;
5785 wxRect result;
5786 wxRect temp2 ;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 char *kwnames[] = {
5790 (char *) "self",(char *) "rect", NULL
5791 };
5792
5793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5795 if (SWIG_arg_fail(1)) SWIG_fail;
5796 {
5797 arg2 = &temp2;
5798 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5799 }
5800 {
5801 PyThreadState* __tstate = wxPyBeginAllowThreads();
5802 result = (arg1)->Intersect((wxRect const &)*arg2);
5803
5804 wxPyEndAllowThreads(__tstate);
5805 if (PyErr_Occurred()) SWIG_fail;
5806 }
5807 {
5808 wxRect * resultptr;
5809 resultptr = new wxRect((wxRect &)(result));
5810 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5811 }
5812 return resultobj;
5813 fail:
5814 return NULL;
5815 }
5816
5817
5818 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5819 PyObject *resultobj;
5820 wxRect *arg1 = (wxRect *) 0 ;
5821 wxRect *arg2 = 0 ;
5822 wxRect result;
5823 wxRect temp2 ;
5824 PyObject * obj0 = 0 ;
5825 PyObject * obj1 = 0 ;
5826 char *kwnames[] = {
5827 (char *) "self",(char *) "rect", NULL
5828 };
5829
5830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5832 if (SWIG_arg_fail(1)) SWIG_fail;
5833 {
5834 arg2 = &temp2;
5835 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5836 }
5837 {
5838 PyThreadState* __tstate = wxPyBeginAllowThreads();
5839 result = (arg1)->Union((wxRect const &)*arg2);
5840
5841 wxPyEndAllowThreads(__tstate);
5842 if (PyErr_Occurred()) SWIG_fail;
5843 }
5844 {
5845 wxRect * resultptr;
5846 resultptr = new wxRect((wxRect &)(result));
5847 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5848 }
5849 return resultobj;
5850 fail:
5851 return NULL;
5852 }
5853
5854
5855 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5856 PyObject *resultobj;
5857 wxRect *arg1 = (wxRect *) 0 ;
5858 wxRect *arg2 = 0 ;
5859 wxRect result;
5860 wxRect temp2 ;
5861 PyObject * obj0 = 0 ;
5862 PyObject * obj1 = 0 ;
5863 char *kwnames[] = {
5864 (char *) "self",(char *) "rect", NULL
5865 };
5866
5867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5869 if (SWIG_arg_fail(1)) SWIG_fail;
5870 {
5871 arg2 = &temp2;
5872 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5873 }
5874 {
5875 PyThreadState* __tstate = wxPyBeginAllowThreads();
5876 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5877
5878 wxPyEndAllowThreads(__tstate);
5879 if (PyErr_Occurred()) SWIG_fail;
5880 }
5881 {
5882 wxRect * resultptr;
5883 resultptr = new wxRect((wxRect &)(result));
5884 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5885 }
5886 return resultobj;
5887 fail:
5888 return NULL;
5889 }
5890
5891
5892 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5893 PyObject *resultobj;
5894 wxRect *arg1 = (wxRect *) 0 ;
5895 wxRect *arg2 = 0 ;
5896 wxRect *result;
5897 wxRect temp2 ;
5898 PyObject * obj0 = 0 ;
5899 PyObject * obj1 = 0 ;
5900 char *kwnames[] = {
5901 (char *) "self",(char *) "rect", NULL
5902 };
5903
5904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5906 if (SWIG_arg_fail(1)) SWIG_fail;
5907 {
5908 arg2 = &temp2;
5909 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5910 }
5911 {
5912 PyThreadState* __tstate = wxPyBeginAllowThreads();
5913 {
5914 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5915 result = (wxRect *) &_result_ref;
5916 }
5917
5918 wxPyEndAllowThreads(__tstate);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5922 return resultobj;
5923 fail:
5924 return NULL;
5925 }
5926
5927
5928 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5929 PyObject *resultobj;
5930 wxRect *arg1 = (wxRect *) 0 ;
5931 wxRect *arg2 = 0 ;
5932 bool result;
5933 wxRect temp2 ;
5934 PyObject * obj0 = 0 ;
5935 PyObject * obj1 = 0 ;
5936 char *kwnames[] = {
5937 (char *) "self",(char *) "rect", NULL
5938 };
5939
5940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5942 if (SWIG_arg_fail(1)) SWIG_fail;
5943 {
5944 arg2 = &temp2;
5945 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5946 }
5947 {
5948 PyThreadState* __tstate = wxPyBeginAllowThreads();
5949 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5950
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 {
5955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5956 }
5957 return resultobj;
5958 fail:
5959 return NULL;
5960 }
5961
5962
5963 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5964 PyObject *resultobj;
5965 wxRect *arg1 = (wxRect *) 0 ;
5966 wxRect *arg2 = 0 ;
5967 bool result;
5968 wxRect temp2 ;
5969 PyObject * obj0 = 0 ;
5970 PyObject * obj1 = 0 ;
5971 char *kwnames[] = {
5972 (char *) "self",(char *) "rect", NULL
5973 };
5974
5975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5977 if (SWIG_arg_fail(1)) SWIG_fail;
5978 {
5979 arg2 = &temp2;
5980 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5981 }
5982 {
5983 PyThreadState* __tstate = wxPyBeginAllowThreads();
5984 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5985
5986 wxPyEndAllowThreads(__tstate);
5987 if (PyErr_Occurred()) SWIG_fail;
5988 }
5989 {
5990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5991 }
5992 return resultobj;
5993 fail:
5994 return NULL;
5995 }
5996
5997
5998 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
5999 PyObject *resultobj;
6000 wxRect *arg1 = (wxRect *) 0 ;
6001 int arg2 ;
6002 int arg3 ;
6003 bool result;
6004 PyObject * obj0 = 0 ;
6005 PyObject * obj1 = 0 ;
6006 PyObject * obj2 = 0 ;
6007 char *kwnames[] = {
6008 (char *) "self",(char *) "x",(char *) "y", NULL
6009 };
6010
6011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6013 if (SWIG_arg_fail(1)) SWIG_fail;
6014 {
6015 arg2 = (int)(SWIG_As_int(obj1));
6016 if (SWIG_arg_fail(2)) SWIG_fail;
6017 }
6018 {
6019 arg3 = (int)(SWIG_As_int(obj2));
6020 if (SWIG_arg_fail(3)) SWIG_fail;
6021 }
6022 {
6023 PyThreadState* __tstate = wxPyBeginAllowThreads();
6024 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6025
6026 wxPyEndAllowThreads(__tstate);
6027 if (PyErr_Occurred()) SWIG_fail;
6028 }
6029 {
6030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6031 }
6032 return resultobj;
6033 fail:
6034 return NULL;
6035 }
6036
6037
6038 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6039 PyObject *resultobj;
6040 wxRect *arg1 = (wxRect *) 0 ;
6041 wxPoint *arg2 = 0 ;
6042 bool result;
6043 wxPoint temp2 ;
6044 PyObject * obj0 = 0 ;
6045 PyObject * obj1 = 0 ;
6046 char *kwnames[] = {
6047 (char *) "self",(char *) "pt", NULL
6048 };
6049
6050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6052 if (SWIG_arg_fail(1)) SWIG_fail;
6053 {
6054 arg2 = &temp2;
6055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6056 }
6057 {
6058 PyThreadState* __tstate = wxPyBeginAllowThreads();
6059 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6060
6061 wxPyEndAllowThreads(__tstate);
6062 if (PyErr_Occurred()) SWIG_fail;
6063 }
6064 {
6065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6066 }
6067 return resultobj;
6068 fail:
6069 return NULL;
6070 }
6071
6072
6073 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6074 PyObject *resultobj;
6075 wxRect *arg1 = (wxRect *) 0 ;
6076 wxRect *arg2 = 0 ;
6077 bool result;
6078 wxRect temp2 ;
6079 PyObject * obj0 = 0 ;
6080 PyObject * obj1 = 0 ;
6081 char *kwnames[] = {
6082 (char *) "self",(char *) "rect", NULL
6083 };
6084
6085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6087 if (SWIG_arg_fail(1)) SWIG_fail;
6088 {
6089 arg2 = &temp2;
6090 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6091 }
6092 {
6093 PyThreadState* __tstate = wxPyBeginAllowThreads();
6094 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6095
6096 wxPyEndAllowThreads(__tstate);
6097 if (PyErr_Occurred()) SWIG_fail;
6098 }
6099 {
6100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6101 }
6102 return resultobj;
6103 fail:
6104 return NULL;
6105 }
6106
6107
6108 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6109 PyObject *resultobj;
6110 wxRect *arg1 = (wxRect *) 0 ;
6111 int arg2 ;
6112 PyObject * obj0 = 0 ;
6113 PyObject * obj1 = 0 ;
6114 char *kwnames[] = {
6115 (char *) "self",(char *) "x", NULL
6116 };
6117
6118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6120 if (SWIG_arg_fail(1)) SWIG_fail;
6121 {
6122 arg2 = (int)(SWIG_As_int(obj1));
6123 if (SWIG_arg_fail(2)) SWIG_fail;
6124 }
6125 if (arg1) (arg1)->x = arg2;
6126
6127 Py_INCREF(Py_None); resultobj = Py_None;
6128 return resultobj;
6129 fail:
6130 return NULL;
6131 }
6132
6133
6134 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6135 PyObject *resultobj;
6136 wxRect *arg1 = (wxRect *) 0 ;
6137 int result;
6138 PyObject * obj0 = 0 ;
6139 char *kwnames[] = {
6140 (char *) "self", NULL
6141 };
6142
6143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6145 if (SWIG_arg_fail(1)) SWIG_fail;
6146 result = (int) ((arg1)->x);
6147
6148 {
6149 resultobj = SWIG_From_int((int)(result));
6150 }
6151 return resultobj;
6152 fail:
6153 return NULL;
6154 }
6155
6156
6157 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6158 PyObject *resultobj;
6159 wxRect *arg1 = (wxRect *) 0 ;
6160 int arg2 ;
6161 PyObject * obj0 = 0 ;
6162 PyObject * obj1 = 0 ;
6163 char *kwnames[] = {
6164 (char *) "self",(char *) "y", NULL
6165 };
6166
6167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6169 if (SWIG_arg_fail(1)) SWIG_fail;
6170 {
6171 arg2 = (int)(SWIG_As_int(obj1));
6172 if (SWIG_arg_fail(2)) SWIG_fail;
6173 }
6174 if (arg1) (arg1)->y = arg2;
6175
6176 Py_INCREF(Py_None); resultobj = Py_None;
6177 return resultobj;
6178 fail:
6179 return NULL;
6180 }
6181
6182
6183 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj;
6185 wxRect *arg1 = (wxRect *) 0 ;
6186 int result;
6187 PyObject * obj0 = 0 ;
6188 char *kwnames[] = {
6189 (char *) "self", NULL
6190 };
6191
6192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6194 if (SWIG_arg_fail(1)) SWIG_fail;
6195 result = (int) ((arg1)->y);
6196
6197 {
6198 resultobj = SWIG_From_int((int)(result));
6199 }
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj;
6208 wxRect *arg1 = (wxRect *) 0 ;
6209 int arg2 ;
6210 PyObject * obj0 = 0 ;
6211 PyObject * obj1 = 0 ;
6212 char *kwnames[] = {
6213 (char *) "self",(char *) "width", NULL
6214 };
6215
6216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6218 if (SWIG_arg_fail(1)) SWIG_fail;
6219 {
6220 arg2 = (int)(SWIG_As_int(obj1));
6221 if (SWIG_arg_fail(2)) SWIG_fail;
6222 }
6223 if (arg1) (arg1)->width = arg2;
6224
6225 Py_INCREF(Py_None); resultobj = Py_None;
6226 return resultobj;
6227 fail:
6228 return NULL;
6229 }
6230
6231
6232 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6233 PyObject *resultobj;
6234 wxRect *arg1 = (wxRect *) 0 ;
6235 int result;
6236 PyObject * obj0 = 0 ;
6237 char *kwnames[] = {
6238 (char *) "self", NULL
6239 };
6240
6241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6243 if (SWIG_arg_fail(1)) SWIG_fail;
6244 result = (int) ((arg1)->width);
6245
6246 {
6247 resultobj = SWIG_From_int((int)(result));
6248 }
6249 return resultobj;
6250 fail:
6251 return NULL;
6252 }
6253
6254
6255 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6256 PyObject *resultobj;
6257 wxRect *arg1 = (wxRect *) 0 ;
6258 int arg2 ;
6259 PyObject * obj0 = 0 ;
6260 PyObject * obj1 = 0 ;
6261 char *kwnames[] = {
6262 (char *) "self",(char *) "height", NULL
6263 };
6264
6265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6267 if (SWIG_arg_fail(1)) SWIG_fail;
6268 {
6269 arg2 = (int)(SWIG_As_int(obj1));
6270 if (SWIG_arg_fail(2)) SWIG_fail;
6271 }
6272 if (arg1) (arg1)->height = arg2;
6273
6274 Py_INCREF(Py_None); resultobj = Py_None;
6275 return resultobj;
6276 fail:
6277 return NULL;
6278 }
6279
6280
6281 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6282 PyObject *resultobj;
6283 wxRect *arg1 = (wxRect *) 0 ;
6284 int result;
6285 PyObject * obj0 = 0 ;
6286 char *kwnames[] = {
6287 (char *) "self", NULL
6288 };
6289
6290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6292 if (SWIG_arg_fail(1)) SWIG_fail;
6293 result = (int) ((arg1)->height);
6294
6295 {
6296 resultobj = SWIG_From_int((int)(result));
6297 }
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj;
6306 wxRect *arg1 = (wxRect *) 0 ;
6307 int arg2 = (int) 0 ;
6308 int arg3 = (int) 0 ;
6309 int arg4 = (int) 0 ;
6310 int arg5 = (int) 0 ;
6311 PyObject * obj0 = 0 ;
6312 PyObject * obj1 = 0 ;
6313 PyObject * obj2 = 0 ;
6314 PyObject * obj3 = 0 ;
6315 PyObject * obj4 = 0 ;
6316 char *kwnames[] = {
6317 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6318 };
6319
6320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6322 if (SWIG_arg_fail(1)) SWIG_fail;
6323 if (obj1) {
6324 {
6325 arg2 = (int)(SWIG_As_int(obj1));
6326 if (SWIG_arg_fail(2)) SWIG_fail;
6327 }
6328 }
6329 if (obj2) {
6330 {
6331 arg3 = (int)(SWIG_As_int(obj2));
6332 if (SWIG_arg_fail(3)) SWIG_fail;
6333 }
6334 }
6335 if (obj3) {
6336 {
6337 arg4 = (int)(SWIG_As_int(obj3));
6338 if (SWIG_arg_fail(4)) SWIG_fail;
6339 }
6340 }
6341 if (obj4) {
6342 {
6343 arg5 = (int)(SWIG_As_int(obj4));
6344 if (SWIG_arg_fail(5)) SWIG_fail;
6345 }
6346 }
6347 {
6348 PyThreadState* __tstate = wxPyBeginAllowThreads();
6349 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6350
6351 wxPyEndAllowThreads(__tstate);
6352 if (PyErr_Occurred()) SWIG_fail;
6353 }
6354 Py_INCREF(Py_None); resultobj = Py_None;
6355 return resultobj;
6356 fail:
6357 return NULL;
6358 }
6359
6360
6361 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6362 PyObject *resultobj;
6363 wxRect *arg1 = (wxRect *) 0 ;
6364 PyObject *result;
6365 PyObject * obj0 = 0 ;
6366 char *kwnames[] = {
6367 (char *) "self", NULL
6368 };
6369
6370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6372 if (SWIG_arg_fail(1)) SWIG_fail;
6373 {
6374 PyThreadState* __tstate = wxPyBeginAllowThreads();
6375 result = (PyObject *)wxRect_Get(arg1);
6376
6377 wxPyEndAllowThreads(__tstate);
6378 if (PyErr_Occurred()) SWIG_fail;
6379 }
6380 resultobj = result;
6381 return resultobj;
6382 fail:
6383 return NULL;
6384 }
6385
6386
6387 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6388 PyObject *obj;
6389 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6390 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6391 Py_INCREF(obj);
6392 return Py_BuildValue((char *)"");
6393 }
6394 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6395 PyObject *resultobj;
6396 wxRect *arg1 = (wxRect *) 0 ;
6397 wxRect *arg2 = (wxRect *) 0 ;
6398 PyObject *result;
6399 PyObject * obj0 = 0 ;
6400 PyObject * obj1 = 0 ;
6401 char *kwnames[] = {
6402 (char *) "r1",(char *) "r2", NULL
6403 };
6404
6405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6407 if (SWIG_arg_fail(1)) SWIG_fail;
6408 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6409 if (SWIG_arg_fail(2)) SWIG_fail;
6410 {
6411 if (!wxPyCheckForApp()) SWIG_fail;
6412 PyThreadState* __tstate = wxPyBeginAllowThreads();
6413 result = (PyObject *)wxIntersectRect(arg1,arg2);
6414
6415 wxPyEndAllowThreads(__tstate);
6416 if (PyErr_Occurred()) SWIG_fail;
6417 }
6418 resultobj = result;
6419 return resultobj;
6420 fail:
6421 return NULL;
6422 }
6423
6424
6425 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6426 PyObject *resultobj;
6427 double arg1 = (double) 0.0 ;
6428 double arg2 = (double) 0.0 ;
6429 wxPoint2D *result;
6430 PyObject * obj0 = 0 ;
6431 PyObject * obj1 = 0 ;
6432 char *kwnames[] = {
6433 (char *) "x",(char *) "y", NULL
6434 };
6435
6436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6437 if (obj0) {
6438 {
6439 arg1 = (double)(SWIG_As_double(obj0));
6440 if (SWIG_arg_fail(1)) SWIG_fail;
6441 }
6442 }
6443 if (obj1) {
6444 {
6445 arg2 = (double)(SWIG_As_double(obj1));
6446 if (SWIG_arg_fail(2)) SWIG_fail;
6447 }
6448 }
6449 {
6450 PyThreadState* __tstate = wxPyBeginAllowThreads();
6451 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6452
6453 wxPyEndAllowThreads(__tstate);
6454 if (PyErr_Occurred()) SWIG_fail;
6455 }
6456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6457 return resultobj;
6458 fail:
6459 return NULL;
6460 }
6461
6462
6463 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6464 PyObject *resultobj;
6465 wxPoint2D *arg1 = 0 ;
6466 wxPoint2D *result;
6467 wxPoint2D temp1 ;
6468 PyObject * obj0 = 0 ;
6469 char *kwnames[] = {
6470 (char *) "pt", NULL
6471 };
6472
6473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6474 {
6475 arg1 = &temp1;
6476 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6477 }
6478 {
6479 PyThreadState* __tstate = wxPyBeginAllowThreads();
6480 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6481
6482 wxPyEndAllowThreads(__tstate);
6483 if (PyErr_Occurred()) SWIG_fail;
6484 }
6485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6486 return resultobj;
6487 fail:
6488 return NULL;
6489 }
6490
6491
6492 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6493 PyObject *resultobj;
6494 wxPoint *arg1 = 0 ;
6495 wxPoint2D *result;
6496 wxPoint temp1 ;
6497 PyObject * obj0 = 0 ;
6498 char *kwnames[] = {
6499 (char *) "pt", NULL
6500 };
6501
6502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6503 {
6504 arg1 = &temp1;
6505 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6506 }
6507 {
6508 PyThreadState* __tstate = wxPyBeginAllowThreads();
6509 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6510
6511 wxPyEndAllowThreads(__tstate);
6512 if (PyErr_Occurred()) SWIG_fail;
6513 }
6514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6515 return resultobj;
6516 fail:
6517 return NULL;
6518 }
6519
6520
6521 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6522 PyObject *resultobj;
6523 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6524 int *arg2 = (int *) 0 ;
6525 int *arg3 = (int *) 0 ;
6526 int temp2 ;
6527 int res2 = 0 ;
6528 int temp3 ;
6529 int res3 = 0 ;
6530 PyObject * obj0 = 0 ;
6531 char *kwnames[] = {
6532 (char *) "self", NULL
6533 };
6534
6535 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6536 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6539 if (SWIG_arg_fail(1)) SWIG_fail;
6540 {
6541 PyThreadState* __tstate = wxPyBeginAllowThreads();
6542 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6543
6544 wxPyEndAllowThreads(__tstate);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 Py_INCREF(Py_None); resultobj = Py_None;
6548 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6549 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6550 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6551 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6552 return resultobj;
6553 fail:
6554 return NULL;
6555 }
6556
6557
6558 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6559 PyObject *resultobj;
6560 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6561 int *arg2 = (int *) 0 ;
6562 int *arg3 = (int *) 0 ;
6563 int temp2 ;
6564 int res2 = 0 ;
6565 int temp3 ;
6566 int res3 = 0 ;
6567 PyObject * obj0 = 0 ;
6568 char *kwnames[] = {
6569 (char *) "self", NULL
6570 };
6571
6572 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6573 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6576 if (SWIG_arg_fail(1)) SWIG_fail;
6577 {
6578 PyThreadState* __tstate = wxPyBeginAllowThreads();
6579 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6580
6581 wxPyEndAllowThreads(__tstate);
6582 if (PyErr_Occurred()) SWIG_fail;
6583 }
6584 Py_INCREF(Py_None); resultobj = Py_None;
6585 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6586 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6587 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6588 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6589 return resultobj;
6590 fail:
6591 return NULL;
6592 }
6593
6594
6595 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6596 PyObject *resultobj;
6597 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6598 double result;
6599 PyObject * obj0 = 0 ;
6600 char *kwnames[] = {
6601 (char *) "self", NULL
6602 };
6603
6604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6606 if (SWIG_arg_fail(1)) SWIG_fail;
6607 {
6608 PyThreadState* __tstate = wxPyBeginAllowThreads();
6609 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6610
6611 wxPyEndAllowThreads(__tstate);
6612 if (PyErr_Occurred()) SWIG_fail;
6613 }
6614 {
6615 resultobj = SWIG_From_double((double)(result));
6616 }
6617 return resultobj;
6618 fail:
6619 return NULL;
6620 }
6621
6622
6623 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6624 PyObject *resultobj;
6625 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6626 double result;
6627 PyObject * obj0 = 0 ;
6628 char *kwnames[] = {
6629 (char *) "self", NULL
6630 };
6631
6632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6634 if (SWIG_arg_fail(1)) SWIG_fail;
6635 {
6636 PyThreadState* __tstate = wxPyBeginAllowThreads();
6637 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6638
6639 wxPyEndAllowThreads(__tstate);
6640 if (PyErr_Occurred()) SWIG_fail;
6641 }
6642 {
6643 resultobj = SWIG_From_double((double)(result));
6644 }
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6652 PyObject *resultobj;
6653 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6654 double arg2 ;
6655 PyObject * obj0 = 0 ;
6656 PyObject * obj1 = 0 ;
6657 char *kwnames[] = {
6658 (char *) "self",(char *) "length", NULL
6659 };
6660
6661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6663 if (SWIG_arg_fail(1)) SWIG_fail;
6664 {
6665 arg2 = (double)(SWIG_As_double(obj1));
6666 if (SWIG_arg_fail(2)) SWIG_fail;
6667 }
6668 {
6669 PyThreadState* __tstate = wxPyBeginAllowThreads();
6670 (arg1)->SetVectorLength(arg2);
6671
6672 wxPyEndAllowThreads(__tstate);
6673 if (PyErr_Occurred()) SWIG_fail;
6674 }
6675 Py_INCREF(Py_None); resultobj = Py_None;
6676 return resultobj;
6677 fail:
6678 return NULL;
6679 }
6680
6681
6682 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6683 PyObject *resultobj;
6684 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6685 double arg2 ;
6686 PyObject * obj0 = 0 ;
6687 PyObject * obj1 = 0 ;
6688 char *kwnames[] = {
6689 (char *) "self",(char *) "degrees", NULL
6690 };
6691
6692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6694 if (SWIG_arg_fail(1)) SWIG_fail;
6695 {
6696 arg2 = (double)(SWIG_As_double(obj1));
6697 if (SWIG_arg_fail(2)) SWIG_fail;
6698 }
6699 {
6700 PyThreadState* __tstate = wxPyBeginAllowThreads();
6701 (arg1)->SetVectorAngle(arg2);
6702
6703 wxPyEndAllowThreads(__tstate);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 Py_INCREF(Py_None); resultobj = Py_None;
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj;
6715 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6716 wxPoint2D *arg2 = 0 ;
6717 double result;
6718 wxPoint2D temp2 ;
6719 PyObject * obj0 = 0 ;
6720 PyObject * obj1 = 0 ;
6721 char *kwnames[] = {
6722 (char *) "self",(char *) "pt", NULL
6723 };
6724
6725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6727 if (SWIG_arg_fail(1)) SWIG_fail;
6728 {
6729 arg2 = &temp2;
6730 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6731 }
6732 {
6733 PyThreadState* __tstate = wxPyBeginAllowThreads();
6734 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6735
6736 wxPyEndAllowThreads(__tstate);
6737 if (PyErr_Occurred()) SWIG_fail;
6738 }
6739 {
6740 resultobj = SWIG_From_double((double)(result));
6741 }
6742 return resultobj;
6743 fail:
6744 return NULL;
6745 }
6746
6747
6748 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6749 PyObject *resultobj;
6750 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6751 wxPoint2D *arg2 = 0 ;
6752 double result;
6753 wxPoint2D temp2 ;
6754 PyObject * obj0 = 0 ;
6755 PyObject * obj1 = 0 ;
6756 char *kwnames[] = {
6757 (char *) "self",(char *) "pt", NULL
6758 };
6759
6760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6762 if (SWIG_arg_fail(1)) SWIG_fail;
6763 {
6764 arg2 = &temp2;
6765 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6766 }
6767 {
6768 PyThreadState* __tstate = wxPyBeginAllowThreads();
6769 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6770
6771 wxPyEndAllowThreads(__tstate);
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 {
6775 resultobj = SWIG_From_double((double)(result));
6776 }
6777 return resultobj;
6778 fail:
6779 return NULL;
6780 }
6781
6782
6783 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6784 PyObject *resultobj;
6785 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6786 wxPoint2D *arg2 = 0 ;
6787 double result;
6788 wxPoint2D temp2 ;
6789 PyObject * obj0 = 0 ;
6790 PyObject * obj1 = 0 ;
6791 char *kwnames[] = {
6792 (char *) "self",(char *) "vec", NULL
6793 };
6794
6795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6797 if (SWIG_arg_fail(1)) SWIG_fail;
6798 {
6799 arg2 = &temp2;
6800 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6801 }
6802 {
6803 PyThreadState* __tstate = wxPyBeginAllowThreads();
6804 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6805
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 {
6810 resultobj = SWIG_From_double((double)(result));
6811 }
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6819 PyObject *resultobj;
6820 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6821 wxPoint2D *arg2 = 0 ;
6822 double result;
6823 wxPoint2D temp2 ;
6824 PyObject * obj0 = 0 ;
6825 PyObject * obj1 = 0 ;
6826 char *kwnames[] = {
6827 (char *) "self",(char *) "vec", NULL
6828 };
6829
6830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6832 if (SWIG_arg_fail(1)) SWIG_fail;
6833 {
6834 arg2 = &temp2;
6835 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6836 }
6837 {
6838 PyThreadState* __tstate = wxPyBeginAllowThreads();
6839 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6840
6841 wxPyEndAllowThreads(__tstate);
6842 if (PyErr_Occurred()) SWIG_fail;
6843 }
6844 {
6845 resultobj = SWIG_From_double((double)(result));
6846 }
6847 return resultobj;
6848 fail:
6849 return NULL;
6850 }
6851
6852
6853 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6854 PyObject *resultobj;
6855 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6856 wxPoint2D result;
6857 PyObject * obj0 = 0 ;
6858 char *kwnames[] = {
6859 (char *) "self", NULL
6860 };
6861
6862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6864 if (SWIG_arg_fail(1)) SWIG_fail;
6865 {
6866 PyThreadState* __tstate = wxPyBeginAllowThreads();
6867 result = (arg1)->operator -();
6868
6869 wxPyEndAllowThreads(__tstate);
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 {
6873 wxPoint2D * resultptr;
6874 resultptr = new wxPoint2D((wxPoint2D &)(result));
6875 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6876 }
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6884 PyObject *resultobj;
6885 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6886 wxPoint2D *arg2 = 0 ;
6887 wxPoint2D *result;
6888 wxPoint2D temp2 ;
6889 PyObject * obj0 = 0 ;
6890 PyObject * obj1 = 0 ;
6891 char *kwnames[] = {
6892 (char *) "self",(char *) "pt", NULL
6893 };
6894
6895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6897 if (SWIG_arg_fail(1)) SWIG_fail;
6898 {
6899 arg2 = &temp2;
6900 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6901 }
6902 {
6903 PyThreadState* __tstate = wxPyBeginAllowThreads();
6904 {
6905 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6906 result = (wxPoint2D *) &_result_ref;
6907 }
6908
6909 wxPyEndAllowThreads(__tstate);
6910 if (PyErr_Occurred()) SWIG_fail;
6911 }
6912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6913 return resultobj;
6914 fail:
6915 return NULL;
6916 }
6917
6918
6919 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6920 PyObject *resultobj;
6921 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6922 wxPoint2D *arg2 = 0 ;
6923 wxPoint2D *result;
6924 wxPoint2D temp2 ;
6925 PyObject * obj0 = 0 ;
6926 PyObject * obj1 = 0 ;
6927 char *kwnames[] = {
6928 (char *) "self",(char *) "pt", NULL
6929 };
6930
6931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6933 if (SWIG_arg_fail(1)) SWIG_fail;
6934 {
6935 arg2 = &temp2;
6936 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6937 }
6938 {
6939 PyThreadState* __tstate = wxPyBeginAllowThreads();
6940 {
6941 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6942 result = (wxPoint2D *) &_result_ref;
6943 }
6944
6945 wxPyEndAllowThreads(__tstate);
6946 if (PyErr_Occurred()) SWIG_fail;
6947 }
6948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6949 return resultobj;
6950 fail:
6951 return NULL;
6952 }
6953
6954
6955 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6956 PyObject *resultobj;
6957 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6958 wxPoint2D *arg2 = 0 ;
6959 wxPoint2D *result;
6960 wxPoint2D temp2 ;
6961 PyObject * obj0 = 0 ;
6962 PyObject * obj1 = 0 ;
6963 char *kwnames[] = {
6964 (char *) "self",(char *) "pt", NULL
6965 };
6966
6967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6969 if (SWIG_arg_fail(1)) SWIG_fail;
6970 {
6971 arg2 = &temp2;
6972 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6973 }
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 {
6977 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6978 result = (wxPoint2D *) &_result_ref;
6979 }
6980
6981 wxPyEndAllowThreads(__tstate);
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6985 return resultobj;
6986 fail:
6987 return NULL;
6988 }
6989
6990
6991 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
6992 PyObject *resultobj;
6993 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6994 wxPoint2D *arg2 = 0 ;
6995 wxPoint2D *result;
6996 wxPoint2D temp2 ;
6997 PyObject * obj0 = 0 ;
6998 PyObject * obj1 = 0 ;
6999 char *kwnames[] = {
7000 (char *) "self",(char *) "pt", NULL
7001 };
7002
7003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7005 if (SWIG_arg_fail(1)) SWIG_fail;
7006 {
7007 arg2 = &temp2;
7008 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7009 }
7010 {
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 {
7013 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7014 result = (wxPoint2D *) &_result_ref;
7015 }
7016
7017 wxPyEndAllowThreads(__tstate);
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj;
7029 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7030 wxPoint2D *arg2 = 0 ;
7031 bool result;
7032 wxPoint2D temp2 ;
7033 PyObject * obj0 = 0 ;
7034 PyObject * obj1 = 0 ;
7035 char *kwnames[] = {
7036 (char *) "self",(char *) "pt", NULL
7037 };
7038
7039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7041 if (SWIG_arg_fail(1)) SWIG_fail;
7042 {
7043 arg2 = &temp2;
7044 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7045 }
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7049
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 {
7054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7055 }
7056 return resultobj;
7057 fail:
7058 return NULL;
7059 }
7060
7061
7062 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7063 PyObject *resultobj;
7064 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7065 wxPoint2D *arg2 = 0 ;
7066 bool result;
7067 wxPoint2D temp2 ;
7068 PyObject * obj0 = 0 ;
7069 PyObject * obj1 = 0 ;
7070 char *kwnames[] = {
7071 (char *) "self",(char *) "pt", NULL
7072 };
7073
7074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7076 if (SWIG_arg_fail(1)) SWIG_fail;
7077 {
7078 arg2 = &temp2;
7079 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7080 }
7081 {
7082 PyThreadState* __tstate = wxPyBeginAllowThreads();
7083 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7084
7085 wxPyEndAllowThreads(__tstate);
7086 if (PyErr_Occurred()) SWIG_fail;
7087 }
7088 {
7089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7090 }
7091 return resultobj;
7092 fail:
7093 return NULL;
7094 }
7095
7096
7097 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7098 PyObject *resultobj;
7099 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7100 double arg2 ;
7101 PyObject * obj0 = 0 ;
7102 PyObject * obj1 = 0 ;
7103 char *kwnames[] = {
7104 (char *) "self",(char *) "m_x", NULL
7105 };
7106
7107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7109 if (SWIG_arg_fail(1)) SWIG_fail;
7110 {
7111 arg2 = (double)(SWIG_As_double(obj1));
7112 if (SWIG_arg_fail(2)) SWIG_fail;
7113 }
7114 if (arg1) (arg1)->m_x = arg2;
7115
7116 Py_INCREF(Py_None); resultobj = Py_None;
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7124 PyObject *resultobj;
7125 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7126 double result;
7127 PyObject * obj0 = 0 ;
7128 char *kwnames[] = {
7129 (char *) "self", NULL
7130 };
7131
7132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7134 if (SWIG_arg_fail(1)) SWIG_fail;
7135 result = (double) ((arg1)->m_x);
7136
7137 {
7138 resultobj = SWIG_From_double((double)(result));
7139 }
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7147 PyObject *resultobj;
7148 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7149 double arg2 ;
7150 PyObject * obj0 = 0 ;
7151 PyObject * obj1 = 0 ;
7152 char *kwnames[] = {
7153 (char *) "self",(char *) "m_y", NULL
7154 };
7155
7156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7158 if (SWIG_arg_fail(1)) SWIG_fail;
7159 {
7160 arg2 = (double)(SWIG_As_double(obj1));
7161 if (SWIG_arg_fail(2)) SWIG_fail;
7162 }
7163 if (arg1) (arg1)->m_y = arg2;
7164
7165 Py_INCREF(Py_None); resultobj = Py_None;
7166 return resultobj;
7167 fail:
7168 return NULL;
7169 }
7170
7171
7172 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7173 PyObject *resultobj;
7174 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7175 double result;
7176 PyObject * obj0 = 0 ;
7177 char *kwnames[] = {
7178 (char *) "self", NULL
7179 };
7180
7181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7183 if (SWIG_arg_fail(1)) SWIG_fail;
7184 result = (double) ((arg1)->m_y);
7185
7186 {
7187 resultobj = SWIG_From_double((double)(result));
7188 }
7189 return resultobj;
7190 fail:
7191 return NULL;
7192 }
7193
7194
7195 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7196 PyObject *resultobj;
7197 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7198 double arg2 = (double) 0 ;
7199 double arg3 = (double) 0 ;
7200 PyObject * obj0 = 0 ;
7201 PyObject * obj1 = 0 ;
7202 PyObject * obj2 = 0 ;
7203 char *kwnames[] = {
7204 (char *) "self",(char *) "x",(char *) "y", NULL
7205 };
7206
7207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7209 if (SWIG_arg_fail(1)) SWIG_fail;
7210 if (obj1) {
7211 {
7212 arg2 = (double)(SWIG_As_double(obj1));
7213 if (SWIG_arg_fail(2)) SWIG_fail;
7214 }
7215 }
7216 if (obj2) {
7217 {
7218 arg3 = (double)(SWIG_As_double(obj2));
7219 if (SWIG_arg_fail(3)) SWIG_fail;
7220 }
7221 }
7222 {
7223 PyThreadState* __tstate = wxPyBeginAllowThreads();
7224 wxPoint2D_Set(arg1,arg2,arg3);
7225
7226 wxPyEndAllowThreads(__tstate);
7227 if (PyErr_Occurred()) SWIG_fail;
7228 }
7229 Py_INCREF(Py_None); resultobj = Py_None;
7230 return resultobj;
7231 fail:
7232 return NULL;
7233 }
7234
7235
7236 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7237 PyObject *resultobj;
7238 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7239 PyObject *result;
7240 PyObject * obj0 = 0 ;
7241 char *kwnames[] = {
7242 (char *) "self", NULL
7243 };
7244
7245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7247 if (SWIG_arg_fail(1)) SWIG_fail;
7248 {
7249 PyThreadState* __tstate = wxPyBeginAllowThreads();
7250 result = (PyObject *)wxPoint2D_Get(arg1);
7251
7252 wxPyEndAllowThreads(__tstate);
7253 if (PyErr_Occurred()) SWIG_fail;
7254 }
7255 resultobj = result;
7256 return resultobj;
7257 fail:
7258 return NULL;
7259 }
7260
7261
7262 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7263 PyObject *obj;
7264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7265 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7266 Py_INCREF(obj);
7267 return Py_BuildValue((char *)"");
7268 }
7269 static int _wrap_DefaultPosition_set(PyObject *) {
7270 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7271 return 1;
7272 }
7273
7274
7275 static PyObject *_wrap_DefaultPosition_get(void) {
7276 PyObject *pyobj;
7277
7278 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7279 return pyobj;
7280 }
7281
7282
7283 static int _wrap_DefaultSize_set(PyObject *) {
7284 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7285 return 1;
7286 }
7287
7288
7289 static PyObject *_wrap_DefaultSize_get(void) {
7290 PyObject *pyobj;
7291
7292 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7293 return pyobj;
7294 }
7295
7296
7297 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7298 PyObject *resultobj;
7299 PyObject *arg1 = (PyObject *) 0 ;
7300 wxPyInputStream *result;
7301 PyObject * obj0 = 0 ;
7302 char *kwnames[] = {
7303 (char *) "p", NULL
7304 };
7305
7306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7307 arg1 = obj0;
7308 {
7309 PyThreadState* __tstate = wxPyBeginAllowThreads();
7310 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7311
7312 wxPyEndAllowThreads(__tstate);
7313 if (PyErr_Occurred()) SWIG_fail;
7314 }
7315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7316 return resultobj;
7317 fail:
7318 return NULL;
7319 }
7320
7321
7322 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7323 PyObject *resultobj;
7324 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7325 PyObject * obj0 = 0 ;
7326 char *kwnames[] = {
7327 (char *) "self", NULL
7328 };
7329
7330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7332 if (SWIG_arg_fail(1)) SWIG_fail;
7333 {
7334 PyThreadState* __tstate = wxPyBeginAllowThreads();
7335 delete arg1;
7336
7337 wxPyEndAllowThreads(__tstate);
7338 if (PyErr_Occurred()) SWIG_fail;
7339 }
7340 Py_INCREF(Py_None); resultobj = Py_None;
7341 return resultobj;
7342 fail:
7343 return NULL;
7344 }
7345
7346
7347 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7348 PyObject *resultobj;
7349 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7350 PyObject * obj0 = 0 ;
7351 char *kwnames[] = {
7352 (char *) "self", NULL
7353 };
7354
7355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7357 if (SWIG_arg_fail(1)) SWIG_fail;
7358 {
7359 PyThreadState* __tstate = wxPyBeginAllowThreads();
7360 (arg1)->close();
7361
7362 wxPyEndAllowThreads(__tstate);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 Py_INCREF(Py_None); resultobj = Py_None;
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7373 PyObject *resultobj;
7374 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7375 PyObject * obj0 = 0 ;
7376 char *kwnames[] = {
7377 (char *) "self", NULL
7378 };
7379
7380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7382 if (SWIG_arg_fail(1)) SWIG_fail;
7383 {
7384 PyThreadState* __tstate = wxPyBeginAllowThreads();
7385 (arg1)->flush();
7386
7387 wxPyEndAllowThreads(__tstate);
7388 if (PyErr_Occurred()) SWIG_fail;
7389 }
7390 Py_INCREF(Py_None); resultobj = Py_None;
7391 return resultobj;
7392 fail:
7393 return NULL;
7394 }
7395
7396
7397 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7398 PyObject *resultobj;
7399 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7400 bool result;
7401 PyObject * obj0 = 0 ;
7402 char *kwnames[] = {
7403 (char *) "self", NULL
7404 };
7405
7406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7408 if (SWIG_arg_fail(1)) SWIG_fail;
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 result = (bool)(arg1)->eof();
7412
7413 wxPyEndAllowThreads(__tstate);
7414 if (PyErr_Occurred()) SWIG_fail;
7415 }
7416 {
7417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7418 }
7419 return resultobj;
7420 fail:
7421 return NULL;
7422 }
7423
7424
7425 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj;
7427 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7428 int arg2 = (int) -1 ;
7429 PyObject *result;
7430 PyObject * obj0 = 0 ;
7431 PyObject * obj1 = 0 ;
7432 char *kwnames[] = {
7433 (char *) "self",(char *) "size", NULL
7434 };
7435
7436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) 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 if (obj1) {
7440 {
7441 arg2 = (int)(SWIG_As_int(obj1));
7442 if (SWIG_arg_fail(2)) SWIG_fail;
7443 }
7444 }
7445 {
7446 PyThreadState* __tstate = wxPyBeginAllowThreads();
7447 result = (PyObject *)(arg1)->read(arg2);
7448
7449 wxPyEndAllowThreads(__tstate);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 resultobj = result;
7453 return resultobj;
7454 fail:
7455 return NULL;
7456 }
7457
7458
7459 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7460 PyObject *resultobj;
7461 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7462 int arg2 = (int) -1 ;
7463 PyObject *result;
7464 PyObject * obj0 = 0 ;
7465 PyObject * obj1 = 0 ;
7466 char *kwnames[] = {
7467 (char *) "self",(char *) "size", NULL
7468 };
7469
7470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7472 if (SWIG_arg_fail(1)) SWIG_fail;
7473 if (obj1) {
7474 {
7475 arg2 = (int)(SWIG_As_int(obj1));
7476 if (SWIG_arg_fail(2)) SWIG_fail;
7477 }
7478 }
7479 {
7480 PyThreadState* __tstate = wxPyBeginAllowThreads();
7481 result = (PyObject *)(arg1)->readline(arg2);
7482
7483 wxPyEndAllowThreads(__tstate);
7484 if (PyErr_Occurred()) SWIG_fail;
7485 }
7486 resultobj = result;
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj;
7495 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7496 int arg2 = (int) -1 ;
7497 PyObject *result;
7498 PyObject * obj0 = 0 ;
7499 PyObject * obj1 = 0 ;
7500 char *kwnames[] = {
7501 (char *) "self",(char *) "sizehint", NULL
7502 };
7503
7504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7506 if (SWIG_arg_fail(1)) SWIG_fail;
7507 if (obj1) {
7508 {
7509 arg2 = (int)(SWIG_As_int(obj1));
7510 if (SWIG_arg_fail(2)) SWIG_fail;
7511 }
7512 }
7513 {
7514 PyThreadState* __tstate = wxPyBeginAllowThreads();
7515 result = (PyObject *)(arg1)->readlines(arg2);
7516
7517 wxPyEndAllowThreads(__tstate);
7518 if (PyErr_Occurred()) SWIG_fail;
7519 }
7520 resultobj = result;
7521 return resultobj;
7522 fail:
7523 return NULL;
7524 }
7525
7526
7527 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7528 PyObject *resultobj;
7529 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7530 int arg2 ;
7531 int arg3 = (int) 0 ;
7532 PyObject * obj0 = 0 ;
7533 PyObject * obj1 = 0 ;
7534 PyObject * obj2 = 0 ;
7535 char *kwnames[] = {
7536 (char *) "self",(char *) "offset",(char *) "whence", NULL
7537 };
7538
7539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7541 if (SWIG_arg_fail(1)) SWIG_fail;
7542 {
7543 arg2 = (int)(SWIG_As_int(obj1));
7544 if (SWIG_arg_fail(2)) SWIG_fail;
7545 }
7546 if (obj2) {
7547 {
7548 arg3 = (int)(SWIG_As_int(obj2));
7549 if (SWIG_arg_fail(3)) SWIG_fail;
7550 }
7551 }
7552 {
7553 PyThreadState* __tstate = wxPyBeginAllowThreads();
7554 (arg1)->seek(arg2,arg3);
7555
7556 wxPyEndAllowThreads(__tstate);
7557 if (PyErr_Occurred()) SWIG_fail;
7558 }
7559 Py_INCREF(Py_None); resultobj = Py_None;
7560 return resultobj;
7561 fail:
7562 return NULL;
7563 }
7564
7565
7566 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7567 PyObject *resultobj;
7568 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7569 int result;
7570 PyObject * obj0 = 0 ;
7571 char *kwnames[] = {
7572 (char *) "self", NULL
7573 };
7574
7575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7577 if (SWIG_arg_fail(1)) SWIG_fail;
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 result = (int)(arg1)->tell();
7581
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 {
7586 resultobj = SWIG_From_int((int)(result));
7587 }
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7595 PyObject *resultobj;
7596 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7597 char result;
7598 PyObject * obj0 = 0 ;
7599 char *kwnames[] = {
7600 (char *) "self", NULL
7601 };
7602
7603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7605 if (SWIG_arg_fail(1)) SWIG_fail;
7606 {
7607 PyThreadState* __tstate = wxPyBeginAllowThreads();
7608 result = (char)(arg1)->Peek();
7609
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = SWIG_From_char((char)(result));
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj;
7624 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7625 char result;
7626 PyObject * obj0 = 0 ;
7627 char *kwnames[] = {
7628 (char *) "self", NULL
7629 };
7630
7631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",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 = (char)(arg1)->GetC();
7637
7638 wxPyEndAllowThreads(__tstate);
7639 if (PyErr_Occurred()) SWIG_fail;
7640 }
7641 {
7642 resultobj = SWIG_From_char((char)(result));
7643 }
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7651 PyObject *resultobj;
7652 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7653 size_t result;
7654 PyObject * obj0 = 0 ;
7655 char *kwnames[] = {
7656 (char *) "self", NULL
7657 };
7658
7659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",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 = (size_t)(arg1)->LastRead();
7665
7666 wxPyEndAllowThreads(__tstate);
7667 if (PyErr_Occurred()) SWIG_fail;
7668 }
7669 {
7670 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7671 }
7672 return resultobj;
7673 fail:
7674 return NULL;
7675 }
7676
7677
7678 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7679 PyObject *resultobj;
7680 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7681 bool result;
7682 PyObject * obj0 = 0 ;
7683 char *kwnames[] = {
7684 (char *) "self", NULL
7685 };
7686
7687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",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 = (bool)(arg1)->CanRead();
7693
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 {
7698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7699 }
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj;
7708 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7709 bool result;
7710 PyObject * obj0 = 0 ;
7711 char *kwnames[] = {
7712 (char *) "self", NULL
7713 };
7714
7715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",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 = (bool)(arg1)->Eof();
7721
7722 wxPyEndAllowThreads(__tstate);
7723 if (PyErr_Occurred()) SWIG_fail;
7724 }
7725 {
7726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7727 }
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7735 PyObject *resultobj;
7736 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7737 char arg2 ;
7738 bool result;
7739 PyObject * obj0 = 0 ;
7740 PyObject * obj1 = 0 ;
7741 char *kwnames[] = {
7742 (char *) "self",(char *) "c", NULL
7743 };
7744
7745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7747 if (SWIG_arg_fail(1)) SWIG_fail;
7748 {
7749 arg2 = (char)(SWIG_As_char(obj1));
7750 if (SWIG_arg_fail(2)) SWIG_fail;
7751 }
7752 {
7753 PyThreadState* __tstate = wxPyBeginAllowThreads();
7754 result = (bool)(arg1)->Ungetch(arg2);
7755
7756 wxPyEndAllowThreads(__tstate);
7757 if (PyErr_Occurred()) SWIG_fail;
7758 }
7759 {
7760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7761 }
7762 return resultobj;
7763 fail:
7764 return NULL;
7765 }
7766
7767
7768 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7769 PyObject *resultobj;
7770 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7771 long arg2 ;
7772 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7773 long result;
7774 PyObject * obj0 = 0 ;
7775 PyObject * obj1 = 0 ;
7776 PyObject * obj2 = 0 ;
7777 char *kwnames[] = {
7778 (char *) "self",(char *) "pos",(char *) "mode", NULL
7779 };
7780
7781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7783 if (SWIG_arg_fail(1)) SWIG_fail;
7784 {
7785 arg2 = (long)(SWIG_As_long(obj1));
7786 if (SWIG_arg_fail(2)) SWIG_fail;
7787 }
7788 if (obj2) {
7789 {
7790 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7791 if (SWIG_arg_fail(3)) SWIG_fail;
7792 }
7793 }
7794 {
7795 PyThreadState* __tstate = wxPyBeginAllowThreads();
7796 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7797
7798 wxPyEndAllowThreads(__tstate);
7799 if (PyErr_Occurred()) SWIG_fail;
7800 }
7801 {
7802 resultobj = SWIG_From_long((long)(result));
7803 }
7804 return resultobj;
7805 fail:
7806 return NULL;
7807 }
7808
7809
7810 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7811 PyObject *resultobj;
7812 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7813 long result;
7814 PyObject * obj0 = 0 ;
7815 char *kwnames[] = {
7816 (char *) "self", NULL
7817 };
7818
7819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7821 if (SWIG_arg_fail(1)) SWIG_fail;
7822 {
7823 PyThreadState* __tstate = wxPyBeginAllowThreads();
7824 result = (long)(arg1)->TellI();
7825
7826 wxPyEndAllowThreads(__tstate);
7827 if (PyErr_Occurred()) SWIG_fail;
7828 }
7829 {
7830 resultobj = SWIG_From_long((long)(result));
7831 }
7832 return resultobj;
7833 fail:
7834 return NULL;
7835 }
7836
7837
7838 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7839 PyObject *obj;
7840 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7841 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7842 Py_INCREF(obj);
7843 return Py_BuildValue((char *)"");
7844 }
7845 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7846 PyObject *resultobj;
7847 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7848 PyObject *arg2 = (PyObject *) 0 ;
7849 PyObject * obj0 = 0 ;
7850 PyObject * obj1 = 0 ;
7851 char *kwnames[] = {
7852 (char *) "self",(char *) "obj", NULL
7853 };
7854
7855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7857 if (SWIG_arg_fail(1)) SWIG_fail;
7858 arg2 = obj1;
7859 {
7860 PyThreadState* __tstate = wxPyBeginAllowThreads();
7861 wxOutputStream_write(arg1,arg2);
7862
7863 wxPyEndAllowThreads(__tstate);
7864 if (PyErr_Occurred()) SWIG_fail;
7865 }
7866 Py_INCREF(Py_None); resultobj = Py_None;
7867 return resultobj;
7868 fail:
7869 return NULL;
7870 }
7871
7872
7873 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7874 PyObject *obj;
7875 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7876 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7877 Py_INCREF(obj);
7878 return Py_BuildValue((char *)"");
7879 }
7880 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7881 PyObject *resultobj;
7882 wxInputStream *arg1 = (wxInputStream *) 0 ;
7883 wxString *arg2 = 0 ;
7884 wxString *arg3 = 0 ;
7885 wxString *arg4 = 0 ;
7886 wxDateTime arg5 ;
7887 wxFSFile *result;
7888 wxPyInputStream *temp1 ;
7889 bool created1 ;
7890 bool temp2 = false ;
7891 bool temp3 = false ;
7892 bool temp4 = false ;
7893 PyObject * obj0 = 0 ;
7894 PyObject * obj1 = 0 ;
7895 PyObject * obj2 = 0 ;
7896 PyObject * obj3 = 0 ;
7897 PyObject * obj4 = 0 ;
7898 char *kwnames[] = {
7899 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7900 };
7901
7902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7903 {
7904 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7905 arg1 = temp1->m_wxis;
7906 created1 = false;
7907 } else {
7908 PyErr_Clear(); // clear the failure of the wxPyConvert above
7909 arg1 = wxPyCBInputStream_create(obj0, false);
7910 if (arg1 == NULL) {
7911 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7912 SWIG_fail;
7913 }
7914 created1 = true;
7915 }
7916 }
7917 {
7918 arg2 = wxString_in_helper(obj1);
7919 if (arg2 == NULL) SWIG_fail;
7920 temp2 = true;
7921 }
7922 {
7923 arg3 = wxString_in_helper(obj2);
7924 if (arg3 == NULL) SWIG_fail;
7925 temp3 = true;
7926 }
7927 {
7928 arg4 = wxString_in_helper(obj3);
7929 if (arg4 == NULL) SWIG_fail;
7930 temp4 = true;
7931 }
7932 {
7933 wxDateTime * argp;
7934 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7935 if (SWIG_arg_fail(5)) SWIG_fail;
7936 if (argp == NULL) {
7937 SWIG_null_ref("wxDateTime");
7938 }
7939 if (SWIG_arg_fail(5)) SWIG_fail;
7940 arg5 = *argp;
7941 }
7942 {
7943 PyThreadState* __tstate = wxPyBeginAllowThreads();
7944 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7945
7946 wxPyEndAllowThreads(__tstate);
7947 if (PyErr_Occurred()) SWIG_fail;
7948 }
7949 {
7950 resultobj = wxPyMake_wxObject(result, 1);
7951 }
7952 {
7953 if (created1)
7954 delete arg1;
7955 }
7956 {
7957 if (temp2)
7958 delete arg2;
7959 }
7960 {
7961 if (temp3)
7962 delete arg3;
7963 }
7964 {
7965 if (temp4)
7966 delete arg4;
7967 }
7968 return resultobj;
7969 fail:
7970 {
7971 if (created1)
7972 delete arg1;
7973 }
7974 {
7975 if (temp2)
7976 delete arg2;
7977 }
7978 {
7979 if (temp3)
7980 delete arg3;
7981 }
7982 {
7983 if (temp4)
7984 delete arg4;
7985 }
7986 return NULL;
7987 }
7988
7989
7990 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7991 PyObject *resultobj;
7992 wxFSFile *arg1 = (wxFSFile *) 0 ;
7993 PyObject * obj0 = 0 ;
7994 char *kwnames[] = {
7995 (char *) "self", NULL
7996 };
7997
7998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
7999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8000 if (SWIG_arg_fail(1)) SWIG_fail;
8001 {
8002 PyThreadState* __tstate = wxPyBeginAllowThreads();
8003 delete arg1;
8004
8005 wxPyEndAllowThreads(__tstate);
8006 if (PyErr_Occurred()) SWIG_fail;
8007 }
8008 Py_INCREF(Py_None); resultobj = Py_None;
8009 return resultobj;
8010 fail:
8011 return NULL;
8012 }
8013
8014
8015 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8016 PyObject *resultobj;
8017 wxFSFile *arg1 = (wxFSFile *) 0 ;
8018 wxInputStream *result;
8019 PyObject * obj0 = 0 ;
8020 char *kwnames[] = {
8021 (char *) "self", NULL
8022 };
8023
8024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8026 if (SWIG_arg_fail(1)) SWIG_fail;
8027 {
8028 PyThreadState* __tstate = wxPyBeginAllowThreads();
8029 result = (wxInputStream *)(arg1)->GetStream();
8030
8031 wxPyEndAllowThreads(__tstate);
8032 if (PyErr_Occurred()) SWIG_fail;
8033 }
8034 {
8035 wxPyInputStream * _ptr = NULL;
8036
8037 if (result) {
8038 _ptr = new wxPyInputStream(result);
8039 }
8040 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8041 }
8042 return resultobj;
8043 fail:
8044 return NULL;
8045 }
8046
8047
8048 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8049 PyObject *resultobj;
8050 wxFSFile *arg1 = (wxFSFile *) 0 ;
8051 wxString *result;
8052 PyObject * obj0 = 0 ;
8053 char *kwnames[] = {
8054 (char *) "self", NULL
8055 };
8056
8057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8059 if (SWIG_arg_fail(1)) SWIG_fail;
8060 {
8061 PyThreadState* __tstate = wxPyBeginAllowThreads();
8062 {
8063 wxString const &_result_ref = (arg1)->GetMimeType();
8064 result = (wxString *) &_result_ref;
8065 }
8066
8067 wxPyEndAllowThreads(__tstate);
8068 if (PyErr_Occurred()) SWIG_fail;
8069 }
8070 {
8071 #if wxUSE_UNICODE
8072 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8073 #else
8074 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8075 #endif
8076 }
8077 return resultobj;
8078 fail:
8079 return NULL;
8080 }
8081
8082
8083 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8084 PyObject *resultobj;
8085 wxFSFile *arg1 = (wxFSFile *) 0 ;
8086 wxString *result;
8087 PyObject * obj0 = 0 ;
8088 char *kwnames[] = {
8089 (char *) "self", NULL
8090 };
8091
8092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8094 if (SWIG_arg_fail(1)) SWIG_fail;
8095 {
8096 PyThreadState* __tstate = wxPyBeginAllowThreads();
8097 {
8098 wxString const &_result_ref = (arg1)->GetLocation();
8099 result = (wxString *) &_result_ref;
8100 }
8101
8102 wxPyEndAllowThreads(__tstate);
8103 if (PyErr_Occurred()) SWIG_fail;
8104 }
8105 {
8106 #if wxUSE_UNICODE
8107 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8108 #else
8109 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8110 #endif
8111 }
8112 return resultobj;
8113 fail:
8114 return NULL;
8115 }
8116
8117
8118 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8119 PyObject *resultobj;
8120 wxFSFile *arg1 = (wxFSFile *) 0 ;
8121 wxString *result;
8122 PyObject * obj0 = 0 ;
8123 char *kwnames[] = {
8124 (char *) "self", NULL
8125 };
8126
8127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8129 if (SWIG_arg_fail(1)) SWIG_fail;
8130 {
8131 PyThreadState* __tstate = wxPyBeginAllowThreads();
8132 {
8133 wxString const &_result_ref = (arg1)->GetAnchor();
8134 result = (wxString *) &_result_ref;
8135 }
8136
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 {
8141 #if wxUSE_UNICODE
8142 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8143 #else
8144 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8145 #endif
8146 }
8147 return resultobj;
8148 fail:
8149 return NULL;
8150 }
8151
8152
8153 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8154 PyObject *resultobj;
8155 wxFSFile *arg1 = (wxFSFile *) 0 ;
8156 wxDateTime result;
8157 PyObject * obj0 = 0 ;
8158 char *kwnames[] = {
8159 (char *) "self", NULL
8160 };
8161
8162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8164 if (SWIG_arg_fail(1)) SWIG_fail;
8165 {
8166 PyThreadState* __tstate = wxPyBeginAllowThreads();
8167 result = (arg1)->GetModificationTime();
8168
8169 wxPyEndAllowThreads(__tstate);
8170 if (PyErr_Occurred()) SWIG_fail;
8171 }
8172 {
8173 wxDateTime * resultptr;
8174 resultptr = new wxDateTime((wxDateTime &)(result));
8175 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8176 }
8177 return resultobj;
8178 fail:
8179 return NULL;
8180 }
8181
8182
8183 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8184 PyObject *obj;
8185 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8186 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8187 Py_INCREF(obj);
8188 return Py_BuildValue((char *)"");
8189 }
8190 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8191 PyObject *obj;
8192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8193 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8194 Py_INCREF(obj);
8195 return Py_BuildValue((char *)"");
8196 }
8197 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8198 PyObject *resultobj;
8199 wxPyFileSystemHandler *result;
8200 char *kwnames[] = {
8201 NULL
8202 };
8203
8204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8208
8209 wxPyEndAllowThreads(__tstate);
8210 if (PyErr_Occurred()) SWIG_fail;
8211 }
8212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8220 PyObject *resultobj;
8221 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8222 PyObject *arg2 = (PyObject *) 0 ;
8223 PyObject *arg3 = (PyObject *) 0 ;
8224 PyObject * obj0 = 0 ;
8225 PyObject * obj1 = 0 ;
8226 PyObject * obj2 = 0 ;
8227 char *kwnames[] = {
8228 (char *) "self",(char *) "self",(char *) "_class", NULL
8229 };
8230
8231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8233 if (SWIG_arg_fail(1)) SWIG_fail;
8234 arg2 = obj1;
8235 arg3 = obj2;
8236 {
8237 PyThreadState* __tstate = wxPyBeginAllowThreads();
8238 (arg1)->_setCallbackInfo(arg2,arg3);
8239
8240 wxPyEndAllowThreads(__tstate);
8241 if (PyErr_Occurred()) SWIG_fail;
8242 }
8243 Py_INCREF(Py_None); resultobj = Py_None;
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8251 PyObject *resultobj;
8252 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8253 wxString *arg2 = 0 ;
8254 bool result;
8255 bool temp2 = false ;
8256 PyObject * obj0 = 0 ;
8257 PyObject * obj1 = 0 ;
8258 char *kwnames[] = {
8259 (char *) "self",(char *) "location", NULL
8260 };
8261
8262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8264 if (SWIG_arg_fail(1)) SWIG_fail;
8265 {
8266 arg2 = wxString_in_helper(obj1);
8267 if (arg2 == NULL) SWIG_fail;
8268 temp2 = true;
8269 }
8270 {
8271 PyThreadState* __tstate = wxPyBeginAllowThreads();
8272 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8273
8274 wxPyEndAllowThreads(__tstate);
8275 if (PyErr_Occurred()) SWIG_fail;
8276 }
8277 {
8278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8279 }
8280 {
8281 if (temp2)
8282 delete arg2;
8283 }
8284 return resultobj;
8285 fail:
8286 {
8287 if (temp2)
8288 delete arg2;
8289 }
8290 return NULL;
8291 }
8292
8293
8294 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8295 PyObject *resultobj;
8296 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8297 wxFileSystem *arg2 = 0 ;
8298 wxString *arg3 = 0 ;
8299 wxFSFile *result;
8300 bool temp3 = false ;
8301 PyObject * obj0 = 0 ;
8302 PyObject * obj1 = 0 ;
8303 PyObject * obj2 = 0 ;
8304 char *kwnames[] = {
8305 (char *) "self",(char *) "fs",(char *) "location", NULL
8306 };
8307
8308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8310 if (SWIG_arg_fail(1)) SWIG_fail;
8311 {
8312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8313 if (SWIG_arg_fail(2)) SWIG_fail;
8314 if (arg2 == NULL) {
8315 SWIG_null_ref("wxFileSystem");
8316 }
8317 if (SWIG_arg_fail(2)) SWIG_fail;
8318 }
8319 {
8320 arg3 = wxString_in_helper(obj2);
8321 if (arg3 == NULL) SWIG_fail;
8322 temp3 = true;
8323 }
8324 {
8325 PyThreadState* __tstate = wxPyBeginAllowThreads();
8326 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8327
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 {
8332 resultobj = wxPyMake_wxObject(result, 1);
8333 }
8334 {
8335 if (temp3)
8336 delete arg3;
8337 }
8338 return resultobj;
8339 fail:
8340 {
8341 if (temp3)
8342 delete arg3;
8343 }
8344 return NULL;
8345 }
8346
8347
8348 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8349 PyObject *resultobj;
8350 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8351 wxString *arg2 = 0 ;
8352 int arg3 = (int) 0 ;
8353 wxString result;
8354 bool temp2 = false ;
8355 PyObject * obj0 = 0 ;
8356 PyObject * obj1 = 0 ;
8357 PyObject * obj2 = 0 ;
8358 char *kwnames[] = {
8359 (char *) "self",(char *) "spec",(char *) "flags", NULL
8360 };
8361
8362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8364 if (SWIG_arg_fail(1)) SWIG_fail;
8365 {
8366 arg2 = wxString_in_helper(obj1);
8367 if (arg2 == NULL) SWIG_fail;
8368 temp2 = true;
8369 }
8370 if (obj2) {
8371 {
8372 arg3 = (int)(SWIG_As_int(obj2));
8373 if (SWIG_arg_fail(3)) SWIG_fail;
8374 }
8375 }
8376 {
8377 PyThreadState* __tstate = wxPyBeginAllowThreads();
8378 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8379
8380 wxPyEndAllowThreads(__tstate);
8381 if (PyErr_Occurred()) SWIG_fail;
8382 }
8383 {
8384 #if wxUSE_UNICODE
8385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8386 #else
8387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8388 #endif
8389 }
8390 {
8391 if (temp2)
8392 delete arg2;
8393 }
8394 return resultobj;
8395 fail:
8396 {
8397 if (temp2)
8398 delete arg2;
8399 }
8400 return NULL;
8401 }
8402
8403
8404 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8405 PyObject *resultobj;
8406 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8407 wxString result;
8408 PyObject * obj0 = 0 ;
8409 char *kwnames[] = {
8410 (char *) "self", NULL
8411 };
8412
8413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8415 if (SWIG_arg_fail(1)) SWIG_fail;
8416 {
8417 PyThreadState* __tstate = wxPyBeginAllowThreads();
8418 result = (arg1)->FindNext();
8419
8420 wxPyEndAllowThreads(__tstate);
8421 if (PyErr_Occurred()) SWIG_fail;
8422 }
8423 {
8424 #if wxUSE_UNICODE
8425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8426 #else
8427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8428 #endif
8429 }
8430 return resultobj;
8431 fail:
8432 return NULL;
8433 }
8434
8435
8436 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8437 PyObject *resultobj;
8438 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8439 wxString *arg2 = 0 ;
8440 wxString result;
8441 bool temp2 = false ;
8442 PyObject * obj0 = 0 ;
8443 PyObject * obj1 = 0 ;
8444 char *kwnames[] = {
8445 (char *) "self",(char *) "location", NULL
8446 };
8447
8448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8450 if (SWIG_arg_fail(1)) SWIG_fail;
8451 {
8452 arg2 = wxString_in_helper(obj1);
8453 if (arg2 == NULL) SWIG_fail;
8454 temp2 = true;
8455 }
8456 {
8457 PyThreadState* __tstate = wxPyBeginAllowThreads();
8458 result = (arg1)->GetProtocol((wxString const &)*arg2);
8459
8460 wxPyEndAllowThreads(__tstate);
8461 if (PyErr_Occurred()) SWIG_fail;
8462 }
8463 {
8464 #if wxUSE_UNICODE
8465 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8466 #else
8467 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8468 #endif
8469 }
8470 {
8471 if (temp2)
8472 delete arg2;
8473 }
8474 return resultobj;
8475 fail:
8476 {
8477 if (temp2)
8478 delete arg2;
8479 }
8480 return NULL;
8481 }
8482
8483
8484 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8485 PyObject *resultobj;
8486 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8487 wxString *arg2 = 0 ;
8488 wxString result;
8489 bool temp2 = false ;
8490 PyObject * obj0 = 0 ;
8491 PyObject * obj1 = 0 ;
8492 char *kwnames[] = {
8493 (char *) "self",(char *) "location", NULL
8494 };
8495
8496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8498 if (SWIG_arg_fail(1)) SWIG_fail;
8499 {
8500 arg2 = wxString_in_helper(obj1);
8501 if (arg2 == NULL) SWIG_fail;
8502 temp2 = true;
8503 }
8504 {
8505 PyThreadState* __tstate = wxPyBeginAllowThreads();
8506 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8507
8508 wxPyEndAllowThreads(__tstate);
8509 if (PyErr_Occurred()) SWIG_fail;
8510 }
8511 {
8512 #if wxUSE_UNICODE
8513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8514 #else
8515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8516 #endif
8517 }
8518 {
8519 if (temp2)
8520 delete arg2;
8521 }
8522 return resultobj;
8523 fail:
8524 {
8525 if (temp2)
8526 delete arg2;
8527 }
8528 return NULL;
8529 }
8530
8531
8532 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8533 PyObject *resultobj;
8534 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8535 wxString *arg2 = 0 ;
8536 wxString result;
8537 bool temp2 = false ;
8538 PyObject * obj0 = 0 ;
8539 PyObject * obj1 = 0 ;
8540 char *kwnames[] = {
8541 (char *) "self",(char *) "location", NULL
8542 };
8543
8544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8546 if (SWIG_arg_fail(1)) SWIG_fail;
8547 {
8548 arg2 = wxString_in_helper(obj1);
8549 if (arg2 == NULL) SWIG_fail;
8550 temp2 = true;
8551 }
8552 {
8553 PyThreadState* __tstate = wxPyBeginAllowThreads();
8554 result = (arg1)->GetAnchor((wxString const &)*arg2);
8555
8556 wxPyEndAllowThreads(__tstate);
8557 if (PyErr_Occurred()) SWIG_fail;
8558 }
8559 {
8560 #if wxUSE_UNICODE
8561 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8562 #else
8563 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8564 #endif
8565 }
8566 {
8567 if (temp2)
8568 delete arg2;
8569 }
8570 return resultobj;
8571 fail:
8572 {
8573 if (temp2)
8574 delete arg2;
8575 }
8576 return NULL;
8577 }
8578
8579
8580 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8581 PyObject *resultobj;
8582 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8583 wxString *arg2 = 0 ;
8584 wxString result;
8585 bool temp2 = false ;
8586 PyObject * obj0 = 0 ;
8587 PyObject * obj1 = 0 ;
8588 char *kwnames[] = {
8589 (char *) "self",(char *) "location", NULL
8590 };
8591
8592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8594 if (SWIG_arg_fail(1)) SWIG_fail;
8595 {
8596 arg2 = wxString_in_helper(obj1);
8597 if (arg2 == NULL) SWIG_fail;
8598 temp2 = true;
8599 }
8600 {
8601 PyThreadState* __tstate = wxPyBeginAllowThreads();
8602 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8603
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 {
8608 #if wxUSE_UNICODE
8609 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8610 #else
8611 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8612 #endif
8613 }
8614 {
8615 if (temp2)
8616 delete arg2;
8617 }
8618 return resultobj;
8619 fail:
8620 {
8621 if (temp2)
8622 delete arg2;
8623 }
8624 return NULL;
8625 }
8626
8627
8628 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8629 PyObject *resultobj;
8630 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8631 wxString *arg2 = 0 ;
8632 wxString result;
8633 bool temp2 = false ;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 char *kwnames[] = {
8637 (char *) "self",(char *) "location", NULL
8638 };
8639
8640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8642 if (SWIG_arg_fail(1)) SWIG_fail;
8643 {
8644 arg2 = wxString_in_helper(obj1);
8645 if (arg2 == NULL) SWIG_fail;
8646 temp2 = true;
8647 }
8648 {
8649 PyThreadState* __tstate = wxPyBeginAllowThreads();
8650 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8651
8652 wxPyEndAllowThreads(__tstate);
8653 if (PyErr_Occurred()) SWIG_fail;
8654 }
8655 {
8656 #if wxUSE_UNICODE
8657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8658 #else
8659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8660 #endif
8661 }
8662 {
8663 if (temp2)
8664 delete arg2;
8665 }
8666 return resultobj;
8667 fail:
8668 {
8669 if (temp2)
8670 delete arg2;
8671 }
8672 return NULL;
8673 }
8674
8675
8676 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8677 PyObject *obj;
8678 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8679 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8680 Py_INCREF(obj);
8681 return Py_BuildValue((char *)"");
8682 }
8683 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8684 PyObject *resultobj;
8685 wxFileSystem *result;
8686 char *kwnames[] = {
8687 NULL
8688 };
8689
8690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8691 {
8692 PyThreadState* __tstate = wxPyBeginAllowThreads();
8693 result = (wxFileSystem *)new wxFileSystem();
8694
8695 wxPyEndAllowThreads(__tstate);
8696 if (PyErr_Occurred()) SWIG_fail;
8697 }
8698 {
8699 resultobj = wxPyMake_wxObject(result, 1);
8700 }
8701 return resultobj;
8702 fail:
8703 return NULL;
8704 }
8705
8706
8707 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8708 PyObject *resultobj;
8709 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8710 PyObject * obj0 = 0 ;
8711 char *kwnames[] = {
8712 (char *) "self", NULL
8713 };
8714
8715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8717 if (SWIG_arg_fail(1)) SWIG_fail;
8718 {
8719 PyThreadState* __tstate = wxPyBeginAllowThreads();
8720 delete arg1;
8721
8722 wxPyEndAllowThreads(__tstate);
8723 if (PyErr_Occurred()) SWIG_fail;
8724 }
8725 Py_INCREF(Py_None); resultobj = Py_None;
8726 return resultobj;
8727 fail:
8728 return NULL;
8729 }
8730
8731
8732 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8733 PyObject *resultobj;
8734 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8735 wxString *arg2 = 0 ;
8736 bool arg3 = (bool) false ;
8737 bool temp2 = false ;
8738 PyObject * obj0 = 0 ;
8739 PyObject * obj1 = 0 ;
8740 PyObject * obj2 = 0 ;
8741 char *kwnames[] = {
8742 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8743 };
8744
8745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8747 if (SWIG_arg_fail(1)) SWIG_fail;
8748 {
8749 arg2 = wxString_in_helper(obj1);
8750 if (arg2 == NULL) SWIG_fail;
8751 temp2 = true;
8752 }
8753 if (obj2) {
8754 {
8755 arg3 = (bool)(SWIG_As_bool(obj2));
8756 if (SWIG_arg_fail(3)) SWIG_fail;
8757 }
8758 }
8759 {
8760 PyThreadState* __tstate = wxPyBeginAllowThreads();
8761 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8762
8763 wxPyEndAllowThreads(__tstate);
8764 if (PyErr_Occurred()) SWIG_fail;
8765 }
8766 Py_INCREF(Py_None); resultobj = Py_None;
8767 {
8768 if (temp2)
8769 delete arg2;
8770 }
8771 return resultobj;
8772 fail:
8773 {
8774 if (temp2)
8775 delete arg2;
8776 }
8777 return NULL;
8778 }
8779
8780
8781 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8782 PyObject *resultobj;
8783 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8784 wxString result;
8785 PyObject * obj0 = 0 ;
8786 char *kwnames[] = {
8787 (char *) "self", NULL
8788 };
8789
8790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
8795 result = (arg1)->GetPath();
8796
8797 wxPyEndAllowThreads(__tstate);
8798 if (PyErr_Occurred()) SWIG_fail;
8799 }
8800 {
8801 #if wxUSE_UNICODE
8802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8803 #else
8804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8805 #endif
8806 }
8807 return resultobj;
8808 fail:
8809 return NULL;
8810 }
8811
8812
8813 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8814 PyObject *resultobj;
8815 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8816 wxString *arg2 = 0 ;
8817 wxFSFile *result;
8818 bool temp2 = false ;
8819 PyObject * obj0 = 0 ;
8820 PyObject * obj1 = 0 ;
8821 char *kwnames[] = {
8822 (char *) "self",(char *) "location", NULL
8823 };
8824
8825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8827 if (SWIG_arg_fail(1)) SWIG_fail;
8828 {
8829 arg2 = wxString_in_helper(obj1);
8830 if (arg2 == NULL) SWIG_fail;
8831 temp2 = true;
8832 }
8833 {
8834 PyThreadState* __tstate = wxPyBeginAllowThreads();
8835 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8836
8837 wxPyEndAllowThreads(__tstate);
8838 if (PyErr_Occurred()) SWIG_fail;
8839 }
8840 {
8841 resultobj = wxPyMake_wxObject(result, 1);
8842 }
8843 {
8844 if (temp2)
8845 delete arg2;
8846 }
8847 return resultobj;
8848 fail:
8849 {
8850 if (temp2)
8851 delete arg2;
8852 }
8853 return NULL;
8854 }
8855
8856
8857 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8858 PyObject *resultobj;
8859 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8860 wxString *arg2 = 0 ;
8861 int arg3 = (int) 0 ;
8862 wxString result;
8863 bool temp2 = false ;
8864 PyObject * obj0 = 0 ;
8865 PyObject * obj1 = 0 ;
8866 PyObject * obj2 = 0 ;
8867 char *kwnames[] = {
8868 (char *) "self",(char *) "spec",(char *) "flags", NULL
8869 };
8870
8871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8873 if (SWIG_arg_fail(1)) SWIG_fail;
8874 {
8875 arg2 = wxString_in_helper(obj1);
8876 if (arg2 == NULL) SWIG_fail;
8877 temp2 = true;
8878 }
8879 if (obj2) {
8880 {
8881 arg3 = (int)(SWIG_As_int(obj2));
8882 if (SWIG_arg_fail(3)) SWIG_fail;
8883 }
8884 }
8885 {
8886 PyThreadState* __tstate = wxPyBeginAllowThreads();
8887 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8888
8889 wxPyEndAllowThreads(__tstate);
8890 if (PyErr_Occurred()) SWIG_fail;
8891 }
8892 {
8893 #if wxUSE_UNICODE
8894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8895 #else
8896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8897 #endif
8898 }
8899 {
8900 if (temp2)
8901 delete arg2;
8902 }
8903 return resultobj;
8904 fail:
8905 {
8906 if (temp2)
8907 delete arg2;
8908 }
8909 return NULL;
8910 }
8911
8912
8913 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8914 PyObject *resultobj;
8915 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8916 wxString result;
8917 PyObject * obj0 = 0 ;
8918 char *kwnames[] = {
8919 (char *) "self", NULL
8920 };
8921
8922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8924 if (SWIG_arg_fail(1)) SWIG_fail;
8925 {
8926 PyThreadState* __tstate = wxPyBeginAllowThreads();
8927 result = (arg1)->FindNext();
8928
8929 wxPyEndAllowThreads(__tstate);
8930 if (PyErr_Occurred()) SWIG_fail;
8931 }
8932 {
8933 #if wxUSE_UNICODE
8934 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8935 #else
8936 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8937 #endif
8938 }
8939 return resultobj;
8940 fail:
8941 return NULL;
8942 }
8943
8944
8945 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8946 PyObject *resultobj;
8947 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8948 PyObject * obj0 = 0 ;
8949 char *kwnames[] = {
8950 (char *) "handler", NULL
8951 };
8952
8953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8955 if (SWIG_arg_fail(1)) SWIG_fail;
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 wxFileSystem::AddHandler(arg1);
8959
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 Py_INCREF(Py_None); resultobj = Py_None;
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8971 PyObject *resultobj;
8972 char *kwnames[] = {
8973 NULL
8974 };
8975
8976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8977 {
8978 PyThreadState* __tstate = wxPyBeginAllowThreads();
8979 wxFileSystem::CleanUpHandlers();
8980
8981 wxPyEndAllowThreads(__tstate);
8982 if (PyErr_Occurred()) SWIG_fail;
8983 }
8984 Py_INCREF(Py_None); resultobj = Py_None;
8985 return resultobj;
8986 fail:
8987 return NULL;
8988 }
8989
8990
8991 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
8992 PyObject *resultobj;
8993 wxString *arg1 = 0 ;
8994 wxString result;
8995 bool temp1 = false ;
8996 PyObject * obj0 = 0 ;
8997 char *kwnames[] = {
8998 (char *) "filename", NULL
8999 };
9000
9001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9002 {
9003 arg1 = wxString_in_helper(obj0);
9004 if (arg1 == NULL) SWIG_fail;
9005 temp1 = true;
9006 }
9007 {
9008 PyThreadState* __tstate = wxPyBeginAllowThreads();
9009 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9010
9011 wxPyEndAllowThreads(__tstate);
9012 if (PyErr_Occurred()) SWIG_fail;
9013 }
9014 {
9015 #if wxUSE_UNICODE
9016 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9017 #else
9018 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9019 #endif
9020 }
9021 {
9022 if (temp1)
9023 delete arg1;
9024 }
9025 return resultobj;
9026 fail:
9027 {
9028 if (temp1)
9029 delete arg1;
9030 }
9031 return NULL;
9032 }
9033
9034
9035 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9036 PyObject *resultobj;
9037 wxString *arg1 = 0 ;
9038 wxString result;
9039 bool temp1 = false ;
9040 PyObject * obj0 = 0 ;
9041 char *kwnames[] = {
9042 (char *) "url", NULL
9043 };
9044
9045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9046 {
9047 arg1 = wxString_in_helper(obj0);
9048 if (arg1 == NULL) SWIG_fail;
9049 temp1 = true;
9050 }
9051 {
9052 PyThreadState* __tstate = wxPyBeginAllowThreads();
9053 result = FileSystem_URLToFileName((wxString const &)*arg1);
9054
9055 wxPyEndAllowThreads(__tstate);
9056 if (PyErr_Occurred()) SWIG_fail;
9057 }
9058 {
9059 #if wxUSE_UNICODE
9060 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9061 #else
9062 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9063 #endif
9064 }
9065 {
9066 if (temp1)
9067 delete arg1;
9068 }
9069 return resultobj;
9070 fail:
9071 {
9072 if (temp1)
9073 delete arg1;
9074 }
9075 return NULL;
9076 }
9077
9078
9079 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9080 PyObject *obj;
9081 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9082 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9083 Py_INCREF(obj);
9084 return Py_BuildValue((char *)"");
9085 }
9086 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9087 PyObject *resultobj;
9088 wxInternetFSHandler *result;
9089 char *kwnames[] = {
9090 NULL
9091 };
9092
9093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9094 {
9095 PyThreadState* __tstate = wxPyBeginAllowThreads();
9096 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9097
9098 wxPyEndAllowThreads(__tstate);
9099 if (PyErr_Occurred()) SWIG_fail;
9100 }
9101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9102 return resultobj;
9103 fail:
9104 return NULL;
9105 }
9106
9107
9108 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9109 PyObject *resultobj;
9110 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9111 wxString *arg2 = 0 ;
9112 bool result;
9113 bool temp2 = false ;
9114 PyObject * obj0 = 0 ;
9115 PyObject * obj1 = 0 ;
9116 char *kwnames[] = {
9117 (char *) "self",(char *) "location", NULL
9118 };
9119
9120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9122 if (SWIG_arg_fail(1)) SWIG_fail;
9123 {
9124 arg2 = wxString_in_helper(obj1);
9125 if (arg2 == NULL) SWIG_fail;
9126 temp2 = true;
9127 }
9128 {
9129 PyThreadState* __tstate = wxPyBeginAllowThreads();
9130 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9131
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 {
9136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9137 }
9138 {
9139 if (temp2)
9140 delete arg2;
9141 }
9142 return resultobj;
9143 fail:
9144 {
9145 if (temp2)
9146 delete arg2;
9147 }
9148 return NULL;
9149 }
9150
9151
9152 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9153 PyObject *resultobj;
9154 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9155 wxFileSystem *arg2 = 0 ;
9156 wxString *arg3 = 0 ;
9157 wxFSFile *result;
9158 bool temp3 = false ;
9159 PyObject * obj0 = 0 ;
9160 PyObject * obj1 = 0 ;
9161 PyObject * obj2 = 0 ;
9162 char *kwnames[] = {
9163 (char *) "self",(char *) "fs",(char *) "location", NULL
9164 };
9165
9166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9168 if (SWIG_arg_fail(1)) SWIG_fail;
9169 {
9170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9171 if (SWIG_arg_fail(2)) SWIG_fail;
9172 if (arg2 == NULL) {
9173 SWIG_null_ref("wxFileSystem");
9174 }
9175 if (SWIG_arg_fail(2)) SWIG_fail;
9176 }
9177 {
9178 arg3 = wxString_in_helper(obj2);
9179 if (arg3 == NULL) SWIG_fail;
9180 temp3 = true;
9181 }
9182 {
9183 PyThreadState* __tstate = wxPyBeginAllowThreads();
9184 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9185
9186 wxPyEndAllowThreads(__tstate);
9187 if (PyErr_Occurred()) SWIG_fail;
9188 }
9189 {
9190 resultobj = wxPyMake_wxObject(result, 1);
9191 }
9192 {
9193 if (temp3)
9194 delete arg3;
9195 }
9196 return resultobj;
9197 fail:
9198 {
9199 if (temp3)
9200 delete arg3;
9201 }
9202 return NULL;
9203 }
9204
9205
9206 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9207 PyObject *obj;
9208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9209 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9210 Py_INCREF(obj);
9211 return Py_BuildValue((char *)"");
9212 }
9213 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9214 PyObject *resultobj;
9215 wxZipFSHandler *result;
9216 char *kwnames[] = {
9217 NULL
9218 };
9219
9220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9221 {
9222 PyThreadState* __tstate = wxPyBeginAllowThreads();
9223 result = (wxZipFSHandler *)new wxZipFSHandler();
9224
9225 wxPyEndAllowThreads(__tstate);
9226 if (PyErr_Occurred()) SWIG_fail;
9227 }
9228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9229 return resultobj;
9230 fail:
9231 return NULL;
9232 }
9233
9234
9235 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9236 PyObject *resultobj;
9237 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9238 wxString *arg2 = 0 ;
9239 bool result;
9240 bool temp2 = false ;
9241 PyObject * obj0 = 0 ;
9242 PyObject * obj1 = 0 ;
9243 char *kwnames[] = {
9244 (char *) "self",(char *) "location", NULL
9245 };
9246
9247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9249 if (SWIG_arg_fail(1)) SWIG_fail;
9250 {
9251 arg2 = wxString_in_helper(obj1);
9252 if (arg2 == NULL) SWIG_fail;
9253 temp2 = true;
9254 }
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9258
9259 wxPyEndAllowThreads(__tstate);
9260 if (PyErr_Occurred()) SWIG_fail;
9261 }
9262 {
9263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9264 }
9265 {
9266 if (temp2)
9267 delete arg2;
9268 }
9269 return resultobj;
9270 fail:
9271 {
9272 if (temp2)
9273 delete arg2;
9274 }
9275 return NULL;
9276 }
9277
9278
9279 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9280 PyObject *resultobj;
9281 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9282 wxFileSystem *arg2 = 0 ;
9283 wxString *arg3 = 0 ;
9284 wxFSFile *result;
9285 bool temp3 = false ;
9286 PyObject * obj0 = 0 ;
9287 PyObject * obj1 = 0 ;
9288 PyObject * obj2 = 0 ;
9289 char *kwnames[] = {
9290 (char *) "self",(char *) "fs",(char *) "location", NULL
9291 };
9292
9293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9295 if (SWIG_arg_fail(1)) SWIG_fail;
9296 {
9297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9298 if (SWIG_arg_fail(2)) SWIG_fail;
9299 if (arg2 == NULL) {
9300 SWIG_null_ref("wxFileSystem");
9301 }
9302 if (SWIG_arg_fail(2)) SWIG_fail;
9303 }
9304 {
9305 arg3 = wxString_in_helper(obj2);
9306 if (arg3 == NULL) SWIG_fail;
9307 temp3 = true;
9308 }
9309 {
9310 PyThreadState* __tstate = wxPyBeginAllowThreads();
9311 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9312
9313 wxPyEndAllowThreads(__tstate);
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 {
9317 resultobj = wxPyMake_wxObject(result, 1);
9318 }
9319 {
9320 if (temp3)
9321 delete arg3;
9322 }
9323 return resultobj;
9324 fail:
9325 {
9326 if (temp3)
9327 delete arg3;
9328 }
9329 return NULL;
9330 }
9331
9332
9333 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9334 PyObject *resultobj;
9335 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9336 wxString *arg2 = 0 ;
9337 int arg3 = (int) 0 ;
9338 wxString result;
9339 bool temp2 = false ;
9340 PyObject * obj0 = 0 ;
9341 PyObject * obj1 = 0 ;
9342 PyObject * obj2 = 0 ;
9343 char *kwnames[] = {
9344 (char *) "self",(char *) "spec",(char *) "flags", NULL
9345 };
9346
9347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9349 if (SWIG_arg_fail(1)) SWIG_fail;
9350 {
9351 arg2 = wxString_in_helper(obj1);
9352 if (arg2 == NULL) SWIG_fail;
9353 temp2 = true;
9354 }
9355 if (obj2) {
9356 {
9357 arg3 = (int)(SWIG_As_int(obj2));
9358 if (SWIG_arg_fail(3)) SWIG_fail;
9359 }
9360 }
9361 {
9362 PyThreadState* __tstate = wxPyBeginAllowThreads();
9363 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9364
9365 wxPyEndAllowThreads(__tstate);
9366 if (PyErr_Occurred()) SWIG_fail;
9367 }
9368 {
9369 #if wxUSE_UNICODE
9370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9371 #else
9372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9373 #endif
9374 }
9375 {
9376 if (temp2)
9377 delete arg2;
9378 }
9379 return resultobj;
9380 fail:
9381 {
9382 if (temp2)
9383 delete arg2;
9384 }
9385 return NULL;
9386 }
9387
9388
9389 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9390 PyObject *resultobj;
9391 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9392 wxString result;
9393 PyObject * obj0 = 0 ;
9394 char *kwnames[] = {
9395 (char *) "self", NULL
9396 };
9397
9398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9400 if (SWIG_arg_fail(1)) SWIG_fail;
9401 {
9402 PyThreadState* __tstate = wxPyBeginAllowThreads();
9403 result = (arg1)->FindNext();
9404
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 {
9409 #if wxUSE_UNICODE
9410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9411 #else
9412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9413 #endif
9414 }
9415 return resultobj;
9416 fail:
9417 return NULL;
9418 }
9419
9420
9421 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9422 PyObject *obj;
9423 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9424 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9425 Py_INCREF(obj);
9426 return Py_BuildValue((char *)"");
9427 }
9428 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9429 PyObject *resultobj;
9430 wxString *arg1 = 0 ;
9431 wxImage *arg2 = 0 ;
9432 long arg3 ;
9433 bool temp1 = false ;
9434 PyObject * obj0 = 0 ;
9435 PyObject * obj1 = 0 ;
9436 PyObject * obj2 = 0 ;
9437 char *kwnames[] = {
9438 (char *) "filename",(char *) "image",(char *) "type", NULL
9439 };
9440
9441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9442 {
9443 arg1 = wxString_in_helper(obj0);
9444 if (arg1 == NULL) SWIG_fail;
9445 temp1 = true;
9446 }
9447 {
9448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9449 if (SWIG_arg_fail(2)) SWIG_fail;
9450 if (arg2 == NULL) {
9451 SWIG_null_ref("wxImage");
9452 }
9453 if (SWIG_arg_fail(2)) SWIG_fail;
9454 }
9455 {
9456 arg3 = (long)(SWIG_As_long(obj2));
9457 if (SWIG_arg_fail(3)) SWIG_fail;
9458 }
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9462
9463 wxPyEndAllowThreads(__tstate);
9464 if (PyErr_Occurred()) SWIG_fail;
9465 }
9466 Py_INCREF(Py_None); resultobj = Py_None;
9467 {
9468 if (temp1)
9469 delete arg1;
9470 }
9471 return resultobj;
9472 fail:
9473 {
9474 if (temp1)
9475 delete arg1;
9476 }
9477 return NULL;
9478 }
9479
9480
9481 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9482 PyObject *resultobj;
9483 wxString *arg1 = 0 ;
9484 wxBitmap *arg2 = 0 ;
9485 long arg3 ;
9486 bool temp1 = false ;
9487 PyObject * obj0 = 0 ;
9488 PyObject * obj1 = 0 ;
9489 PyObject * obj2 = 0 ;
9490 char *kwnames[] = {
9491 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9492 };
9493
9494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9495 {
9496 arg1 = wxString_in_helper(obj0);
9497 if (arg1 == NULL) SWIG_fail;
9498 temp1 = true;
9499 }
9500 {
9501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9502 if (SWIG_arg_fail(2)) SWIG_fail;
9503 if (arg2 == NULL) {
9504 SWIG_null_ref("wxBitmap");
9505 }
9506 if (SWIG_arg_fail(2)) SWIG_fail;
9507 }
9508 {
9509 arg3 = (long)(SWIG_As_long(obj2));
9510 if (SWIG_arg_fail(3)) SWIG_fail;
9511 }
9512 {
9513 PyThreadState* __tstate = wxPyBeginAllowThreads();
9514 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9515
9516 wxPyEndAllowThreads(__tstate);
9517 if (PyErr_Occurred()) SWIG_fail;
9518 }
9519 Py_INCREF(Py_None); resultobj = Py_None;
9520 {
9521 if (temp1)
9522 delete arg1;
9523 }
9524 return resultobj;
9525 fail:
9526 {
9527 if (temp1)
9528 delete arg1;
9529 }
9530 return NULL;
9531 }
9532
9533
9534 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9535 PyObject *resultobj;
9536 wxString *arg1 = 0 ;
9537 PyObject *arg2 = (PyObject *) 0 ;
9538 bool temp1 = false ;
9539 PyObject * obj0 = 0 ;
9540 PyObject * obj1 = 0 ;
9541 char *kwnames[] = {
9542 (char *) "filename",(char *) "data", NULL
9543 };
9544
9545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9546 {
9547 arg1 = wxString_in_helper(obj0);
9548 if (arg1 == NULL) SWIG_fail;
9549 temp1 = true;
9550 }
9551 arg2 = obj1;
9552 {
9553 PyThreadState* __tstate = wxPyBeginAllowThreads();
9554 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9555
9556 wxPyEndAllowThreads(__tstate);
9557 if (PyErr_Occurred()) SWIG_fail;
9558 }
9559 Py_INCREF(Py_None); resultobj = Py_None;
9560 {
9561 if (temp1)
9562 delete arg1;
9563 }
9564 return resultobj;
9565 fail:
9566 {
9567 if (temp1)
9568 delete arg1;
9569 }
9570 return NULL;
9571 }
9572
9573
9574 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9575 PyObject *resultobj;
9576 wxMemoryFSHandler *result;
9577 char *kwnames[] = {
9578 NULL
9579 };
9580
9581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9585
9586 wxPyEndAllowThreads(__tstate);
9587 if (PyErr_Occurred()) SWIG_fail;
9588 }
9589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9590 return resultobj;
9591 fail:
9592 return NULL;
9593 }
9594
9595
9596 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9597 PyObject *resultobj;
9598 wxString *arg1 = 0 ;
9599 bool temp1 = false ;
9600 PyObject * obj0 = 0 ;
9601 char *kwnames[] = {
9602 (char *) "filename", NULL
9603 };
9604
9605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9606 {
9607 arg1 = wxString_in_helper(obj0);
9608 if (arg1 == NULL) SWIG_fail;
9609 temp1 = true;
9610 }
9611 {
9612 PyThreadState* __tstate = wxPyBeginAllowThreads();
9613 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9614
9615 wxPyEndAllowThreads(__tstate);
9616 if (PyErr_Occurred()) SWIG_fail;
9617 }
9618 Py_INCREF(Py_None); resultobj = Py_None;
9619 {
9620 if (temp1)
9621 delete arg1;
9622 }
9623 return resultobj;
9624 fail:
9625 {
9626 if (temp1)
9627 delete arg1;
9628 }
9629 return NULL;
9630 }
9631
9632
9633 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9634 PyObject *resultobj;
9635 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9636 wxString *arg2 = 0 ;
9637 bool result;
9638 bool temp2 = false ;
9639 PyObject * obj0 = 0 ;
9640 PyObject * obj1 = 0 ;
9641 char *kwnames[] = {
9642 (char *) "self",(char *) "location", NULL
9643 };
9644
9645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9647 if (SWIG_arg_fail(1)) SWIG_fail;
9648 {
9649 arg2 = wxString_in_helper(obj1);
9650 if (arg2 == NULL) SWIG_fail;
9651 temp2 = true;
9652 }
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9656
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 {
9661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9662 }
9663 {
9664 if (temp2)
9665 delete arg2;
9666 }
9667 return resultobj;
9668 fail:
9669 {
9670 if (temp2)
9671 delete arg2;
9672 }
9673 return NULL;
9674 }
9675
9676
9677 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9678 PyObject *resultobj;
9679 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9680 wxFileSystem *arg2 = 0 ;
9681 wxString *arg3 = 0 ;
9682 wxFSFile *result;
9683 bool temp3 = false ;
9684 PyObject * obj0 = 0 ;
9685 PyObject * obj1 = 0 ;
9686 PyObject * obj2 = 0 ;
9687 char *kwnames[] = {
9688 (char *) "self",(char *) "fs",(char *) "location", NULL
9689 };
9690
9691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9693 if (SWIG_arg_fail(1)) SWIG_fail;
9694 {
9695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9696 if (SWIG_arg_fail(2)) SWIG_fail;
9697 if (arg2 == NULL) {
9698 SWIG_null_ref("wxFileSystem");
9699 }
9700 if (SWIG_arg_fail(2)) SWIG_fail;
9701 }
9702 {
9703 arg3 = wxString_in_helper(obj2);
9704 if (arg3 == NULL) SWIG_fail;
9705 temp3 = true;
9706 }
9707 {
9708 PyThreadState* __tstate = wxPyBeginAllowThreads();
9709 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9710
9711 wxPyEndAllowThreads(__tstate);
9712 if (PyErr_Occurred()) SWIG_fail;
9713 }
9714 {
9715 resultobj = wxPyMake_wxObject(result, 1);
9716 }
9717 {
9718 if (temp3)
9719 delete arg3;
9720 }
9721 return resultobj;
9722 fail:
9723 {
9724 if (temp3)
9725 delete arg3;
9726 }
9727 return NULL;
9728 }
9729
9730
9731 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9732 PyObject *resultobj;
9733 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9734 wxString *arg2 = 0 ;
9735 int arg3 = (int) 0 ;
9736 wxString result;
9737 bool temp2 = false ;
9738 PyObject * obj0 = 0 ;
9739 PyObject * obj1 = 0 ;
9740 PyObject * obj2 = 0 ;
9741 char *kwnames[] = {
9742 (char *) "self",(char *) "spec",(char *) "flags", NULL
9743 };
9744
9745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9747 if (SWIG_arg_fail(1)) SWIG_fail;
9748 {
9749 arg2 = wxString_in_helper(obj1);
9750 if (arg2 == NULL) SWIG_fail;
9751 temp2 = true;
9752 }
9753 if (obj2) {
9754 {
9755 arg3 = (int)(SWIG_As_int(obj2));
9756 if (SWIG_arg_fail(3)) SWIG_fail;
9757 }
9758 }
9759 {
9760 PyThreadState* __tstate = wxPyBeginAllowThreads();
9761 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9762
9763 wxPyEndAllowThreads(__tstate);
9764 if (PyErr_Occurred()) SWIG_fail;
9765 }
9766 {
9767 #if wxUSE_UNICODE
9768 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9769 #else
9770 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9771 #endif
9772 }
9773 {
9774 if (temp2)
9775 delete arg2;
9776 }
9777 return resultobj;
9778 fail:
9779 {
9780 if (temp2)
9781 delete arg2;
9782 }
9783 return NULL;
9784 }
9785
9786
9787 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9788 PyObject *resultobj;
9789 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9790 wxString result;
9791 PyObject * obj0 = 0 ;
9792 char *kwnames[] = {
9793 (char *) "self", NULL
9794 };
9795
9796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9798 if (SWIG_arg_fail(1)) SWIG_fail;
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 result = (arg1)->FindNext();
9802
9803 wxPyEndAllowThreads(__tstate);
9804 if (PyErr_Occurred()) SWIG_fail;
9805 }
9806 {
9807 #if wxUSE_UNICODE
9808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9809 #else
9810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9811 #endif
9812 }
9813 return resultobj;
9814 fail:
9815 return NULL;
9816 }
9817
9818
9819 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9820 PyObject *obj;
9821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9822 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9823 Py_INCREF(obj);
9824 return Py_BuildValue((char *)"");
9825 }
9826 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9827 PyObject *resultobj;
9828 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9829 wxString result;
9830 PyObject * obj0 = 0 ;
9831 char *kwnames[] = {
9832 (char *) "self", NULL
9833 };
9834
9835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9837 if (SWIG_arg_fail(1)) SWIG_fail;
9838 {
9839 PyThreadState* __tstate = wxPyBeginAllowThreads();
9840 result = (arg1)->GetName();
9841
9842 wxPyEndAllowThreads(__tstate);
9843 if (PyErr_Occurred()) SWIG_fail;
9844 }
9845 {
9846 #if wxUSE_UNICODE
9847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9848 #else
9849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9850 #endif
9851 }
9852 return resultobj;
9853 fail:
9854 return NULL;
9855 }
9856
9857
9858 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9859 PyObject *resultobj;
9860 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9861 wxString result;
9862 PyObject * obj0 = 0 ;
9863 char *kwnames[] = {
9864 (char *) "self", NULL
9865 };
9866
9867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9869 if (SWIG_arg_fail(1)) SWIG_fail;
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 result = (arg1)->GetExtension();
9873
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 {
9878 #if wxUSE_UNICODE
9879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9880 #else
9881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9882 #endif
9883 }
9884 return resultobj;
9885 fail:
9886 return NULL;
9887 }
9888
9889
9890 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9891 PyObject *resultobj;
9892 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9893 long result;
9894 PyObject * obj0 = 0 ;
9895 char *kwnames[] = {
9896 (char *) "self", NULL
9897 };
9898
9899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9901 if (SWIG_arg_fail(1)) SWIG_fail;
9902 {
9903 PyThreadState* __tstate = wxPyBeginAllowThreads();
9904 result = (long)(arg1)->GetType();
9905
9906 wxPyEndAllowThreads(__tstate);
9907 if (PyErr_Occurred()) SWIG_fail;
9908 }
9909 {
9910 resultobj = SWIG_From_long((long)(result));
9911 }
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9919 PyObject *resultobj;
9920 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9921 wxString result;
9922 PyObject * obj0 = 0 ;
9923 char *kwnames[] = {
9924 (char *) "self", NULL
9925 };
9926
9927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9929 if (SWIG_arg_fail(1)) SWIG_fail;
9930 {
9931 PyThreadState* __tstate = wxPyBeginAllowThreads();
9932 result = (arg1)->GetMimeType();
9933
9934 wxPyEndAllowThreads(__tstate);
9935 if (PyErr_Occurred()) SWIG_fail;
9936 }
9937 {
9938 #if wxUSE_UNICODE
9939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9940 #else
9941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9942 #endif
9943 }
9944 return resultobj;
9945 fail:
9946 return NULL;
9947 }
9948
9949
9950 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9951 PyObject *resultobj;
9952 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9953 wxString *arg2 = 0 ;
9954 bool result;
9955 bool temp2 = false ;
9956 PyObject * obj0 = 0 ;
9957 PyObject * obj1 = 0 ;
9958 char *kwnames[] = {
9959 (char *) "self",(char *) "name", NULL
9960 };
9961
9962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9964 if (SWIG_arg_fail(1)) SWIG_fail;
9965 {
9966 arg2 = wxString_in_helper(obj1);
9967 if (arg2 == NULL) SWIG_fail;
9968 temp2 = true;
9969 }
9970 {
9971 PyThreadState* __tstate = wxPyBeginAllowThreads();
9972 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9973
9974 wxPyEndAllowThreads(__tstate);
9975 if (PyErr_Occurred()) SWIG_fail;
9976 }
9977 {
9978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9979 }
9980 {
9981 if (temp2)
9982 delete arg2;
9983 }
9984 return resultobj;
9985 fail:
9986 {
9987 if (temp2)
9988 delete arg2;
9989 }
9990 return NULL;
9991 }
9992
9993
9994 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
9995 PyObject *resultobj;
9996 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9997 wxString *arg2 = 0 ;
9998 bool temp2 = false ;
9999 PyObject * obj0 = 0 ;
10000 PyObject * obj1 = 0 ;
10001 char *kwnames[] = {
10002 (char *) "self",(char *) "name", NULL
10003 };
10004
10005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10007 if (SWIG_arg_fail(1)) SWIG_fail;
10008 {
10009 arg2 = wxString_in_helper(obj1);
10010 if (arg2 == NULL) SWIG_fail;
10011 temp2 = true;
10012 }
10013 {
10014 PyThreadState* __tstate = wxPyBeginAllowThreads();
10015 (arg1)->SetName((wxString const &)*arg2);
10016
10017 wxPyEndAllowThreads(__tstate);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 Py_INCREF(Py_None); resultobj = Py_None;
10021 {
10022 if (temp2)
10023 delete arg2;
10024 }
10025 return resultobj;
10026 fail:
10027 {
10028 if (temp2)
10029 delete arg2;
10030 }
10031 return NULL;
10032 }
10033
10034
10035 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10036 PyObject *resultobj;
10037 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10038 wxString *arg2 = 0 ;
10039 bool temp2 = false ;
10040 PyObject * obj0 = 0 ;
10041 PyObject * obj1 = 0 ;
10042 char *kwnames[] = {
10043 (char *) "self",(char *) "extension", NULL
10044 };
10045
10046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10048 if (SWIG_arg_fail(1)) SWIG_fail;
10049 {
10050 arg2 = wxString_in_helper(obj1);
10051 if (arg2 == NULL) SWIG_fail;
10052 temp2 = true;
10053 }
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 (arg1)->SetExtension((wxString const &)*arg2);
10057
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 Py_INCREF(Py_None); resultobj = Py_None;
10062 {
10063 if (temp2)
10064 delete arg2;
10065 }
10066 return resultobj;
10067 fail:
10068 {
10069 if (temp2)
10070 delete arg2;
10071 }
10072 return NULL;
10073 }
10074
10075
10076 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10077 PyObject *resultobj;
10078 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10079 long arg2 ;
10080 PyObject * obj0 = 0 ;
10081 PyObject * obj1 = 0 ;
10082 char *kwnames[] = {
10083 (char *) "self",(char *) "type", NULL
10084 };
10085
10086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10088 if (SWIG_arg_fail(1)) SWIG_fail;
10089 {
10090 arg2 = (long)(SWIG_As_long(obj1));
10091 if (SWIG_arg_fail(2)) SWIG_fail;
10092 }
10093 {
10094 PyThreadState* __tstate = wxPyBeginAllowThreads();
10095 (arg1)->SetType(arg2);
10096
10097 wxPyEndAllowThreads(__tstate);
10098 if (PyErr_Occurred()) SWIG_fail;
10099 }
10100 Py_INCREF(Py_None); resultobj = Py_None;
10101 return resultobj;
10102 fail:
10103 return NULL;
10104 }
10105
10106
10107 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10108 PyObject *resultobj;
10109 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10110 wxString *arg2 = 0 ;
10111 bool temp2 = false ;
10112 PyObject * obj0 = 0 ;
10113 PyObject * obj1 = 0 ;
10114 char *kwnames[] = {
10115 (char *) "self",(char *) "mimetype", NULL
10116 };
10117
10118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10120 if (SWIG_arg_fail(1)) SWIG_fail;
10121 {
10122 arg2 = wxString_in_helper(obj1);
10123 if (arg2 == NULL) SWIG_fail;
10124 temp2 = true;
10125 }
10126 {
10127 PyThreadState* __tstate = wxPyBeginAllowThreads();
10128 (arg1)->SetMimeType((wxString const &)*arg2);
10129
10130 wxPyEndAllowThreads(__tstate);
10131 if (PyErr_Occurred()) SWIG_fail;
10132 }
10133 Py_INCREF(Py_None); resultobj = Py_None;
10134 {
10135 if (temp2)
10136 delete arg2;
10137 }
10138 return resultobj;
10139 fail:
10140 {
10141 if (temp2)
10142 delete arg2;
10143 }
10144 return NULL;
10145 }
10146
10147
10148 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10149 PyObject *obj;
10150 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10151 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10152 Py_INCREF(obj);
10153 return Py_BuildValue((char *)"");
10154 }
10155 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10156 PyObject *resultobj;
10157 wxImageHistogram *result;
10158 char *kwnames[] = {
10159 NULL
10160 };
10161
10162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10163 {
10164 PyThreadState* __tstate = wxPyBeginAllowThreads();
10165 result = (wxImageHistogram *)new wxImageHistogram();
10166
10167 wxPyEndAllowThreads(__tstate);
10168 if (PyErr_Occurred()) SWIG_fail;
10169 }
10170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10171 return resultobj;
10172 fail:
10173 return NULL;
10174 }
10175
10176
10177 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10178 PyObject *resultobj;
10179 unsigned char arg1 ;
10180 unsigned char arg2 ;
10181 unsigned char arg3 ;
10182 unsigned long result;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 PyObject * obj2 = 0 ;
10186 char *kwnames[] = {
10187 (char *) "r",(char *) "g",(char *) "b", NULL
10188 };
10189
10190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10191 {
10192 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10193 if (SWIG_arg_fail(1)) SWIG_fail;
10194 }
10195 {
10196 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10197 if (SWIG_arg_fail(2)) SWIG_fail;
10198 }
10199 {
10200 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10201 if (SWIG_arg_fail(3)) SWIG_fail;
10202 }
10203 {
10204 PyThreadState* __tstate = wxPyBeginAllowThreads();
10205 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10206
10207 wxPyEndAllowThreads(__tstate);
10208 if (PyErr_Occurred()) SWIG_fail;
10209 }
10210 {
10211 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10212 }
10213 return resultobj;
10214 fail:
10215 return NULL;
10216 }
10217
10218
10219 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10220 PyObject *resultobj;
10221 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10222 unsigned char *arg2 = (unsigned char *) 0 ;
10223 unsigned char *arg3 = (unsigned char *) 0 ;
10224 unsigned char *arg4 = (unsigned char *) 0 ;
10225 unsigned char arg5 = (unsigned char) 1 ;
10226 unsigned char arg6 = (unsigned char) 0 ;
10227 unsigned char arg7 = (unsigned char) 0 ;
10228 bool result;
10229 unsigned char temp2 ;
10230 int res2 = 0 ;
10231 unsigned char temp3 ;
10232 int res3 = 0 ;
10233 unsigned char temp4 ;
10234 int res4 = 0 ;
10235 PyObject * obj0 = 0 ;
10236 PyObject * obj1 = 0 ;
10237 PyObject * obj2 = 0 ;
10238 PyObject * obj3 = 0 ;
10239 char *kwnames[] = {
10240 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10241 };
10242
10243 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10244 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10245 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10248 if (SWIG_arg_fail(1)) SWIG_fail;
10249 if (obj1) {
10250 {
10251 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10252 if (SWIG_arg_fail(5)) SWIG_fail;
10253 }
10254 }
10255 if (obj2) {
10256 {
10257 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10258 if (SWIG_arg_fail(6)) SWIG_fail;
10259 }
10260 }
10261 if (obj3) {
10262 {
10263 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10264 if (SWIG_arg_fail(7)) SWIG_fail;
10265 }
10266 }
10267 {
10268 PyThreadState* __tstate = wxPyBeginAllowThreads();
10269 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10270
10271 wxPyEndAllowThreads(__tstate);
10272 if (PyErr_Occurred()) SWIG_fail;
10273 }
10274 {
10275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10276 }
10277 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10278 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10279 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10280 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10281 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10282 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10283 return resultobj;
10284 fail:
10285 return NULL;
10286 }
10287
10288
10289 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10290 PyObject *obj;
10291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10292 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10293 Py_INCREF(obj);
10294 return Py_BuildValue((char *)"");
10295 }
10296 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10297 PyObject *resultobj;
10298 wxString *arg1 = 0 ;
10299 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10300 int arg3 = (int) -1 ;
10301 wxImage *result;
10302 bool temp1 = false ;
10303 PyObject * obj0 = 0 ;
10304 PyObject * obj1 = 0 ;
10305 PyObject * obj2 = 0 ;
10306 char *kwnames[] = {
10307 (char *) "name",(char *) "type",(char *) "index", NULL
10308 };
10309
10310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10311 {
10312 arg1 = wxString_in_helper(obj0);
10313 if (arg1 == NULL) SWIG_fail;
10314 temp1 = true;
10315 }
10316 if (obj1) {
10317 {
10318 arg2 = (long)(SWIG_As_long(obj1));
10319 if (SWIG_arg_fail(2)) SWIG_fail;
10320 }
10321 }
10322 if (obj2) {
10323 {
10324 arg3 = (int)(SWIG_As_int(obj2));
10325 if (SWIG_arg_fail(3)) SWIG_fail;
10326 }
10327 }
10328 {
10329 PyThreadState* __tstate = wxPyBeginAllowThreads();
10330 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10331
10332 wxPyEndAllowThreads(__tstate);
10333 if (PyErr_Occurred()) SWIG_fail;
10334 }
10335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10336 {
10337 if (temp1)
10338 delete arg1;
10339 }
10340 return resultobj;
10341 fail:
10342 {
10343 if (temp1)
10344 delete arg1;
10345 }
10346 return NULL;
10347 }
10348
10349
10350 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj;
10352 wxImage *arg1 = (wxImage *) 0 ;
10353 PyObject * obj0 = 0 ;
10354 char *kwnames[] = {
10355 (char *) "self", NULL
10356 };
10357
10358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10360 if (SWIG_arg_fail(1)) SWIG_fail;
10361 {
10362 PyThreadState* __tstate = wxPyBeginAllowThreads();
10363 delete arg1;
10364
10365 wxPyEndAllowThreads(__tstate);
10366 if (PyErr_Occurred()) SWIG_fail;
10367 }
10368 Py_INCREF(Py_None); resultobj = Py_None;
10369 return resultobj;
10370 fail:
10371 return NULL;
10372 }
10373
10374
10375 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10376 PyObject *resultobj;
10377 wxString *arg1 = 0 ;
10378 wxString *arg2 = 0 ;
10379 int arg3 = (int) -1 ;
10380 wxImage *result;
10381 bool temp1 = false ;
10382 bool temp2 = false ;
10383 PyObject * obj0 = 0 ;
10384 PyObject * obj1 = 0 ;
10385 PyObject * obj2 = 0 ;
10386 char *kwnames[] = {
10387 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10388 };
10389
10390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10391 {
10392 arg1 = wxString_in_helper(obj0);
10393 if (arg1 == NULL) SWIG_fail;
10394 temp1 = true;
10395 }
10396 {
10397 arg2 = wxString_in_helper(obj1);
10398 if (arg2 == NULL) SWIG_fail;
10399 temp2 = true;
10400 }
10401 if (obj2) {
10402 {
10403 arg3 = (int)(SWIG_As_int(obj2));
10404 if (SWIG_arg_fail(3)) SWIG_fail;
10405 }
10406 }
10407 {
10408 PyThreadState* __tstate = wxPyBeginAllowThreads();
10409 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10410
10411 wxPyEndAllowThreads(__tstate);
10412 if (PyErr_Occurred()) SWIG_fail;
10413 }
10414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10415 {
10416 if (temp1)
10417 delete arg1;
10418 }
10419 {
10420 if (temp2)
10421 delete arg2;
10422 }
10423 return resultobj;
10424 fail:
10425 {
10426 if (temp1)
10427 delete arg1;
10428 }
10429 {
10430 if (temp2)
10431 delete arg2;
10432 }
10433 return NULL;
10434 }
10435
10436
10437 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10438 PyObject *resultobj;
10439 wxInputStream *arg1 = 0 ;
10440 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10441 int arg3 = (int) -1 ;
10442 wxImage *result;
10443 wxPyInputStream *temp1 ;
10444 bool created1 ;
10445 PyObject * obj0 = 0 ;
10446 PyObject * obj1 = 0 ;
10447 PyObject * obj2 = 0 ;
10448 char *kwnames[] = {
10449 (char *) "stream",(char *) "type",(char *) "index", NULL
10450 };
10451
10452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10453 {
10454 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10455 arg1 = temp1->m_wxis;
10456 created1 = false;
10457 } else {
10458 PyErr_Clear(); // clear the failure of the wxPyConvert above
10459 arg1 = wxPyCBInputStream_create(obj0, false);
10460 if (arg1 == NULL) {
10461 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10462 SWIG_fail;
10463 }
10464 created1 = true;
10465 }
10466 }
10467 if (obj1) {
10468 {
10469 arg2 = (long)(SWIG_As_long(obj1));
10470 if (SWIG_arg_fail(2)) SWIG_fail;
10471 }
10472 }
10473 if (obj2) {
10474 {
10475 arg3 = (int)(SWIG_As_int(obj2));
10476 if (SWIG_arg_fail(3)) SWIG_fail;
10477 }
10478 }
10479 {
10480 PyThreadState* __tstate = wxPyBeginAllowThreads();
10481 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10482
10483 wxPyEndAllowThreads(__tstate);
10484 if (PyErr_Occurred()) SWIG_fail;
10485 }
10486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10487 {
10488 if (created1)
10489 delete arg1;
10490 }
10491 return resultobj;
10492 fail:
10493 {
10494 if (created1)
10495 delete arg1;
10496 }
10497 return NULL;
10498 }
10499
10500
10501 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10502 PyObject *resultobj;
10503 wxInputStream *arg1 = 0 ;
10504 wxString *arg2 = 0 ;
10505 int arg3 = (int) -1 ;
10506 wxImage *result;
10507 wxPyInputStream *temp1 ;
10508 bool created1 ;
10509 bool temp2 = false ;
10510 PyObject * obj0 = 0 ;
10511 PyObject * obj1 = 0 ;
10512 PyObject * obj2 = 0 ;
10513 char *kwnames[] = {
10514 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10515 };
10516
10517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10518 {
10519 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10520 arg1 = temp1->m_wxis;
10521 created1 = false;
10522 } else {
10523 PyErr_Clear(); // clear the failure of the wxPyConvert above
10524 arg1 = wxPyCBInputStream_create(obj0, false);
10525 if (arg1 == NULL) {
10526 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10527 SWIG_fail;
10528 }
10529 created1 = true;
10530 }
10531 }
10532 {
10533 arg2 = wxString_in_helper(obj1);
10534 if (arg2 == NULL) SWIG_fail;
10535 temp2 = true;
10536 }
10537 if (obj2) {
10538 {
10539 arg3 = (int)(SWIG_As_int(obj2));
10540 if (SWIG_arg_fail(3)) SWIG_fail;
10541 }
10542 }
10543 {
10544 PyThreadState* __tstate = wxPyBeginAllowThreads();
10545 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10546
10547 wxPyEndAllowThreads(__tstate);
10548 if (PyErr_Occurred()) SWIG_fail;
10549 }
10550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10551 {
10552 if (created1)
10553 delete arg1;
10554 }
10555 {
10556 if (temp2)
10557 delete arg2;
10558 }
10559 return resultobj;
10560 fail:
10561 {
10562 if (created1)
10563 delete arg1;
10564 }
10565 {
10566 if (temp2)
10567 delete arg2;
10568 }
10569 return NULL;
10570 }
10571
10572
10573 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10574 PyObject *resultobj;
10575 int arg1 = (int) 0 ;
10576 int arg2 = (int) 0 ;
10577 bool arg3 = (bool) true ;
10578 wxImage *result;
10579 PyObject * obj0 = 0 ;
10580 PyObject * obj1 = 0 ;
10581 PyObject * obj2 = 0 ;
10582 char *kwnames[] = {
10583 (char *) "width",(char *) "height",(char *) "clear", NULL
10584 };
10585
10586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10587 if (obj0) {
10588 {
10589 arg1 = (int)(SWIG_As_int(obj0));
10590 if (SWIG_arg_fail(1)) SWIG_fail;
10591 }
10592 }
10593 if (obj1) {
10594 {
10595 arg2 = (int)(SWIG_As_int(obj1));
10596 if (SWIG_arg_fail(2)) SWIG_fail;
10597 }
10598 }
10599 if (obj2) {
10600 {
10601 arg3 = (bool)(SWIG_As_bool(obj2));
10602 if (SWIG_arg_fail(3)) SWIG_fail;
10603 }
10604 }
10605 {
10606 PyThreadState* __tstate = wxPyBeginAllowThreads();
10607 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10608
10609 wxPyEndAllowThreads(__tstate);
10610 if (PyErr_Occurred()) SWIG_fail;
10611 }
10612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10613 return resultobj;
10614 fail:
10615 return NULL;
10616 }
10617
10618
10619 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10620 PyObject *resultobj;
10621 wxBitmap *arg1 = 0 ;
10622 wxImage *result;
10623 PyObject * obj0 = 0 ;
10624 char *kwnames[] = {
10625 (char *) "bitmap", NULL
10626 };
10627
10628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10629 {
10630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10631 if (SWIG_arg_fail(1)) SWIG_fail;
10632 if (arg1 == NULL) {
10633 SWIG_null_ref("wxBitmap");
10634 }
10635 if (SWIG_arg_fail(1)) SWIG_fail;
10636 }
10637 {
10638 if (!wxPyCheckForApp()) SWIG_fail;
10639 PyThreadState* __tstate = wxPyBeginAllowThreads();
10640 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10641
10642 wxPyEndAllowThreads(__tstate);
10643 if (PyErr_Occurred()) SWIG_fail;
10644 }
10645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10646 return resultobj;
10647 fail:
10648 return NULL;
10649 }
10650
10651
10652 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10653 PyObject *resultobj;
10654 int arg1 ;
10655 int arg2 ;
10656 unsigned char *arg3 = (unsigned char *) 0 ;
10657 wxImage *result;
10658 PyObject * obj0 = 0 ;
10659 PyObject * obj1 = 0 ;
10660 PyObject * obj2 = 0 ;
10661 char *kwnames[] = {
10662 (char *) "width",(char *) "height",(char *) "data", NULL
10663 };
10664
10665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10666 {
10667 arg1 = (int)(SWIG_As_int(obj0));
10668 if (SWIG_arg_fail(1)) SWIG_fail;
10669 }
10670 {
10671 arg2 = (int)(SWIG_As_int(obj1));
10672 if (SWIG_arg_fail(2)) SWIG_fail;
10673 }
10674 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10675 if (SWIG_arg_fail(3)) SWIG_fail;
10676 {
10677 PyThreadState* __tstate = wxPyBeginAllowThreads();
10678 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10679
10680 wxPyEndAllowThreads(__tstate);
10681 if (PyErr_Occurred()) SWIG_fail;
10682 }
10683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10684 return resultobj;
10685 fail:
10686 return NULL;
10687 }
10688
10689
10690 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj;
10692 int arg1 ;
10693 int arg2 ;
10694 unsigned char *arg3 = (unsigned char *) 0 ;
10695 unsigned char *arg4 = (unsigned char *) 0 ;
10696 wxImage *result;
10697 PyObject * obj0 = 0 ;
10698 PyObject * obj1 = 0 ;
10699 PyObject * obj2 = 0 ;
10700 PyObject * obj3 = 0 ;
10701 char *kwnames[] = {
10702 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10703 };
10704
10705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10706 {
10707 arg1 = (int)(SWIG_As_int(obj0));
10708 if (SWIG_arg_fail(1)) SWIG_fail;
10709 }
10710 {
10711 arg2 = (int)(SWIG_As_int(obj1));
10712 if (SWIG_arg_fail(2)) SWIG_fail;
10713 }
10714 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10715 if (SWIG_arg_fail(3)) SWIG_fail;
10716 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10717 if (SWIG_arg_fail(4)) SWIG_fail;
10718 {
10719 PyThreadState* __tstate = wxPyBeginAllowThreads();
10720 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10721
10722 wxPyEndAllowThreads(__tstate);
10723 if (PyErr_Occurred()) SWIG_fail;
10724 }
10725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10726 return resultobj;
10727 fail:
10728 return NULL;
10729 }
10730
10731
10732 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10733 PyObject *resultobj;
10734 wxImage *arg1 = (wxImage *) 0 ;
10735 int arg2 ;
10736 int arg3 ;
10737 PyObject * obj0 = 0 ;
10738 PyObject * obj1 = 0 ;
10739 PyObject * obj2 = 0 ;
10740 char *kwnames[] = {
10741 (char *) "self",(char *) "width",(char *) "height", NULL
10742 };
10743
10744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10746 if (SWIG_arg_fail(1)) SWIG_fail;
10747 {
10748 arg2 = (int)(SWIG_As_int(obj1));
10749 if (SWIG_arg_fail(2)) SWIG_fail;
10750 }
10751 {
10752 arg3 = (int)(SWIG_As_int(obj2));
10753 if (SWIG_arg_fail(3)) SWIG_fail;
10754 }
10755 {
10756 PyThreadState* __tstate = wxPyBeginAllowThreads();
10757 (arg1)->Create(arg2,arg3);
10758
10759 wxPyEndAllowThreads(__tstate);
10760 if (PyErr_Occurred()) SWIG_fail;
10761 }
10762 Py_INCREF(Py_None); resultobj = Py_None;
10763 return resultobj;
10764 fail:
10765 return NULL;
10766 }
10767
10768
10769 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10770 PyObject *resultobj;
10771 wxImage *arg1 = (wxImage *) 0 ;
10772 PyObject * obj0 = 0 ;
10773 char *kwnames[] = {
10774 (char *) "self", NULL
10775 };
10776
10777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10779 if (SWIG_arg_fail(1)) SWIG_fail;
10780 {
10781 PyThreadState* __tstate = wxPyBeginAllowThreads();
10782 (arg1)->Destroy();
10783
10784 wxPyEndAllowThreads(__tstate);
10785 if (PyErr_Occurred()) SWIG_fail;
10786 }
10787 Py_INCREF(Py_None); resultobj = Py_None;
10788 return resultobj;
10789 fail:
10790 return NULL;
10791 }
10792
10793
10794 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10795 PyObject *resultobj;
10796 wxImage *arg1 = (wxImage *) 0 ;
10797 int arg2 ;
10798 int arg3 ;
10799 SwigValueWrapper<wxImage > result;
10800 PyObject * obj0 = 0 ;
10801 PyObject * obj1 = 0 ;
10802 PyObject * obj2 = 0 ;
10803 char *kwnames[] = {
10804 (char *) "self",(char *) "width",(char *) "height", NULL
10805 };
10806
10807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10809 if (SWIG_arg_fail(1)) SWIG_fail;
10810 {
10811 arg2 = (int)(SWIG_As_int(obj1));
10812 if (SWIG_arg_fail(2)) SWIG_fail;
10813 }
10814 {
10815 arg3 = (int)(SWIG_As_int(obj2));
10816 if (SWIG_arg_fail(3)) SWIG_fail;
10817 }
10818 {
10819 PyThreadState* __tstate = wxPyBeginAllowThreads();
10820 result = (arg1)->Scale(arg2,arg3);
10821
10822 wxPyEndAllowThreads(__tstate);
10823 if (PyErr_Occurred()) SWIG_fail;
10824 }
10825 {
10826 wxImage * resultptr;
10827 resultptr = new wxImage((wxImage &)(result));
10828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10829 }
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10837 PyObject *resultobj;
10838 wxImage *arg1 = (wxImage *) 0 ;
10839 int arg2 ;
10840 int arg3 ;
10841 SwigValueWrapper<wxImage > result;
10842 PyObject * obj0 = 0 ;
10843 PyObject * obj1 = 0 ;
10844 PyObject * obj2 = 0 ;
10845 char *kwnames[] = {
10846 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10847 };
10848
10849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10851 if (SWIG_arg_fail(1)) SWIG_fail;
10852 {
10853 arg2 = (int)(SWIG_As_int(obj1));
10854 if (SWIG_arg_fail(2)) SWIG_fail;
10855 }
10856 {
10857 arg3 = (int)(SWIG_As_int(obj2));
10858 if (SWIG_arg_fail(3)) SWIG_fail;
10859 }
10860 {
10861 PyThreadState* __tstate = wxPyBeginAllowThreads();
10862 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10863
10864 wxPyEndAllowThreads(__tstate);
10865 if (PyErr_Occurred()) SWIG_fail;
10866 }
10867 {
10868 wxImage * resultptr;
10869 resultptr = new wxImage((wxImage &)(result));
10870 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10871 }
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10879 PyObject *resultobj;
10880 wxImage *arg1 = (wxImage *) 0 ;
10881 int arg2 ;
10882 int arg3 ;
10883 wxImage *result;
10884 PyObject * obj0 = 0 ;
10885 PyObject * obj1 = 0 ;
10886 PyObject * obj2 = 0 ;
10887 char *kwnames[] = {
10888 (char *) "self",(char *) "width",(char *) "height", NULL
10889 };
10890
10891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10893 if (SWIG_arg_fail(1)) SWIG_fail;
10894 {
10895 arg2 = (int)(SWIG_As_int(obj1));
10896 if (SWIG_arg_fail(2)) SWIG_fail;
10897 }
10898 {
10899 arg3 = (int)(SWIG_As_int(obj2));
10900 if (SWIG_arg_fail(3)) SWIG_fail;
10901 }
10902 {
10903 PyThreadState* __tstate = wxPyBeginAllowThreads();
10904 {
10905 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10906 result = (wxImage *) &_result_ref;
10907 }
10908
10909 wxPyEndAllowThreads(__tstate);
10910 if (PyErr_Occurred()) SWIG_fail;
10911 }
10912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10913 return resultobj;
10914 fail:
10915 return NULL;
10916 }
10917
10918
10919 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10920 PyObject *resultobj;
10921 wxImage *arg1 = (wxImage *) 0 ;
10922 int arg2 ;
10923 int arg3 ;
10924 unsigned char arg4 ;
10925 unsigned char arg5 ;
10926 unsigned char arg6 ;
10927 PyObject * obj0 = 0 ;
10928 PyObject * obj1 = 0 ;
10929 PyObject * obj2 = 0 ;
10930 PyObject * obj3 = 0 ;
10931 PyObject * obj4 = 0 ;
10932 PyObject * obj5 = 0 ;
10933 char *kwnames[] = {
10934 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10935 };
10936
10937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10939 if (SWIG_arg_fail(1)) SWIG_fail;
10940 {
10941 arg2 = (int)(SWIG_As_int(obj1));
10942 if (SWIG_arg_fail(2)) SWIG_fail;
10943 }
10944 {
10945 arg3 = (int)(SWIG_As_int(obj2));
10946 if (SWIG_arg_fail(3)) SWIG_fail;
10947 }
10948 {
10949 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10950 if (SWIG_arg_fail(4)) SWIG_fail;
10951 }
10952 {
10953 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10954 if (SWIG_arg_fail(5)) SWIG_fail;
10955 }
10956 {
10957 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10958 if (SWIG_arg_fail(6)) SWIG_fail;
10959 }
10960 {
10961 PyThreadState* __tstate = wxPyBeginAllowThreads();
10962 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10963
10964 wxPyEndAllowThreads(__tstate);
10965 if (PyErr_Occurred()) SWIG_fail;
10966 }
10967 Py_INCREF(Py_None); resultobj = Py_None;
10968 return resultobj;
10969 fail:
10970 return NULL;
10971 }
10972
10973
10974 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10975 PyObject *resultobj;
10976 wxImage *arg1 = (wxImage *) 0 ;
10977 int arg2 ;
10978 int arg3 ;
10979 unsigned char result;
10980 PyObject * obj0 = 0 ;
10981 PyObject * obj1 = 0 ;
10982 PyObject * obj2 = 0 ;
10983 char *kwnames[] = {
10984 (char *) "self",(char *) "x",(char *) "y", NULL
10985 };
10986
10987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10989 if (SWIG_arg_fail(1)) SWIG_fail;
10990 {
10991 arg2 = (int)(SWIG_As_int(obj1));
10992 if (SWIG_arg_fail(2)) SWIG_fail;
10993 }
10994 {
10995 arg3 = (int)(SWIG_As_int(obj2));
10996 if (SWIG_arg_fail(3)) SWIG_fail;
10997 }
10998 {
10999 PyThreadState* __tstate = wxPyBeginAllowThreads();
11000 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11001
11002 wxPyEndAllowThreads(__tstate);
11003 if (PyErr_Occurred()) SWIG_fail;
11004 }
11005 {
11006 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11007 }
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11015 PyObject *resultobj;
11016 wxImage *arg1 = (wxImage *) 0 ;
11017 int arg2 ;
11018 int arg3 ;
11019 unsigned char result;
11020 PyObject * obj0 = 0 ;
11021 PyObject * obj1 = 0 ;
11022 PyObject * obj2 = 0 ;
11023 char *kwnames[] = {
11024 (char *) "self",(char *) "x",(char *) "y", NULL
11025 };
11026
11027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11029 if (SWIG_arg_fail(1)) SWIG_fail;
11030 {
11031 arg2 = (int)(SWIG_As_int(obj1));
11032 if (SWIG_arg_fail(2)) SWIG_fail;
11033 }
11034 {
11035 arg3 = (int)(SWIG_As_int(obj2));
11036 if (SWIG_arg_fail(3)) SWIG_fail;
11037 }
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11041
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 {
11046 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11047 }
11048 return resultobj;
11049 fail:
11050 return NULL;
11051 }
11052
11053
11054 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11055 PyObject *resultobj;
11056 wxImage *arg1 = (wxImage *) 0 ;
11057 int arg2 ;
11058 int arg3 ;
11059 unsigned char result;
11060 PyObject * obj0 = 0 ;
11061 PyObject * obj1 = 0 ;
11062 PyObject * obj2 = 0 ;
11063 char *kwnames[] = {
11064 (char *) "self",(char *) "x",(char *) "y", NULL
11065 };
11066
11067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11069 if (SWIG_arg_fail(1)) SWIG_fail;
11070 {
11071 arg2 = (int)(SWIG_As_int(obj1));
11072 if (SWIG_arg_fail(2)) SWIG_fail;
11073 }
11074 {
11075 arg3 = (int)(SWIG_As_int(obj2));
11076 if (SWIG_arg_fail(3)) SWIG_fail;
11077 }
11078 {
11079 PyThreadState* __tstate = wxPyBeginAllowThreads();
11080 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11081
11082 wxPyEndAllowThreads(__tstate);
11083 if (PyErr_Occurred()) SWIG_fail;
11084 }
11085 {
11086 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11087 }
11088 return resultobj;
11089 fail:
11090 return NULL;
11091 }
11092
11093
11094 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11095 PyObject *resultobj;
11096 wxImage *arg1 = (wxImage *) 0 ;
11097 int arg2 ;
11098 int arg3 ;
11099 unsigned char arg4 ;
11100 PyObject * obj0 = 0 ;
11101 PyObject * obj1 = 0 ;
11102 PyObject * obj2 = 0 ;
11103 PyObject * obj3 = 0 ;
11104 char *kwnames[] = {
11105 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11106 };
11107
11108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11110 if (SWIG_arg_fail(1)) SWIG_fail;
11111 {
11112 arg2 = (int)(SWIG_As_int(obj1));
11113 if (SWIG_arg_fail(2)) SWIG_fail;
11114 }
11115 {
11116 arg3 = (int)(SWIG_As_int(obj2));
11117 if (SWIG_arg_fail(3)) SWIG_fail;
11118 }
11119 {
11120 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11121 if (SWIG_arg_fail(4)) SWIG_fail;
11122 }
11123 {
11124 PyThreadState* __tstate = wxPyBeginAllowThreads();
11125 (arg1)->SetAlpha(arg2,arg3,arg4);
11126
11127 wxPyEndAllowThreads(__tstate);
11128 if (PyErr_Occurred()) SWIG_fail;
11129 }
11130 Py_INCREF(Py_None); resultobj = Py_None;
11131 return resultobj;
11132 fail:
11133 return NULL;
11134 }
11135
11136
11137 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11138 PyObject *resultobj;
11139 wxImage *arg1 = (wxImage *) 0 ;
11140 int arg2 ;
11141 int arg3 ;
11142 unsigned char result;
11143 PyObject * obj0 = 0 ;
11144 PyObject * obj1 = 0 ;
11145 PyObject * obj2 = 0 ;
11146 char *kwnames[] = {
11147 (char *) "self",(char *) "x",(char *) "y", NULL
11148 };
11149
11150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11152 if (SWIG_arg_fail(1)) SWIG_fail;
11153 {
11154 arg2 = (int)(SWIG_As_int(obj1));
11155 if (SWIG_arg_fail(2)) SWIG_fail;
11156 }
11157 {
11158 arg3 = (int)(SWIG_As_int(obj2));
11159 if (SWIG_arg_fail(3)) SWIG_fail;
11160 }
11161 {
11162 PyThreadState* __tstate = wxPyBeginAllowThreads();
11163 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11164
11165 wxPyEndAllowThreads(__tstate);
11166 if (PyErr_Occurred()) SWIG_fail;
11167 }
11168 {
11169 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11170 }
11171 return resultobj;
11172 fail:
11173 return NULL;
11174 }
11175
11176
11177 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11178 PyObject *resultobj;
11179 wxImage *arg1 = (wxImage *) 0 ;
11180 bool result;
11181 PyObject * obj0 = 0 ;
11182 char *kwnames[] = {
11183 (char *) "self", NULL
11184 };
11185
11186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11188 if (SWIG_arg_fail(1)) SWIG_fail;
11189 {
11190 PyThreadState* __tstate = wxPyBeginAllowThreads();
11191 result = (bool)(arg1)->HasAlpha();
11192
11193 wxPyEndAllowThreads(__tstate);
11194 if (PyErr_Occurred()) SWIG_fail;
11195 }
11196 {
11197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11198 }
11199 return resultobj;
11200 fail:
11201 return NULL;
11202 }
11203
11204
11205 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11206 PyObject *resultobj;
11207 wxImage *arg1 = (wxImage *) 0 ;
11208 byte *arg2 = (byte *) 0 ;
11209 byte *arg3 = (byte *) 0 ;
11210 byte *arg4 = (byte *) 0 ;
11211 byte arg5 = (byte) 0 ;
11212 byte arg6 = (byte) 0 ;
11213 byte arg7 = (byte) 0 ;
11214 bool result;
11215 byte temp2 ;
11216 int res2 = 0 ;
11217 byte temp3 ;
11218 int res3 = 0 ;
11219 byte temp4 ;
11220 int res4 = 0 ;
11221 PyObject * obj0 = 0 ;
11222 PyObject * obj1 = 0 ;
11223 PyObject * obj2 = 0 ;
11224 PyObject * obj3 = 0 ;
11225 char *kwnames[] = {
11226 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11227 };
11228
11229 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11230 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11231 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11234 if (SWIG_arg_fail(1)) SWIG_fail;
11235 if (obj1) {
11236 {
11237 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11238 if (SWIG_arg_fail(5)) SWIG_fail;
11239 }
11240 }
11241 if (obj2) {
11242 {
11243 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11244 if (SWIG_arg_fail(6)) SWIG_fail;
11245 }
11246 }
11247 if (obj3) {
11248 {
11249 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11250 if (SWIG_arg_fail(7)) SWIG_fail;
11251 }
11252 }
11253 {
11254 PyThreadState* __tstate = wxPyBeginAllowThreads();
11255 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11256
11257 wxPyEndAllowThreads(__tstate);
11258 if (PyErr_Occurred()) SWIG_fail;
11259 }
11260 {
11261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11262 }
11263 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11264 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11265 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11266 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11267 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11268 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11269 return resultobj;
11270 fail:
11271 return NULL;
11272 }
11273
11274
11275 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11276 PyObject *resultobj;
11277 wxImage *arg1 = (wxImage *) 0 ;
11278 byte arg2 = (byte) 128 ;
11279 bool result;
11280 PyObject * obj0 = 0 ;
11281 PyObject * obj1 = 0 ;
11282 char *kwnames[] = {
11283 (char *) "self",(char *) "threshold", NULL
11284 };
11285
11286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11288 if (SWIG_arg_fail(1)) SWIG_fail;
11289 if (obj1) {
11290 {
11291 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11292 if (SWIG_arg_fail(2)) SWIG_fail;
11293 }
11294 }
11295 {
11296 PyThreadState* __tstate = wxPyBeginAllowThreads();
11297 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11298
11299 wxPyEndAllowThreads(__tstate);
11300 if (PyErr_Occurred()) SWIG_fail;
11301 }
11302 {
11303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11304 }
11305 return resultobj;
11306 fail:
11307 return NULL;
11308 }
11309
11310
11311 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11312 PyObject *resultobj;
11313 wxImage *arg1 = (wxImage *) 0 ;
11314 unsigned char arg2 ;
11315 unsigned char arg3 ;
11316 unsigned char arg4 ;
11317 bool result;
11318 PyObject * obj0 = 0 ;
11319 PyObject * obj1 = 0 ;
11320 PyObject * obj2 = 0 ;
11321 PyObject * obj3 = 0 ;
11322 char *kwnames[] = {
11323 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11324 };
11325
11326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11328 if (SWIG_arg_fail(1)) SWIG_fail;
11329 {
11330 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11331 if (SWIG_arg_fail(2)) SWIG_fail;
11332 }
11333 {
11334 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11335 if (SWIG_arg_fail(3)) SWIG_fail;
11336 }
11337 {
11338 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11339 if (SWIG_arg_fail(4)) SWIG_fail;
11340 }
11341 {
11342 PyThreadState* __tstate = wxPyBeginAllowThreads();
11343 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11344
11345 wxPyEndAllowThreads(__tstate);
11346 if (PyErr_Occurred()) SWIG_fail;
11347 }
11348 {
11349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11350 }
11351 return resultobj;
11352 fail:
11353 return NULL;
11354 }
11355
11356
11357 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11358 PyObject *resultobj;
11359 wxImage *arg1 = (wxImage *) 0 ;
11360 wxImage *arg2 = 0 ;
11361 byte arg3 ;
11362 byte arg4 ;
11363 byte arg5 ;
11364 bool result;
11365 PyObject * obj0 = 0 ;
11366 PyObject * obj1 = 0 ;
11367 PyObject * obj2 = 0 ;
11368 PyObject * obj3 = 0 ;
11369 PyObject * obj4 = 0 ;
11370 char *kwnames[] = {
11371 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11372 };
11373
11374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11376 if (SWIG_arg_fail(1)) SWIG_fail;
11377 {
11378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11379 if (SWIG_arg_fail(2)) SWIG_fail;
11380 if (arg2 == NULL) {
11381 SWIG_null_ref("wxImage");
11382 }
11383 if (SWIG_arg_fail(2)) SWIG_fail;
11384 }
11385 {
11386 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11387 if (SWIG_arg_fail(3)) SWIG_fail;
11388 }
11389 {
11390 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11391 if (SWIG_arg_fail(4)) SWIG_fail;
11392 }
11393 {
11394 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11395 if (SWIG_arg_fail(5)) SWIG_fail;
11396 }
11397 {
11398 PyThreadState* __tstate = wxPyBeginAllowThreads();
11399 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11400
11401 wxPyEndAllowThreads(__tstate);
11402 if (PyErr_Occurred()) SWIG_fail;
11403 }
11404 {
11405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11406 }
11407 return resultobj;
11408 fail:
11409 return NULL;
11410 }
11411
11412
11413 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11414 PyObject *resultobj;
11415 wxString *arg1 = 0 ;
11416 bool result;
11417 bool temp1 = false ;
11418 PyObject * obj0 = 0 ;
11419 char *kwnames[] = {
11420 (char *) "name", NULL
11421 };
11422
11423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11424 {
11425 arg1 = wxString_in_helper(obj0);
11426 if (arg1 == NULL) SWIG_fail;
11427 temp1 = true;
11428 }
11429 {
11430 PyThreadState* __tstate = wxPyBeginAllowThreads();
11431 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11432
11433 wxPyEndAllowThreads(__tstate);
11434 if (PyErr_Occurred()) SWIG_fail;
11435 }
11436 {
11437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11438 }
11439 {
11440 if (temp1)
11441 delete arg1;
11442 }
11443 return resultobj;
11444 fail:
11445 {
11446 if (temp1)
11447 delete arg1;
11448 }
11449 return NULL;
11450 }
11451
11452
11453 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11454 PyObject *resultobj;
11455 wxString *arg1 = 0 ;
11456 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11457 int result;
11458 bool temp1 = false ;
11459 PyObject * obj0 = 0 ;
11460 PyObject * obj1 = 0 ;
11461 char *kwnames[] = {
11462 (char *) "name",(char *) "type", NULL
11463 };
11464
11465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11466 {
11467 arg1 = wxString_in_helper(obj0);
11468 if (arg1 == NULL) SWIG_fail;
11469 temp1 = true;
11470 }
11471 if (obj1) {
11472 {
11473 arg2 = (long)(SWIG_As_long(obj1));
11474 if (SWIG_arg_fail(2)) SWIG_fail;
11475 }
11476 }
11477 {
11478 PyThreadState* __tstate = wxPyBeginAllowThreads();
11479 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11480
11481 wxPyEndAllowThreads(__tstate);
11482 if (PyErr_Occurred()) SWIG_fail;
11483 }
11484 {
11485 resultobj = SWIG_From_int((int)(result));
11486 }
11487 {
11488 if (temp1)
11489 delete arg1;
11490 }
11491 return resultobj;
11492 fail:
11493 {
11494 if (temp1)
11495 delete arg1;
11496 }
11497 return NULL;
11498 }
11499
11500
11501 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11502 PyObject *resultobj;
11503 wxImage *arg1 = (wxImage *) 0 ;
11504 wxString *arg2 = 0 ;
11505 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11506 int arg4 = (int) -1 ;
11507 bool result;
11508 bool temp2 = false ;
11509 PyObject * obj0 = 0 ;
11510 PyObject * obj1 = 0 ;
11511 PyObject * obj2 = 0 ;
11512 PyObject * obj3 = 0 ;
11513 char *kwnames[] = {
11514 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11515 };
11516
11517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11519 if (SWIG_arg_fail(1)) SWIG_fail;
11520 {
11521 arg2 = wxString_in_helper(obj1);
11522 if (arg2 == NULL) SWIG_fail;
11523 temp2 = true;
11524 }
11525 if (obj2) {
11526 {
11527 arg3 = (long)(SWIG_As_long(obj2));
11528 if (SWIG_arg_fail(3)) SWIG_fail;
11529 }
11530 }
11531 if (obj3) {
11532 {
11533 arg4 = (int)(SWIG_As_int(obj3));
11534 if (SWIG_arg_fail(4)) SWIG_fail;
11535 }
11536 }
11537 {
11538 PyThreadState* __tstate = wxPyBeginAllowThreads();
11539 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11540
11541 wxPyEndAllowThreads(__tstate);
11542 if (PyErr_Occurred()) SWIG_fail;
11543 }
11544 {
11545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11546 }
11547 {
11548 if (temp2)
11549 delete arg2;
11550 }
11551 return resultobj;
11552 fail:
11553 {
11554 if (temp2)
11555 delete arg2;
11556 }
11557 return NULL;
11558 }
11559
11560
11561 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11562 PyObject *resultobj;
11563 wxImage *arg1 = (wxImage *) 0 ;
11564 wxString *arg2 = 0 ;
11565 wxString *arg3 = 0 ;
11566 int arg4 = (int) -1 ;
11567 bool result;
11568 bool temp2 = false ;
11569 bool temp3 = false ;
11570 PyObject * obj0 = 0 ;
11571 PyObject * obj1 = 0 ;
11572 PyObject * obj2 = 0 ;
11573 PyObject * obj3 = 0 ;
11574 char *kwnames[] = {
11575 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11576 };
11577
11578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11580 if (SWIG_arg_fail(1)) SWIG_fail;
11581 {
11582 arg2 = wxString_in_helper(obj1);
11583 if (arg2 == NULL) SWIG_fail;
11584 temp2 = true;
11585 }
11586 {
11587 arg3 = wxString_in_helper(obj2);
11588 if (arg3 == NULL) SWIG_fail;
11589 temp3 = true;
11590 }
11591 if (obj3) {
11592 {
11593 arg4 = (int)(SWIG_As_int(obj3));
11594 if (SWIG_arg_fail(4)) SWIG_fail;
11595 }
11596 }
11597 {
11598 PyThreadState* __tstate = wxPyBeginAllowThreads();
11599 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11600
11601 wxPyEndAllowThreads(__tstate);
11602 if (PyErr_Occurred()) SWIG_fail;
11603 }
11604 {
11605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11606 }
11607 {
11608 if (temp2)
11609 delete arg2;
11610 }
11611 {
11612 if (temp3)
11613 delete arg3;
11614 }
11615 return resultobj;
11616 fail:
11617 {
11618 if (temp2)
11619 delete arg2;
11620 }
11621 {
11622 if (temp3)
11623 delete arg3;
11624 }
11625 return NULL;
11626 }
11627
11628
11629 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11630 PyObject *resultobj;
11631 wxImage *arg1 = (wxImage *) 0 ;
11632 wxString *arg2 = 0 ;
11633 int arg3 ;
11634 bool result;
11635 bool temp2 = false ;
11636 PyObject * obj0 = 0 ;
11637 PyObject * obj1 = 0 ;
11638 PyObject * obj2 = 0 ;
11639 char *kwnames[] = {
11640 (char *) "self",(char *) "name",(char *) "type", NULL
11641 };
11642
11643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11645 if (SWIG_arg_fail(1)) SWIG_fail;
11646 {
11647 arg2 = wxString_in_helper(obj1);
11648 if (arg2 == NULL) SWIG_fail;
11649 temp2 = true;
11650 }
11651 {
11652 arg3 = (int)(SWIG_As_int(obj2));
11653 if (SWIG_arg_fail(3)) SWIG_fail;
11654 }
11655 {
11656 PyThreadState* __tstate = wxPyBeginAllowThreads();
11657 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11658
11659 wxPyEndAllowThreads(__tstate);
11660 if (PyErr_Occurred()) SWIG_fail;
11661 }
11662 {
11663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11664 }
11665 {
11666 if (temp2)
11667 delete arg2;
11668 }
11669 return resultobj;
11670 fail:
11671 {
11672 if (temp2)
11673 delete arg2;
11674 }
11675 return NULL;
11676 }
11677
11678
11679 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11680 PyObject *resultobj;
11681 wxImage *arg1 = (wxImage *) 0 ;
11682 wxString *arg2 = 0 ;
11683 wxString *arg3 = 0 ;
11684 bool result;
11685 bool temp2 = false ;
11686 bool temp3 = false ;
11687 PyObject * obj0 = 0 ;
11688 PyObject * obj1 = 0 ;
11689 PyObject * obj2 = 0 ;
11690 char *kwnames[] = {
11691 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11692 };
11693
11694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11696 if (SWIG_arg_fail(1)) SWIG_fail;
11697 {
11698 arg2 = wxString_in_helper(obj1);
11699 if (arg2 == NULL) SWIG_fail;
11700 temp2 = true;
11701 }
11702 {
11703 arg3 = wxString_in_helper(obj2);
11704 if (arg3 == NULL) SWIG_fail;
11705 temp3 = true;
11706 }
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11710
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 {
11715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11716 }
11717 {
11718 if (temp2)
11719 delete arg2;
11720 }
11721 {
11722 if (temp3)
11723 delete arg3;
11724 }
11725 return resultobj;
11726 fail:
11727 {
11728 if (temp2)
11729 delete arg2;
11730 }
11731 {
11732 if (temp3)
11733 delete arg3;
11734 }
11735 return NULL;
11736 }
11737
11738
11739 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11740 PyObject *resultobj;
11741 wxInputStream *arg1 = 0 ;
11742 bool result;
11743 wxPyInputStream *temp1 ;
11744 bool created1 ;
11745 PyObject * obj0 = 0 ;
11746 char *kwnames[] = {
11747 (char *) "stream", NULL
11748 };
11749
11750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11751 {
11752 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11753 arg1 = temp1->m_wxis;
11754 created1 = false;
11755 } else {
11756 PyErr_Clear(); // clear the failure of the wxPyConvert above
11757 arg1 = wxPyCBInputStream_create(obj0, false);
11758 if (arg1 == NULL) {
11759 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11760 SWIG_fail;
11761 }
11762 created1 = true;
11763 }
11764 }
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (bool)wxImage::CanRead(*arg1);
11768
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 {
11773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11774 }
11775 {
11776 if (created1)
11777 delete arg1;
11778 }
11779 return resultobj;
11780 fail:
11781 {
11782 if (created1)
11783 delete arg1;
11784 }
11785 return NULL;
11786 }
11787
11788
11789 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11790 PyObject *resultobj;
11791 wxImage *arg1 = (wxImage *) 0 ;
11792 wxInputStream *arg2 = 0 ;
11793 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11794 int arg4 = (int) -1 ;
11795 bool result;
11796 wxPyInputStream *temp2 ;
11797 bool created2 ;
11798 PyObject * obj0 = 0 ;
11799 PyObject * obj1 = 0 ;
11800 PyObject * obj2 = 0 ;
11801 PyObject * obj3 = 0 ;
11802 char *kwnames[] = {
11803 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11804 };
11805
11806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11808 if (SWIG_arg_fail(1)) SWIG_fail;
11809 {
11810 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11811 arg2 = temp2->m_wxis;
11812 created2 = false;
11813 } else {
11814 PyErr_Clear(); // clear the failure of the wxPyConvert above
11815 arg2 = wxPyCBInputStream_create(obj1, false);
11816 if (arg2 == NULL) {
11817 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11818 SWIG_fail;
11819 }
11820 created2 = true;
11821 }
11822 }
11823 if (obj2) {
11824 {
11825 arg3 = (long)(SWIG_As_long(obj2));
11826 if (SWIG_arg_fail(3)) SWIG_fail;
11827 }
11828 }
11829 if (obj3) {
11830 {
11831 arg4 = (int)(SWIG_As_int(obj3));
11832 if (SWIG_arg_fail(4)) SWIG_fail;
11833 }
11834 }
11835 {
11836 PyThreadState* __tstate = wxPyBeginAllowThreads();
11837 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11838
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 {
11843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11844 }
11845 {
11846 if (created2)
11847 delete arg2;
11848 }
11849 return resultobj;
11850 fail:
11851 {
11852 if (created2)
11853 delete arg2;
11854 }
11855 return NULL;
11856 }
11857
11858
11859 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11860 PyObject *resultobj;
11861 wxImage *arg1 = (wxImage *) 0 ;
11862 wxInputStream *arg2 = 0 ;
11863 wxString *arg3 = 0 ;
11864 int arg4 = (int) -1 ;
11865 bool result;
11866 wxPyInputStream *temp2 ;
11867 bool created2 ;
11868 bool temp3 = false ;
11869 PyObject * obj0 = 0 ;
11870 PyObject * obj1 = 0 ;
11871 PyObject * obj2 = 0 ;
11872 PyObject * obj3 = 0 ;
11873 char *kwnames[] = {
11874 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11875 };
11876
11877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11882 arg2 = temp2->m_wxis;
11883 created2 = false;
11884 } else {
11885 PyErr_Clear(); // clear the failure of the wxPyConvert above
11886 arg2 = wxPyCBInputStream_create(obj1, false);
11887 if (arg2 == NULL) {
11888 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11889 SWIG_fail;
11890 }
11891 created2 = true;
11892 }
11893 }
11894 {
11895 arg3 = wxString_in_helper(obj2);
11896 if (arg3 == NULL) SWIG_fail;
11897 temp3 = true;
11898 }
11899 if (obj3) {
11900 {
11901 arg4 = (int)(SWIG_As_int(obj3));
11902 if (SWIG_arg_fail(4)) SWIG_fail;
11903 }
11904 }
11905 {
11906 PyThreadState* __tstate = wxPyBeginAllowThreads();
11907 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11908
11909 wxPyEndAllowThreads(__tstate);
11910 if (PyErr_Occurred()) SWIG_fail;
11911 }
11912 {
11913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11914 }
11915 {
11916 if (created2)
11917 delete arg2;
11918 }
11919 {
11920 if (temp3)
11921 delete arg3;
11922 }
11923 return resultobj;
11924 fail:
11925 {
11926 if (created2)
11927 delete arg2;
11928 }
11929 {
11930 if (temp3)
11931 delete arg3;
11932 }
11933 return NULL;
11934 }
11935
11936
11937 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11938 PyObject *resultobj;
11939 wxImage *arg1 = (wxImage *) 0 ;
11940 bool result;
11941 PyObject * obj0 = 0 ;
11942 char *kwnames[] = {
11943 (char *) "self", NULL
11944 };
11945
11946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11948 if (SWIG_arg_fail(1)) SWIG_fail;
11949 {
11950 PyThreadState* __tstate = wxPyBeginAllowThreads();
11951 result = (bool)(arg1)->Ok();
11952
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 {
11957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11958 }
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj;
11967 wxImage *arg1 = (wxImage *) 0 ;
11968 int result;
11969 PyObject * obj0 = 0 ;
11970 char *kwnames[] = {
11971 (char *) "self", NULL
11972 };
11973
11974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
11975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11976 if (SWIG_arg_fail(1)) SWIG_fail;
11977 {
11978 PyThreadState* __tstate = wxPyBeginAllowThreads();
11979 result = (int)(arg1)->GetWidth();
11980
11981 wxPyEndAllowThreads(__tstate);
11982 if (PyErr_Occurred()) SWIG_fail;
11983 }
11984 {
11985 resultobj = SWIG_From_int((int)(result));
11986 }
11987 return resultobj;
11988 fail:
11989 return NULL;
11990 }
11991
11992
11993 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
11994 PyObject *resultobj;
11995 wxImage *arg1 = (wxImage *) 0 ;
11996 int result;
11997 PyObject * obj0 = 0 ;
11998 char *kwnames[] = {
11999 (char *) "self", NULL
12000 };
12001
12002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12004 if (SWIG_arg_fail(1)) SWIG_fail;
12005 {
12006 PyThreadState* __tstate = wxPyBeginAllowThreads();
12007 result = (int)(arg1)->GetHeight();
12008
12009 wxPyEndAllowThreads(__tstate);
12010 if (PyErr_Occurred()) SWIG_fail;
12011 }
12012 {
12013 resultobj = SWIG_From_int((int)(result));
12014 }
12015 return resultobj;
12016 fail:
12017 return NULL;
12018 }
12019
12020
12021 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12022 PyObject *resultobj;
12023 wxImage *arg1 = (wxImage *) 0 ;
12024 wxSize result;
12025 PyObject * obj0 = 0 ;
12026 char *kwnames[] = {
12027 (char *) "self", NULL
12028 };
12029
12030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12032 if (SWIG_arg_fail(1)) SWIG_fail;
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 result = wxImage_GetSize(arg1);
12036
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 {
12041 wxSize * resultptr;
12042 resultptr = new wxSize((wxSize &)(result));
12043 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12044 }
12045 return resultobj;
12046 fail:
12047 return NULL;
12048 }
12049
12050
12051 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12052 PyObject *resultobj;
12053 wxImage *arg1 = (wxImage *) 0 ;
12054 wxRect *arg2 = 0 ;
12055 SwigValueWrapper<wxImage > result;
12056 wxRect temp2 ;
12057 PyObject * obj0 = 0 ;
12058 PyObject * obj1 = 0 ;
12059 char *kwnames[] = {
12060 (char *) "self",(char *) "rect", NULL
12061 };
12062
12063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12065 if (SWIG_arg_fail(1)) SWIG_fail;
12066 {
12067 arg2 = &temp2;
12068 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12069 }
12070 {
12071 PyThreadState* __tstate = wxPyBeginAllowThreads();
12072 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12073
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 {
12078 wxImage * resultptr;
12079 resultptr = new wxImage((wxImage &)(result));
12080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12081 }
12082 return resultobj;
12083 fail:
12084 return NULL;
12085 }
12086
12087
12088 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12089 PyObject *resultobj;
12090 wxImage *arg1 = (wxImage *) 0 ;
12091 SwigValueWrapper<wxImage > result;
12092 PyObject * obj0 = 0 ;
12093 char *kwnames[] = {
12094 (char *) "self", NULL
12095 };
12096
12097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12099 if (SWIG_arg_fail(1)) SWIG_fail;
12100 {
12101 PyThreadState* __tstate = wxPyBeginAllowThreads();
12102 result = (arg1)->Copy();
12103
12104 wxPyEndAllowThreads(__tstate);
12105 if (PyErr_Occurred()) SWIG_fail;
12106 }
12107 {
12108 wxImage * resultptr;
12109 resultptr = new wxImage((wxImage &)(result));
12110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12111 }
12112 return resultobj;
12113 fail:
12114 return NULL;
12115 }
12116
12117
12118 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj;
12120 wxImage *arg1 = (wxImage *) 0 ;
12121 wxImage *arg2 = 0 ;
12122 int arg3 ;
12123 int arg4 ;
12124 PyObject * obj0 = 0 ;
12125 PyObject * obj1 = 0 ;
12126 PyObject * obj2 = 0 ;
12127 PyObject * obj3 = 0 ;
12128 char *kwnames[] = {
12129 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12130 };
12131
12132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12134 if (SWIG_arg_fail(1)) SWIG_fail;
12135 {
12136 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12137 if (SWIG_arg_fail(2)) SWIG_fail;
12138 if (arg2 == NULL) {
12139 SWIG_null_ref("wxImage");
12140 }
12141 if (SWIG_arg_fail(2)) SWIG_fail;
12142 }
12143 {
12144 arg3 = (int)(SWIG_As_int(obj2));
12145 if (SWIG_arg_fail(3)) SWIG_fail;
12146 }
12147 {
12148 arg4 = (int)(SWIG_As_int(obj3));
12149 if (SWIG_arg_fail(4)) SWIG_fail;
12150 }
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12154
12155 wxPyEndAllowThreads(__tstate);
12156 if (PyErr_Occurred()) SWIG_fail;
12157 }
12158 Py_INCREF(Py_None); resultobj = Py_None;
12159 return resultobj;
12160 fail:
12161 return NULL;
12162 }
12163
12164
12165 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12166 PyObject *resultobj;
12167 wxImage *arg1 = (wxImage *) 0 ;
12168 PyObject *result;
12169 PyObject * obj0 = 0 ;
12170 char *kwnames[] = {
12171 (char *) "self", NULL
12172 };
12173
12174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12176 if (SWIG_arg_fail(1)) SWIG_fail;
12177 {
12178 PyThreadState* __tstate = wxPyBeginAllowThreads();
12179 result = (PyObject *)wxImage_GetData(arg1);
12180
12181 wxPyEndAllowThreads(__tstate);
12182 if (PyErr_Occurred()) SWIG_fail;
12183 }
12184 resultobj = result;
12185 return resultobj;
12186 fail:
12187 return NULL;
12188 }
12189
12190
12191 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12192 PyObject *resultobj;
12193 wxImage *arg1 = (wxImage *) 0 ;
12194 PyObject *arg2 = (PyObject *) 0 ;
12195 PyObject * obj0 = 0 ;
12196 PyObject * obj1 = 0 ;
12197 char *kwnames[] = {
12198 (char *) "self",(char *) "data", NULL
12199 };
12200
12201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12203 if (SWIG_arg_fail(1)) SWIG_fail;
12204 arg2 = obj1;
12205 {
12206 PyThreadState* __tstate = wxPyBeginAllowThreads();
12207 wxImage_SetData(arg1,arg2);
12208
12209 wxPyEndAllowThreads(__tstate);
12210 if (PyErr_Occurred()) SWIG_fail;
12211 }
12212 Py_INCREF(Py_None); resultobj = Py_None;
12213 return resultobj;
12214 fail:
12215 return NULL;
12216 }
12217
12218
12219 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12220 PyObject *resultobj;
12221 wxImage *arg1 = (wxImage *) 0 ;
12222 PyObject *result;
12223 PyObject * obj0 = 0 ;
12224 char *kwnames[] = {
12225 (char *) "self", NULL
12226 };
12227
12228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12230 if (SWIG_arg_fail(1)) SWIG_fail;
12231 {
12232 PyThreadState* __tstate = wxPyBeginAllowThreads();
12233 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12234
12235 wxPyEndAllowThreads(__tstate);
12236 if (PyErr_Occurred()) SWIG_fail;
12237 }
12238 resultobj = result;
12239 return resultobj;
12240 fail:
12241 return NULL;
12242 }
12243
12244
12245 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12246 PyObject *resultobj;
12247 wxImage *arg1 = (wxImage *) 0 ;
12248 PyObject *arg2 = (PyObject *) 0 ;
12249 PyObject * obj0 = 0 ;
12250 PyObject * obj1 = 0 ;
12251 char *kwnames[] = {
12252 (char *) "self",(char *) "data", NULL
12253 };
12254
12255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12257 if (SWIG_arg_fail(1)) SWIG_fail;
12258 arg2 = obj1;
12259 {
12260 PyThreadState* __tstate = wxPyBeginAllowThreads();
12261 wxImage_SetDataBuffer(arg1,arg2);
12262
12263 wxPyEndAllowThreads(__tstate);
12264 if (PyErr_Occurred()) SWIG_fail;
12265 }
12266 Py_INCREF(Py_None); resultobj = Py_None;
12267 return resultobj;
12268 fail:
12269 return NULL;
12270 }
12271
12272
12273 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12274 PyObject *resultobj;
12275 wxImage *arg1 = (wxImage *) 0 ;
12276 PyObject *result;
12277 PyObject * obj0 = 0 ;
12278 char *kwnames[] = {
12279 (char *) "self", NULL
12280 };
12281
12282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12284 if (SWIG_arg_fail(1)) SWIG_fail;
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 result = (PyObject *)wxImage_GetAlphaData(arg1);
12288
12289 wxPyEndAllowThreads(__tstate);
12290 if (PyErr_Occurred()) SWIG_fail;
12291 }
12292 resultobj = result;
12293 return resultobj;
12294 fail:
12295 return NULL;
12296 }
12297
12298
12299 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12300 PyObject *resultobj;
12301 wxImage *arg1 = (wxImage *) 0 ;
12302 PyObject *arg2 = (PyObject *) 0 ;
12303 PyObject * obj0 = 0 ;
12304 PyObject * obj1 = 0 ;
12305 char *kwnames[] = {
12306 (char *) "self",(char *) "data", NULL
12307 };
12308
12309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12311 if (SWIG_arg_fail(1)) SWIG_fail;
12312 arg2 = obj1;
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 wxImage_SetAlphaData(arg1,arg2);
12316
12317 wxPyEndAllowThreads(__tstate);
12318 if (PyErr_Occurred()) SWIG_fail;
12319 }
12320 Py_INCREF(Py_None); resultobj = Py_None;
12321 return resultobj;
12322 fail:
12323 return NULL;
12324 }
12325
12326
12327 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12328 PyObject *resultobj;
12329 wxImage *arg1 = (wxImage *) 0 ;
12330 PyObject *result;
12331 PyObject * obj0 = 0 ;
12332 char *kwnames[] = {
12333 (char *) "self", NULL
12334 };
12335
12336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12338 if (SWIG_arg_fail(1)) SWIG_fail;
12339 {
12340 PyThreadState* __tstate = wxPyBeginAllowThreads();
12341 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12342
12343 wxPyEndAllowThreads(__tstate);
12344 if (PyErr_Occurred()) SWIG_fail;
12345 }
12346 resultobj = result;
12347 return resultobj;
12348 fail:
12349 return NULL;
12350 }
12351
12352
12353 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12354 PyObject *resultobj;
12355 wxImage *arg1 = (wxImage *) 0 ;
12356 PyObject *arg2 = (PyObject *) 0 ;
12357 PyObject * obj0 = 0 ;
12358 PyObject * obj1 = 0 ;
12359 char *kwnames[] = {
12360 (char *) "self",(char *) "data", NULL
12361 };
12362
12363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12365 if (SWIG_arg_fail(1)) SWIG_fail;
12366 arg2 = obj1;
12367 {
12368 PyThreadState* __tstate = wxPyBeginAllowThreads();
12369 wxImage_SetAlphaBuffer(arg1,arg2);
12370
12371 wxPyEndAllowThreads(__tstate);
12372 if (PyErr_Occurred()) SWIG_fail;
12373 }
12374 Py_INCREF(Py_None); resultobj = Py_None;
12375 return resultobj;
12376 fail:
12377 return NULL;
12378 }
12379
12380
12381 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12382 PyObject *resultobj;
12383 wxImage *arg1 = (wxImage *) 0 ;
12384 unsigned char arg2 ;
12385 unsigned char arg3 ;
12386 unsigned char arg4 ;
12387 PyObject * obj0 = 0 ;
12388 PyObject * obj1 = 0 ;
12389 PyObject * obj2 = 0 ;
12390 PyObject * obj3 = 0 ;
12391 char *kwnames[] = {
12392 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12393 };
12394
12395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12397 if (SWIG_arg_fail(1)) SWIG_fail;
12398 {
12399 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12400 if (SWIG_arg_fail(2)) SWIG_fail;
12401 }
12402 {
12403 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12404 if (SWIG_arg_fail(3)) SWIG_fail;
12405 }
12406 {
12407 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12408 if (SWIG_arg_fail(4)) SWIG_fail;
12409 }
12410 {
12411 PyThreadState* __tstate = wxPyBeginAllowThreads();
12412 (arg1)->SetMaskColour(arg2,arg3,arg4);
12413
12414 wxPyEndAllowThreads(__tstate);
12415 if (PyErr_Occurred()) SWIG_fail;
12416 }
12417 Py_INCREF(Py_None); resultobj = Py_None;
12418 return resultobj;
12419 fail:
12420 return NULL;
12421 }
12422
12423
12424 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12425 PyObject *resultobj;
12426 wxImage *arg1 = (wxImage *) 0 ;
12427 unsigned char result;
12428 PyObject * obj0 = 0 ;
12429 char *kwnames[] = {
12430 (char *) "self", NULL
12431 };
12432
12433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12435 if (SWIG_arg_fail(1)) SWIG_fail;
12436 {
12437 PyThreadState* __tstate = wxPyBeginAllowThreads();
12438 result = (unsigned char)(arg1)->GetMaskRed();
12439
12440 wxPyEndAllowThreads(__tstate);
12441 if (PyErr_Occurred()) SWIG_fail;
12442 }
12443 {
12444 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12445 }
12446 return resultobj;
12447 fail:
12448 return NULL;
12449 }
12450
12451
12452 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12453 PyObject *resultobj;
12454 wxImage *arg1 = (wxImage *) 0 ;
12455 unsigned char result;
12456 PyObject * obj0 = 0 ;
12457 char *kwnames[] = {
12458 (char *) "self", NULL
12459 };
12460
12461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12463 if (SWIG_arg_fail(1)) SWIG_fail;
12464 {
12465 PyThreadState* __tstate = wxPyBeginAllowThreads();
12466 result = (unsigned char)(arg1)->GetMaskGreen();
12467
12468 wxPyEndAllowThreads(__tstate);
12469 if (PyErr_Occurred()) SWIG_fail;
12470 }
12471 {
12472 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12473 }
12474 return resultobj;
12475 fail:
12476 return NULL;
12477 }
12478
12479
12480 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12481 PyObject *resultobj;
12482 wxImage *arg1 = (wxImage *) 0 ;
12483 unsigned char result;
12484 PyObject * obj0 = 0 ;
12485 char *kwnames[] = {
12486 (char *) "self", NULL
12487 };
12488
12489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12491 if (SWIG_arg_fail(1)) SWIG_fail;
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 result = (unsigned char)(arg1)->GetMaskBlue();
12495
12496 wxPyEndAllowThreads(__tstate);
12497 if (PyErr_Occurred()) SWIG_fail;
12498 }
12499 {
12500 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12501 }
12502 return resultobj;
12503 fail:
12504 return NULL;
12505 }
12506
12507
12508 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12509 PyObject *resultobj;
12510 wxImage *arg1 = (wxImage *) 0 ;
12511 bool arg2 = (bool) true ;
12512 PyObject * obj0 = 0 ;
12513 PyObject * obj1 = 0 ;
12514 char *kwnames[] = {
12515 (char *) "self",(char *) "mask", NULL
12516 };
12517
12518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12520 if (SWIG_arg_fail(1)) SWIG_fail;
12521 if (obj1) {
12522 {
12523 arg2 = (bool)(SWIG_As_bool(obj1));
12524 if (SWIG_arg_fail(2)) SWIG_fail;
12525 }
12526 }
12527 {
12528 PyThreadState* __tstate = wxPyBeginAllowThreads();
12529 (arg1)->SetMask(arg2);
12530
12531 wxPyEndAllowThreads(__tstate);
12532 if (PyErr_Occurred()) SWIG_fail;
12533 }
12534 Py_INCREF(Py_None); resultobj = Py_None;
12535 return resultobj;
12536 fail:
12537 return NULL;
12538 }
12539
12540
12541 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12542 PyObject *resultobj;
12543 wxImage *arg1 = (wxImage *) 0 ;
12544 bool result;
12545 PyObject * obj0 = 0 ;
12546 char *kwnames[] = {
12547 (char *) "self", NULL
12548 };
12549
12550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12552 if (SWIG_arg_fail(1)) SWIG_fail;
12553 {
12554 PyThreadState* __tstate = wxPyBeginAllowThreads();
12555 result = (bool)(arg1)->HasMask();
12556
12557 wxPyEndAllowThreads(__tstate);
12558 if (PyErr_Occurred()) SWIG_fail;
12559 }
12560 {
12561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12562 }
12563 return resultobj;
12564 fail:
12565 return NULL;
12566 }
12567
12568
12569 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12570 PyObject *resultobj;
12571 wxImage *arg1 = (wxImage *) 0 ;
12572 double arg2 ;
12573 wxPoint *arg3 = 0 ;
12574 bool arg4 = (bool) true ;
12575 wxPoint *arg5 = (wxPoint *) NULL ;
12576 SwigValueWrapper<wxImage > result;
12577 wxPoint temp3 ;
12578 PyObject * obj0 = 0 ;
12579 PyObject * obj1 = 0 ;
12580 PyObject * obj2 = 0 ;
12581 PyObject * obj3 = 0 ;
12582 PyObject * obj4 = 0 ;
12583 char *kwnames[] = {
12584 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12585 };
12586
12587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12589 if (SWIG_arg_fail(1)) SWIG_fail;
12590 {
12591 arg2 = (double)(SWIG_As_double(obj1));
12592 if (SWIG_arg_fail(2)) SWIG_fail;
12593 }
12594 {
12595 arg3 = &temp3;
12596 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12597 }
12598 if (obj3) {
12599 {
12600 arg4 = (bool)(SWIG_As_bool(obj3));
12601 if (SWIG_arg_fail(4)) SWIG_fail;
12602 }
12603 }
12604 if (obj4) {
12605 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12606 if (SWIG_arg_fail(5)) SWIG_fail;
12607 }
12608 {
12609 PyThreadState* __tstate = wxPyBeginAllowThreads();
12610 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12611
12612 wxPyEndAllowThreads(__tstate);
12613 if (PyErr_Occurred()) SWIG_fail;
12614 }
12615 {
12616 wxImage * resultptr;
12617 resultptr = new wxImage((wxImage &)(result));
12618 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12619 }
12620 return resultobj;
12621 fail:
12622 return NULL;
12623 }
12624
12625
12626 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12627 PyObject *resultobj;
12628 wxImage *arg1 = (wxImage *) 0 ;
12629 bool arg2 = (bool) true ;
12630 SwigValueWrapper<wxImage > result;
12631 PyObject * obj0 = 0 ;
12632 PyObject * obj1 = 0 ;
12633 char *kwnames[] = {
12634 (char *) "self",(char *) "clockwise", NULL
12635 };
12636
12637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12639 if (SWIG_arg_fail(1)) SWIG_fail;
12640 if (obj1) {
12641 {
12642 arg2 = (bool)(SWIG_As_bool(obj1));
12643 if (SWIG_arg_fail(2)) SWIG_fail;
12644 }
12645 }
12646 {
12647 PyThreadState* __tstate = wxPyBeginAllowThreads();
12648 result = (arg1)->Rotate90(arg2);
12649
12650 wxPyEndAllowThreads(__tstate);
12651 if (PyErr_Occurred()) SWIG_fail;
12652 }
12653 {
12654 wxImage * resultptr;
12655 resultptr = new wxImage((wxImage &)(result));
12656 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12657 }
12658 return resultobj;
12659 fail:
12660 return NULL;
12661 }
12662
12663
12664 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12665 PyObject *resultobj;
12666 wxImage *arg1 = (wxImage *) 0 ;
12667 bool arg2 = (bool) true ;
12668 SwigValueWrapper<wxImage > result;
12669 PyObject * obj0 = 0 ;
12670 PyObject * obj1 = 0 ;
12671 char *kwnames[] = {
12672 (char *) "self",(char *) "horizontally", NULL
12673 };
12674
12675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12677 if (SWIG_arg_fail(1)) SWIG_fail;
12678 if (obj1) {
12679 {
12680 arg2 = (bool)(SWIG_As_bool(obj1));
12681 if (SWIG_arg_fail(2)) SWIG_fail;
12682 }
12683 }
12684 {
12685 PyThreadState* __tstate = wxPyBeginAllowThreads();
12686 result = (arg1)->Mirror(arg2);
12687
12688 wxPyEndAllowThreads(__tstate);
12689 if (PyErr_Occurred()) SWIG_fail;
12690 }
12691 {
12692 wxImage * resultptr;
12693 resultptr = new wxImage((wxImage &)(result));
12694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12695 }
12696 return resultobj;
12697 fail:
12698 return NULL;
12699 }
12700
12701
12702 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12703 PyObject *resultobj;
12704 wxImage *arg1 = (wxImage *) 0 ;
12705 unsigned char arg2 ;
12706 unsigned char arg3 ;
12707 unsigned char arg4 ;
12708 unsigned char arg5 ;
12709 unsigned char arg6 ;
12710 unsigned char arg7 ;
12711 PyObject * obj0 = 0 ;
12712 PyObject * obj1 = 0 ;
12713 PyObject * obj2 = 0 ;
12714 PyObject * obj3 = 0 ;
12715 PyObject * obj4 = 0 ;
12716 PyObject * obj5 = 0 ;
12717 PyObject * obj6 = 0 ;
12718 char *kwnames[] = {
12719 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12720 };
12721
12722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12724 if (SWIG_arg_fail(1)) SWIG_fail;
12725 {
12726 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12727 if (SWIG_arg_fail(2)) SWIG_fail;
12728 }
12729 {
12730 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12731 if (SWIG_arg_fail(3)) SWIG_fail;
12732 }
12733 {
12734 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12735 if (SWIG_arg_fail(4)) SWIG_fail;
12736 }
12737 {
12738 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12739 if (SWIG_arg_fail(5)) SWIG_fail;
12740 }
12741 {
12742 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12743 if (SWIG_arg_fail(6)) SWIG_fail;
12744 }
12745 {
12746 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12747 if (SWIG_arg_fail(7)) SWIG_fail;
12748 }
12749 {
12750 PyThreadState* __tstate = wxPyBeginAllowThreads();
12751 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12752
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 Py_INCREF(Py_None); resultobj = Py_None;
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12764 PyObject *resultobj;
12765 wxImage *arg1 = (wxImage *) 0 ;
12766 unsigned char arg2 ;
12767 unsigned char arg3 ;
12768 unsigned char arg4 ;
12769 SwigValueWrapper<wxImage > result;
12770 PyObject * obj0 = 0 ;
12771 PyObject * obj1 = 0 ;
12772 PyObject * obj2 = 0 ;
12773 PyObject * obj3 = 0 ;
12774 char *kwnames[] = {
12775 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12776 };
12777
12778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12780 if (SWIG_arg_fail(1)) SWIG_fail;
12781 {
12782 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12783 if (SWIG_arg_fail(2)) SWIG_fail;
12784 }
12785 {
12786 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12787 if (SWIG_arg_fail(3)) SWIG_fail;
12788 }
12789 {
12790 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12791 if (SWIG_arg_fail(4)) SWIG_fail;
12792 }
12793 {
12794 PyThreadState* __tstate = wxPyBeginAllowThreads();
12795 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12796
12797 wxPyEndAllowThreads(__tstate);
12798 if (PyErr_Occurred()) SWIG_fail;
12799 }
12800 {
12801 wxImage * resultptr;
12802 resultptr = new wxImage((wxImage &)(result));
12803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12804 }
12805 return resultobj;
12806 fail:
12807 return NULL;
12808 }
12809
12810
12811 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12812 PyObject *resultobj;
12813 wxImage *arg1 = (wxImage *) 0 ;
12814 wxString *arg2 = 0 ;
12815 wxString *arg3 = 0 ;
12816 bool temp2 = false ;
12817 bool temp3 = false ;
12818 PyObject * obj0 = 0 ;
12819 PyObject * obj1 = 0 ;
12820 PyObject * obj2 = 0 ;
12821 char *kwnames[] = {
12822 (char *) "self",(char *) "name",(char *) "value", NULL
12823 };
12824
12825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12827 if (SWIG_arg_fail(1)) SWIG_fail;
12828 {
12829 arg2 = wxString_in_helper(obj1);
12830 if (arg2 == NULL) SWIG_fail;
12831 temp2 = true;
12832 }
12833 {
12834 arg3 = wxString_in_helper(obj2);
12835 if (arg3 == NULL) SWIG_fail;
12836 temp3 = true;
12837 }
12838 {
12839 PyThreadState* __tstate = wxPyBeginAllowThreads();
12840 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12841
12842 wxPyEndAllowThreads(__tstate);
12843 if (PyErr_Occurred()) SWIG_fail;
12844 }
12845 Py_INCREF(Py_None); resultobj = Py_None;
12846 {
12847 if (temp2)
12848 delete arg2;
12849 }
12850 {
12851 if (temp3)
12852 delete arg3;
12853 }
12854 return resultobj;
12855 fail:
12856 {
12857 if (temp2)
12858 delete arg2;
12859 }
12860 {
12861 if (temp3)
12862 delete arg3;
12863 }
12864 return NULL;
12865 }
12866
12867
12868 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12869 PyObject *resultobj;
12870 wxImage *arg1 = (wxImage *) 0 ;
12871 wxString *arg2 = 0 ;
12872 int arg3 ;
12873 bool temp2 = false ;
12874 PyObject * obj0 = 0 ;
12875 PyObject * obj1 = 0 ;
12876 PyObject * obj2 = 0 ;
12877 char *kwnames[] = {
12878 (char *) "self",(char *) "name",(char *) "value", NULL
12879 };
12880
12881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12883 if (SWIG_arg_fail(1)) SWIG_fail;
12884 {
12885 arg2 = wxString_in_helper(obj1);
12886 if (arg2 == NULL) SWIG_fail;
12887 temp2 = true;
12888 }
12889 {
12890 arg3 = (int)(SWIG_As_int(obj2));
12891 if (SWIG_arg_fail(3)) SWIG_fail;
12892 }
12893 {
12894 PyThreadState* __tstate = wxPyBeginAllowThreads();
12895 (arg1)->SetOption((wxString const &)*arg2,arg3);
12896
12897 wxPyEndAllowThreads(__tstate);
12898 if (PyErr_Occurred()) SWIG_fail;
12899 }
12900 Py_INCREF(Py_None); resultobj = Py_None;
12901 {
12902 if (temp2)
12903 delete arg2;
12904 }
12905 return resultobj;
12906 fail:
12907 {
12908 if (temp2)
12909 delete arg2;
12910 }
12911 return NULL;
12912 }
12913
12914
12915 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12916 PyObject *resultobj;
12917 wxImage *arg1 = (wxImage *) 0 ;
12918 wxString *arg2 = 0 ;
12919 wxString result;
12920 bool temp2 = false ;
12921 PyObject * obj0 = 0 ;
12922 PyObject * obj1 = 0 ;
12923 char *kwnames[] = {
12924 (char *) "self",(char *) "name", NULL
12925 };
12926
12927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12929 if (SWIG_arg_fail(1)) SWIG_fail;
12930 {
12931 arg2 = wxString_in_helper(obj1);
12932 if (arg2 == NULL) SWIG_fail;
12933 temp2 = true;
12934 }
12935 {
12936 PyThreadState* __tstate = wxPyBeginAllowThreads();
12937 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12938
12939 wxPyEndAllowThreads(__tstate);
12940 if (PyErr_Occurred()) SWIG_fail;
12941 }
12942 {
12943 #if wxUSE_UNICODE
12944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12945 #else
12946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12947 #endif
12948 }
12949 {
12950 if (temp2)
12951 delete arg2;
12952 }
12953 return resultobj;
12954 fail:
12955 {
12956 if (temp2)
12957 delete arg2;
12958 }
12959 return NULL;
12960 }
12961
12962
12963 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12964 PyObject *resultobj;
12965 wxImage *arg1 = (wxImage *) 0 ;
12966 wxString *arg2 = 0 ;
12967 int result;
12968 bool temp2 = false ;
12969 PyObject * obj0 = 0 ;
12970 PyObject * obj1 = 0 ;
12971 char *kwnames[] = {
12972 (char *) "self",(char *) "name", NULL
12973 };
12974
12975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
12976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12977 if (SWIG_arg_fail(1)) SWIG_fail;
12978 {
12979 arg2 = wxString_in_helper(obj1);
12980 if (arg2 == NULL) SWIG_fail;
12981 temp2 = true;
12982 }
12983 {
12984 PyThreadState* __tstate = wxPyBeginAllowThreads();
12985 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
12986
12987 wxPyEndAllowThreads(__tstate);
12988 if (PyErr_Occurred()) SWIG_fail;
12989 }
12990 {
12991 resultobj = SWIG_From_int((int)(result));
12992 }
12993 {
12994 if (temp2)
12995 delete arg2;
12996 }
12997 return resultobj;
12998 fail:
12999 {
13000 if (temp2)
13001 delete arg2;
13002 }
13003 return NULL;
13004 }
13005
13006
13007 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13008 PyObject *resultobj;
13009 wxImage *arg1 = (wxImage *) 0 ;
13010 wxString *arg2 = 0 ;
13011 bool result;
13012 bool temp2 = false ;
13013 PyObject * obj0 = 0 ;
13014 PyObject * obj1 = 0 ;
13015 char *kwnames[] = {
13016 (char *) "self",(char *) "name", NULL
13017 };
13018
13019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13021 if (SWIG_arg_fail(1)) SWIG_fail;
13022 {
13023 arg2 = wxString_in_helper(obj1);
13024 if (arg2 == NULL) SWIG_fail;
13025 temp2 = true;
13026 }
13027 {
13028 PyThreadState* __tstate = wxPyBeginAllowThreads();
13029 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13030
13031 wxPyEndAllowThreads(__tstate);
13032 if (PyErr_Occurred()) SWIG_fail;
13033 }
13034 {
13035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13036 }
13037 {
13038 if (temp2)
13039 delete arg2;
13040 }
13041 return resultobj;
13042 fail:
13043 {
13044 if (temp2)
13045 delete arg2;
13046 }
13047 return NULL;
13048 }
13049
13050
13051 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13052 PyObject *resultobj;
13053 wxImage *arg1 = (wxImage *) 0 ;
13054 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13055 unsigned long result;
13056 PyObject * obj0 = 0 ;
13057 PyObject * obj1 = 0 ;
13058 char *kwnames[] = {
13059 (char *) "self",(char *) "stopafter", NULL
13060 };
13061
13062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13064 if (SWIG_arg_fail(1)) SWIG_fail;
13065 if (obj1) {
13066 {
13067 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13068 if (SWIG_arg_fail(2)) SWIG_fail;
13069 }
13070 }
13071 {
13072 PyThreadState* __tstate = wxPyBeginAllowThreads();
13073 result = (unsigned long)(arg1)->CountColours(arg2);
13074
13075 wxPyEndAllowThreads(__tstate);
13076 if (PyErr_Occurred()) SWIG_fail;
13077 }
13078 {
13079 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13080 }
13081 return resultobj;
13082 fail:
13083 return NULL;
13084 }
13085
13086
13087 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13088 PyObject *resultobj;
13089 wxImage *arg1 = (wxImage *) 0 ;
13090 wxImageHistogram *arg2 = 0 ;
13091 unsigned long result;
13092 PyObject * obj0 = 0 ;
13093 PyObject * obj1 = 0 ;
13094 char *kwnames[] = {
13095 (char *) "self",(char *) "h", NULL
13096 };
13097
13098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13100 if (SWIG_arg_fail(1)) SWIG_fail;
13101 {
13102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13103 if (SWIG_arg_fail(2)) SWIG_fail;
13104 if (arg2 == NULL) {
13105 SWIG_null_ref("wxImageHistogram");
13106 }
13107 if (SWIG_arg_fail(2)) SWIG_fail;
13108 }
13109 {
13110 PyThreadState* __tstate = wxPyBeginAllowThreads();
13111 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13112
13113 wxPyEndAllowThreads(__tstate);
13114 if (PyErr_Occurred()) SWIG_fail;
13115 }
13116 {
13117 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13118 }
13119 return resultobj;
13120 fail:
13121 return NULL;
13122 }
13123
13124
13125 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13126 PyObject *resultobj;
13127 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13128 PyObject * obj0 = 0 ;
13129 char *kwnames[] = {
13130 (char *) "handler", NULL
13131 };
13132
13133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13135 if (SWIG_arg_fail(1)) SWIG_fail;
13136 {
13137 PyThreadState* __tstate = wxPyBeginAllowThreads();
13138 wxImage::AddHandler(arg1);
13139
13140 wxPyEndAllowThreads(__tstate);
13141 if (PyErr_Occurred()) SWIG_fail;
13142 }
13143 Py_INCREF(Py_None); resultobj = Py_None;
13144 return resultobj;
13145 fail:
13146 return NULL;
13147 }
13148
13149
13150 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13151 PyObject *resultobj;
13152 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13153 PyObject * obj0 = 0 ;
13154 char *kwnames[] = {
13155 (char *) "handler", NULL
13156 };
13157
13158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13160 if (SWIG_arg_fail(1)) SWIG_fail;
13161 {
13162 PyThreadState* __tstate = wxPyBeginAllowThreads();
13163 wxImage::InsertHandler(arg1);
13164
13165 wxPyEndAllowThreads(__tstate);
13166 if (PyErr_Occurred()) SWIG_fail;
13167 }
13168 Py_INCREF(Py_None); resultobj = Py_None;
13169 return resultobj;
13170 fail:
13171 return NULL;
13172 }
13173
13174
13175 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13176 PyObject *resultobj;
13177 wxString *arg1 = 0 ;
13178 bool result;
13179 bool temp1 = false ;
13180 PyObject * obj0 = 0 ;
13181 char *kwnames[] = {
13182 (char *) "name", NULL
13183 };
13184
13185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13186 {
13187 arg1 = wxString_in_helper(obj0);
13188 if (arg1 == NULL) SWIG_fail;
13189 temp1 = true;
13190 }
13191 {
13192 PyThreadState* __tstate = wxPyBeginAllowThreads();
13193 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13194
13195 wxPyEndAllowThreads(__tstate);
13196 if (PyErr_Occurred()) SWIG_fail;
13197 }
13198 {
13199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13200 }
13201 {
13202 if (temp1)
13203 delete arg1;
13204 }
13205 return resultobj;
13206 fail:
13207 {
13208 if (temp1)
13209 delete arg1;
13210 }
13211 return NULL;
13212 }
13213
13214
13215 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13216 PyObject *resultobj;
13217 wxString result;
13218 char *kwnames[] = {
13219 NULL
13220 };
13221
13222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13223 {
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 result = wxImage::GetImageExtWildcard();
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 return resultobj;
13238 fail:
13239 return NULL;
13240 }
13241
13242
13243 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13244 PyObject *resultobj;
13245 wxImage *arg1 = (wxImage *) 0 ;
13246 int arg2 = (int) -1 ;
13247 wxBitmap result;
13248 PyObject * obj0 = 0 ;
13249 PyObject * obj1 = 0 ;
13250 char *kwnames[] = {
13251 (char *) "self",(char *) "depth", NULL
13252 };
13253
13254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13256 if (SWIG_arg_fail(1)) SWIG_fail;
13257 if (obj1) {
13258 {
13259 arg2 = (int)(SWIG_As_int(obj1));
13260 if (SWIG_arg_fail(2)) SWIG_fail;
13261 }
13262 }
13263 {
13264 if (!wxPyCheckForApp()) SWIG_fail;
13265 PyThreadState* __tstate = wxPyBeginAllowThreads();
13266 result = wxImage_ConvertToBitmap(arg1,arg2);
13267
13268 wxPyEndAllowThreads(__tstate);
13269 if (PyErr_Occurred()) SWIG_fail;
13270 }
13271 {
13272 wxBitmap * resultptr;
13273 resultptr = new wxBitmap((wxBitmap &)(result));
13274 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13275 }
13276 return resultobj;
13277 fail:
13278 return NULL;
13279 }
13280
13281
13282 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13283 PyObject *resultobj;
13284 wxImage *arg1 = (wxImage *) 0 ;
13285 unsigned char arg2 ;
13286 unsigned char arg3 ;
13287 unsigned char arg4 ;
13288 wxBitmap result;
13289 PyObject * obj0 = 0 ;
13290 PyObject * obj1 = 0 ;
13291 PyObject * obj2 = 0 ;
13292 PyObject * obj3 = 0 ;
13293 char *kwnames[] = {
13294 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13295 };
13296
13297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13299 if (SWIG_arg_fail(1)) SWIG_fail;
13300 {
13301 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13302 if (SWIG_arg_fail(2)) SWIG_fail;
13303 }
13304 {
13305 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13306 if (SWIG_arg_fail(3)) SWIG_fail;
13307 }
13308 {
13309 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13310 if (SWIG_arg_fail(4)) SWIG_fail;
13311 }
13312 {
13313 if (!wxPyCheckForApp()) SWIG_fail;
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13316
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 {
13321 wxBitmap * resultptr;
13322 resultptr = new wxBitmap((wxBitmap &)(result));
13323 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13324 }
13325 return resultobj;
13326 fail:
13327 return NULL;
13328 }
13329
13330
13331 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13332 PyObject *obj;
13333 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13334 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13335 Py_INCREF(obj);
13336 return Py_BuildValue((char *)"");
13337 }
13338 static int _wrap_NullImage_set(PyObject *) {
13339 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13340 return 1;
13341 }
13342
13343
13344 static PyObject *_wrap_NullImage_get(void) {
13345 PyObject *pyobj;
13346
13347 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13348 return pyobj;
13349 }
13350
13351
13352 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13353 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13354 return 1;
13355 }
13356
13357
13358 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13359 PyObject *pyobj;
13360
13361 {
13362 #if wxUSE_UNICODE
13363 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13364 #else
13365 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13366 #endif
13367 }
13368 return pyobj;
13369 }
13370
13371
13372 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13373 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13374 return 1;
13375 }
13376
13377
13378 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13379 PyObject *pyobj;
13380
13381 {
13382 #if wxUSE_UNICODE
13383 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13384 #else
13385 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13386 #endif
13387 }
13388 return pyobj;
13389 }
13390
13391
13392 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13393 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13394 return 1;
13395 }
13396
13397
13398 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13399 PyObject *pyobj;
13400
13401 {
13402 #if wxUSE_UNICODE
13403 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13404 #else
13405 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13406 #endif
13407 }
13408 return pyobj;
13409 }
13410
13411
13412 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13413 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13414 return 1;
13415 }
13416
13417
13418 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13419 PyObject *pyobj;
13420
13421 {
13422 #if wxUSE_UNICODE
13423 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13424 #else
13425 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13426 #endif
13427 }
13428 return pyobj;
13429 }
13430
13431
13432 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13433 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13434 return 1;
13435 }
13436
13437
13438 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13439 PyObject *pyobj;
13440
13441 {
13442 #if wxUSE_UNICODE
13443 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13444 #else
13445 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13446 #endif
13447 }
13448 return pyobj;
13449 }
13450
13451
13452 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13453 PyObject *resultobj;
13454 wxBMPHandler *result;
13455 char *kwnames[] = {
13456 NULL
13457 };
13458
13459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13460 {
13461 PyThreadState* __tstate = wxPyBeginAllowThreads();
13462 result = (wxBMPHandler *)new wxBMPHandler();
13463
13464 wxPyEndAllowThreads(__tstate);
13465 if (PyErr_Occurred()) SWIG_fail;
13466 }
13467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13468 return resultobj;
13469 fail:
13470 return NULL;
13471 }
13472
13473
13474 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13475 PyObject *obj;
13476 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13477 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13478 Py_INCREF(obj);
13479 return Py_BuildValue((char *)"");
13480 }
13481 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj;
13483 wxICOHandler *result;
13484 char *kwnames[] = {
13485 NULL
13486 };
13487
13488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13489 {
13490 PyThreadState* __tstate = wxPyBeginAllowThreads();
13491 result = (wxICOHandler *)new wxICOHandler();
13492
13493 wxPyEndAllowThreads(__tstate);
13494 if (PyErr_Occurred()) SWIG_fail;
13495 }
13496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13497 return resultobj;
13498 fail:
13499 return NULL;
13500 }
13501
13502
13503 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13504 PyObject *obj;
13505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13506 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13507 Py_INCREF(obj);
13508 return Py_BuildValue((char *)"");
13509 }
13510 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj;
13512 wxCURHandler *result;
13513 char *kwnames[] = {
13514 NULL
13515 };
13516
13517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13518 {
13519 PyThreadState* __tstate = wxPyBeginAllowThreads();
13520 result = (wxCURHandler *)new wxCURHandler();
13521
13522 wxPyEndAllowThreads(__tstate);
13523 if (PyErr_Occurred()) SWIG_fail;
13524 }
13525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13526 return resultobj;
13527 fail:
13528 return NULL;
13529 }
13530
13531
13532 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13533 PyObject *obj;
13534 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13535 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13536 Py_INCREF(obj);
13537 return Py_BuildValue((char *)"");
13538 }
13539 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13540 PyObject *resultobj;
13541 wxANIHandler *result;
13542 char *kwnames[] = {
13543 NULL
13544 };
13545
13546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13547 {
13548 PyThreadState* __tstate = wxPyBeginAllowThreads();
13549 result = (wxANIHandler *)new wxANIHandler();
13550
13551 wxPyEndAllowThreads(__tstate);
13552 if (PyErr_Occurred()) SWIG_fail;
13553 }
13554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13555 return resultobj;
13556 fail:
13557 return NULL;
13558 }
13559
13560
13561 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13562 PyObject *obj;
13563 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13564 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13565 Py_INCREF(obj);
13566 return Py_BuildValue((char *)"");
13567 }
13568 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13569 PyObject *resultobj;
13570 wxPNGHandler *result;
13571 char *kwnames[] = {
13572 NULL
13573 };
13574
13575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13576 {
13577 PyThreadState* __tstate = wxPyBeginAllowThreads();
13578 result = (wxPNGHandler *)new wxPNGHandler();
13579
13580 wxPyEndAllowThreads(__tstate);
13581 if (PyErr_Occurred()) SWIG_fail;
13582 }
13583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13584 return resultobj;
13585 fail:
13586 return NULL;
13587 }
13588
13589
13590 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13591 PyObject *obj;
13592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13593 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13594 Py_INCREF(obj);
13595 return Py_BuildValue((char *)"");
13596 }
13597 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13598 PyObject *resultobj;
13599 wxGIFHandler *result;
13600 char *kwnames[] = {
13601 NULL
13602 };
13603
13604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 result = (wxGIFHandler *)new wxGIFHandler();
13608
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13620 PyObject *obj;
13621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13622 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13623 Py_INCREF(obj);
13624 return Py_BuildValue((char *)"");
13625 }
13626 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13627 PyObject *resultobj;
13628 wxPCXHandler *result;
13629 char *kwnames[] = {
13630 NULL
13631 };
13632
13633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13634 {
13635 PyThreadState* __tstate = wxPyBeginAllowThreads();
13636 result = (wxPCXHandler *)new wxPCXHandler();
13637
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13642 return resultobj;
13643 fail:
13644 return NULL;
13645 }
13646
13647
13648 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13649 PyObject *obj;
13650 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13651 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13652 Py_INCREF(obj);
13653 return Py_BuildValue((char *)"");
13654 }
13655 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13656 PyObject *resultobj;
13657 wxJPEGHandler *result;
13658 char *kwnames[] = {
13659 NULL
13660 };
13661
13662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 result = (wxJPEGHandler *)new wxJPEGHandler();
13666
13667 wxPyEndAllowThreads(__tstate);
13668 if (PyErr_Occurred()) SWIG_fail;
13669 }
13670 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13671 return resultobj;
13672 fail:
13673 return NULL;
13674 }
13675
13676
13677 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13678 PyObject *obj;
13679 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13680 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13681 Py_INCREF(obj);
13682 return Py_BuildValue((char *)"");
13683 }
13684 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj;
13686 wxPNMHandler *result;
13687 char *kwnames[] = {
13688 NULL
13689 };
13690
13691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13692 {
13693 PyThreadState* __tstate = wxPyBeginAllowThreads();
13694 result = (wxPNMHandler *)new wxPNMHandler();
13695
13696 wxPyEndAllowThreads(__tstate);
13697 if (PyErr_Occurred()) SWIG_fail;
13698 }
13699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13700 return resultobj;
13701 fail:
13702 return NULL;
13703 }
13704
13705
13706 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13707 PyObject *obj;
13708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13709 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13710 Py_INCREF(obj);
13711 return Py_BuildValue((char *)"");
13712 }
13713 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13714 PyObject *resultobj;
13715 wxXPMHandler *result;
13716 char *kwnames[] = {
13717 NULL
13718 };
13719
13720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 result = (wxXPMHandler *)new wxXPMHandler();
13724
13725 wxPyEndAllowThreads(__tstate);
13726 if (PyErr_Occurred()) SWIG_fail;
13727 }
13728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13729 return resultobj;
13730 fail:
13731 return NULL;
13732 }
13733
13734
13735 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13736 PyObject *obj;
13737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13738 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13739 Py_INCREF(obj);
13740 return Py_BuildValue((char *)"");
13741 }
13742 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13743 PyObject *resultobj;
13744 wxTIFFHandler *result;
13745 char *kwnames[] = {
13746 NULL
13747 };
13748
13749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13750 {
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 result = (wxTIFFHandler *)new wxTIFFHandler();
13753
13754 wxPyEndAllowThreads(__tstate);
13755 if (PyErr_Occurred()) SWIG_fail;
13756 }
13757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13758 return resultobj;
13759 fail:
13760 return NULL;
13761 }
13762
13763
13764 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13765 PyObject *obj;
13766 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13767 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13768 Py_INCREF(obj);
13769 return Py_BuildValue((char *)"");
13770 }
13771 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13772 PyObject *resultobj;
13773 wxImage *arg1 = 0 ;
13774 wxImage *arg2 = 0 ;
13775 int arg3 = (int) 236 ;
13776 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13777 bool result;
13778 PyObject * obj0 = 0 ;
13779 PyObject * obj1 = 0 ;
13780 PyObject * obj2 = 0 ;
13781 PyObject * obj3 = 0 ;
13782 char *kwnames[] = {
13783 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13784 };
13785
13786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13787 {
13788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13789 if (SWIG_arg_fail(1)) SWIG_fail;
13790 if (arg1 == NULL) {
13791 SWIG_null_ref("wxImage");
13792 }
13793 if (SWIG_arg_fail(1)) SWIG_fail;
13794 }
13795 {
13796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13797 if (SWIG_arg_fail(2)) SWIG_fail;
13798 if (arg2 == NULL) {
13799 SWIG_null_ref("wxImage");
13800 }
13801 if (SWIG_arg_fail(2)) SWIG_fail;
13802 }
13803 if (obj2) {
13804 {
13805 arg3 = (int)(SWIG_As_int(obj2));
13806 if (SWIG_arg_fail(3)) SWIG_fail;
13807 }
13808 }
13809 if (obj3) {
13810 {
13811 arg4 = (int)(SWIG_As_int(obj3));
13812 if (SWIG_arg_fail(4)) SWIG_fail;
13813 }
13814 }
13815 {
13816 PyThreadState* __tstate = wxPyBeginAllowThreads();
13817 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
13818
13819 wxPyEndAllowThreads(__tstate);
13820 if (PyErr_Occurred()) SWIG_fail;
13821 }
13822 {
13823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13824 }
13825 return resultobj;
13826 fail:
13827 return NULL;
13828 }
13829
13830
13831 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
13832 PyObject *obj;
13833 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13834 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
13835 Py_INCREF(obj);
13836 return Py_BuildValue((char *)"");
13837 }
13838 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13839 PyObject *resultobj;
13840 wxEvtHandler *result;
13841 char *kwnames[] = {
13842 NULL
13843 };
13844
13845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
13846 {
13847 PyThreadState* __tstate = wxPyBeginAllowThreads();
13848 result = (wxEvtHandler *)new wxEvtHandler();
13849
13850 wxPyEndAllowThreads(__tstate);
13851 if (PyErr_Occurred()) SWIG_fail;
13852 }
13853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
13854 return resultobj;
13855 fail:
13856 return NULL;
13857 }
13858
13859
13860 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13861 PyObject *resultobj;
13862 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13863 wxEvtHandler *result;
13864 PyObject * obj0 = 0 ;
13865 char *kwnames[] = {
13866 (char *) "self", NULL
13867 };
13868
13869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
13870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13871 if (SWIG_arg_fail(1)) SWIG_fail;
13872 {
13873 PyThreadState* __tstate = wxPyBeginAllowThreads();
13874 result = (wxEvtHandler *)(arg1)->GetNextHandler();
13875
13876 wxPyEndAllowThreads(__tstate);
13877 if (PyErr_Occurred()) SWIG_fail;
13878 }
13879 {
13880 resultobj = wxPyMake_wxObject(result, 0);
13881 }
13882 return resultobj;
13883 fail:
13884 return NULL;
13885 }
13886
13887
13888 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13889 PyObject *resultobj;
13890 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13891 wxEvtHandler *result;
13892 PyObject * obj0 = 0 ;
13893 char *kwnames[] = {
13894 (char *) "self", NULL
13895 };
13896
13897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
13898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13899 if (SWIG_arg_fail(1)) SWIG_fail;
13900 {
13901 PyThreadState* __tstate = wxPyBeginAllowThreads();
13902 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
13903
13904 wxPyEndAllowThreads(__tstate);
13905 if (PyErr_Occurred()) SWIG_fail;
13906 }
13907 {
13908 resultobj = wxPyMake_wxObject(result, 0);
13909 }
13910 return resultobj;
13911 fail:
13912 return NULL;
13913 }
13914
13915
13916 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13917 PyObject *resultobj;
13918 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13919 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13920 PyObject * obj0 = 0 ;
13921 PyObject * obj1 = 0 ;
13922 char *kwnames[] = {
13923 (char *) "self",(char *) "handler", NULL
13924 };
13925
13926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
13927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13928 if (SWIG_arg_fail(1)) SWIG_fail;
13929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13930 if (SWIG_arg_fail(2)) SWIG_fail;
13931 {
13932 PyThreadState* __tstate = wxPyBeginAllowThreads();
13933 (arg1)->SetNextHandler(arg2);
13934
13935 wxPyEndAllowThreads(__tstate);
13936 if (PyErr_Occurred()) SWIG_fail;
13937 }
13938 Py_INCREF(Py_None); resultobj = Py_None;
13939 return resultobj;
13940 fail:
13941 return NULL;
13942 }
13943
13944
13945 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13946 PyObject *resultobj;
13947 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13948 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13949 PyObject * obj0 = 0 ;
13950 PyObject * obj1 = 0 ;
13951 char *kwnames[] = {
13952 (char *) "self",(char *) "handler", NULL
13953 };
13954
13955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
13956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13957 if (SWIG_arg_fail(1)) SWIG_fail;
13958 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13959 if (SWIG_arg_fail(2)) SWIG_fail;
13960 {
13961 PyThreadState* __tstate = wxPyBeginAllowThreads();
13962 (arg1)->SetPreviousHandler(arg2);
13963
13964 wxPyEndAllowThreads(__tstate);
13965 if (PyErr_Occurred()) SWIG_fail;
13966 }
13967 Py_INCREF(Py_None); resultobj = Py_None;
13968 return resultobj;
13969 fail:
13970 return NULL;
13971 }
13972
13973
13974 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13975 PyObject *resultobj;
13976 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13977 bool result;
13978 PyObject * obj0 = 0 ;
13979 char *kwnames[] = {
13980 (char *) "self", NULL
13981 };
13982
13983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
13984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13985 if (SWIG_arg_fail(1)) SWIG_fail;
13986 {
13987 PyThreadState* __tstate = wxPyBeginAllowThreads();
13988 result = (bool)(arg1)->GetEvtHandlerEnabled();
13989
13990 wxPyEndAllowThreads(__tstate);
13991 if (PyErr_Occurred()) SWIG_fail;
13992 }
13993 {
13994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13995 }
13996 return resultobj;
13997 fail:
13998 return NULL;
13999 }
14000
14001
14002 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14003 PyObject *resultobj;
14004 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14005 bool arg2 ;
14006 PyObject * obj0 = 0 ;
14007 PyObject * obj1 = 0 ;
14008 char *kwnames[] = {
14009 (char *) "self",(char *) "enabled", NULL
14010 };
14011
14012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14014 if (SWIG_arg_fail(1)) SWIG_fail;
14015 {
14016 arg2 = (bool)(SWIG_As_bool(obj1));
14017 if (SWIG_arg_fail(2)) SWIG_fail;
14018 }
14019 {
14020 PyThreadState* __tstate = wxPyBeginAllowThreads();
14021 (arg1)->SetEvtHandlerEnabled(arg2);
14022
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 Py_INCREF(Py_None); resultobj = Py_None;
14027 return resultobj;
14028 fail:
14029 return NULL;
14030 }
14031
14032
14033 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14034 PyObject *resultobj;
14035 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14036 wxEvent *arg2 = 0 ;
14037 bool result;
14038 PyObject * obj0 = 0 ;
14039 PyObject * obj1 = 0 ;
14040 char *kwnames[] = {
14041 (char *) "self",(char *) "event", NULL
14042 };
14043
14044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14046 if (SWIG_arg_fail(1)) SWIG_fail;
14047 {
14048 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14049 if (SWIG_arg_fail(2)) SWIG_fail;
14050 if (arg2 == NULL) {
14051 SWIG_null_ref("wxEvent");
14052 }
14053 if (SWIG_arg_fail(2)) SWIG_fail;
14054 }
14055 {
14056 PyThreadState* __tstate = wxPyBeginAllowThreads();
14057 result = (bool)(arg1)->ProcessEvent(*arg2);
14058
14059 wxPyEndAllowThreads(__tstate);
14060 if (PyErr_Occurred()) SWIG_fail;
14061 }
14062 {
14063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14064 }
14065 return resultobj;
14066 fail:
14067 return NULL;
14068 }
14069
14070
14071 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14072 PyObject *resultobj;
14073 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14074 wxEvent *arg2 = 0 ;
14075 PyObject * obj0 = 0 ;
14076 PyObject * obj1 = 0 ;
14077 char *kwnames[] = {
14078 (char *) "self",(char *) "event", NULL
14079 };
14080
14081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14083 if (SWIG_arg_fail(1)) SWIG_fail;
14084 {
14085 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14086 if (SWIG_arg_fail(2)) SWIG_fail;
14087 if (arg2 == NULL) {
14088 SWIG_null_ref("wxEvent");
14089 }
14090 if (SWIG_arg_fail(2)) SWIG_fail;
14091 }
14092 {
14093 PyThreadState* __tstate = wxPyBeginAllowThreads();
14094 (arg1)->AddPendingEvent(*arg2);
14095
14096 wxPyEndAllowThreads(__tstate);
14097 if (PyErr_Occurred()) SWIG_fail;
14098 }
14099 Py_INCREF(Py_None); resultobj = Py_None;
14100 return resultobj;
14101 fail:
14102 return NULL;
14103 }
14104
14105
14106 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14107 PyObject *resultobj;
14108 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14109 PyObject * obj0 = 0 ;
14110 char *kwnames[] = {
14111 (char *) "self", NULL
14112 };
14113
14114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14116 if (SWIG_arg_fail(1)) SWIG_fail;
14117 {
14118 PyThreadState* __tstate = wxPyBeginAllowThreads();
14119 (arg1)->ProcessPendingEvents();
14120
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 Py_INCREF(Py_None); resultobj = Py_None;
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14132 PyObject *resultobj;
14133 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14134 int arg2 ;
14135 int arg3 ;
14136 int arg4 ;
14137 PyObject *arg5 = (PyObject *) 0 ;
14138 PyObject * obj0 = 0 ;
14139 PyObject * obj1 = 0 ;
14140 PyObject * obj2 = 0 ;
14141 PyObject * obj3 = 0 ;
14142 PyObject * obj4 = 0 ;
14143 char *kwnames[] = {
14144 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14145 };
14146
14147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14149 if (SWIG_arg_fail(1)) SWIG_fail;
14150 {
14151 arg2 = (int)(SWIG_As_int(obj1));
14152 if (SWIG_arg_fail(2)) SWIG_fail;
14153 }
14154 {
14155 arg3 = (int)(SWIG_As_int(obj2));
14156 if (SWIG_arg_fail(3)) SWIG_fail;
14157 }
14158 {
14159 arg4 = (int)(SWIG_As_int(obj3));
14160 if (SWIG_arg_fail(4)) SWIG_fail;
14161 }
14162 arg5 = obj4;
14163 {
14164 PyThreadState* __tstate = wxPyBeginAllowThreads();
14165 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14166
14167 wxPyEndAllowThreads(__tstate);
14168 if (PyErr_Occurred()) SWIG_fail;
14169 }
14170 Py_INCREF(Py_None); resultobj = Py_None;
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14178 PyObject *resultobj;
14179 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14180 int arg2 ;
14181 int arg3 = (int) -1 ;
14182 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14183 bool result;
14184 PyObject * obj0 = 0 ;
14185 PyObject * obj1 = 0 ;
14186 PyObject * obj2 = 0 ;
14187 PyObject * obj3 = 0 ;
14188 char *kwnames[] = {
14189 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14190 };
14191
14192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14194 if (SWIG_arg_fail(1)) SWIG_fail;
14195 {
14196 arg2 = (int)(SWIG_As_int(obj1));
14197 if (SWIG_arg_fail(2)) SWIG_fail;
14198 }
14199 if (obj2) {
14200 {
14201 arg3 = (int)(SWIG_As_int(obj2));
14202 if (SWIG_arg_fail(3)) SWIG_fail;
14203 }
14204 }
14205 if (obj3) {
14206 {
14207 arg4 = (wxEventType)(SWIG_As_int(obj3));
14208 if (SWIG_arg_fail(4)) SWIG_fail;
14209 }
14210 }
14211 {
14212 PyThreadState* __tstate = wxPyBeginAllowThreads();
14213 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14214
14215 wxPyEndAllowThreads(__tstate);
14216 if (PyErr_Occurred()) SWIG_fail;
14217 }
14218 {
14219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14220 }
14221 return resultobj;
14222 fail:
14223 return NULL;
14224 }
14225
14226
14227 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14228 PyObject *resultobj;
14229 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14230 PyObject *arg2 = (PyObject *) 0 ;
14231 bool arg3 = (bool) true ;
14232 PyObject * obj0 = 0 ;
14233 PyObject * obj1 = 0 ;
14234 PyObject * obj2 = 0 ;
14235 char *kwnames[] = {
14236 (char *) "self",(char *) "_self",(char *) "incref", NULL
14237 };
14238
14239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14241 if (SWIG_arg_fail(1)) SWIG_fail;
14242 arg2 = obj1;
14243 if (obj2) {
14244 {
14245 arg3 = (bool)(SWIG_As_bool(obj2));
14246 if (SWIG_arg_fail(3)) SWIG_fail;
14247 }
14248 }
14249 {
14250 PyThreadState* __tstate = wxPyBeginAllowThreads();
14251 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14252
14253 wxPyEndAllowThreads(__tstate);
14254 if (PyErr_Occurred()) SWIG_fail;
14255 }
14256 Py_INCREF(Py_None); resultobj = Py_None;
14257 return resultobj;
14258 fail:
14259 return NULL;
14260 }
14261
14262
14263 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14264 PyObject *obj;
14265 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14266 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14267 Py_INCREF(obj);
14268 return Py_BuildValue((char *)"");
14269 }
14270 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14271 PyObject *resultobj;
14272 wxEventType result;
14273 char *kwnames[] = {
14274 NULL
14275 };
14276
14277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14278 {
14279 PyThreadState* __tstate = wxPyBeginAllowThreads();
14280 result = (wxEventType)wxNewEventType();
14281
14282 wxPyEndAllowThreads(__tstate);
14283 if (PyErr_Occurred()) SWIG_fail;
14284 }
14285 {
14286 resultobj = SWIG_From_int((int)(result));
14287 }
14288 return resultobj;
14289 fail:
14290 return NULL;
14291 }
14292
14293
14294 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14295 PyObject *resultobj;
14296 wxEvent *arg1 = (wxEvent *) 0 ;
14297 PyObject * obj0 = 0 ;
14298 char *kwnames[] = {
14299 (char *) "self", NULL
14300 };
14301
14302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14304 if (SWIG_arg_fail(1)) SWIG_fail;
14305 {
14306 PyThreadState* __tstate = wxPyBeginAllowThreads();
14307 delete arg1;
14308
14309 wxPyEndAllowThreads(__tstate);
14310 if (PyErr_Occurred()) SWIG_fail;
14311 }
14312 Py_INCREF(Py_None); resultobj = Py_None;
14313 return resultobj;
14314 fail:
14315 return NULL;
14316 }
14317
14318
14319 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14320 PyObject *resultobj;
14321 wxEvent *arg1 = (wxEvent *) 0 ;
14322 wxEventType arg2 ;
14323 PyObject * obj0 = 0 ;
14324 PyObject * obj1 = 0 ;
14325 char *kwnames[] = {
14326 (char *) "self",(char *) "typ", NULL
14327 };
14328
14329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14331 if (SWIG_arg_fail(1)) SWIG_fail;
14332 {
14333 arg2 = (wxEventType)(SWIG_As_int(obj1));
14334 if (SWIG_arg_fail(2)) SWIG_fail;
14335 }
14336 {
14337 PyThreadState* __tstate = wxPyBeginAllowThreads();
14338 (arg1)->SetEventType(arg2);
14339
14340 wxPyEndAllowThreads(__tstate);
14341 if (PyErr_Occurred()) SWIG_fail;
14342 }
14343 Py_INCREF(Py_None); resultobj = Py_None;
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj;
14352 wxEvent *arg1 = (wxEvent *) 0 ;
14353 wxEventType result;
14354 PyObject * obj0 = 0 ;
14355 char *kwnames[] = {
14356 (char *) "self", NULL
14357 };
14358
14359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14361 if (SWIG_arg_fail(1)) SWIG_fail;
14362 {
14363 PyThreadState* __tstate = wxPyBeginAllowThreads();
14364 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14365
14366 wxPyEndAllowThreads(__tstate);
14367 if (PyErr_Occurred()) SWIG_fail;
14368 }
14369 {
14370 resultobj = SWIG_From_int((int)(result));
14371 }
14372 return resultobj;
14373 fail:
14374 return NULL;
14375 }
14376
14377
14378 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14379 PyObject *resultobj;
14380 wxEvent *arg1 = (wxEvent *) 0 ;
14381 wxObject *result;
14382 PyObject * obj0 = 0 ;
14383 char *kwnames[] = {
14384 (char *) "self", NULL
14385 };
14386
14387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14389 if (SWIG_arg_fail(1)) SWIG_fail;
14390 {
14391 PyThreadState* __tstate = wxPyBeginAllowThreads();
14392 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14393
14394 wxPyEndAllowThreads(__tstate);
14395 if (PyErr_Occurred()) SWIG_fail;
14396 }
14397 {
14398 resultobj = wxPyMake_wxObject(result, 0);
14399 }
14400 return resultobj;
14401 fail:
14402 return NULL;
14403 }
14404
14405
14406 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14407 PyObject *resultobj;
14408 wxEvent *arg1 = (wxEvent *) 0 ;
14409 wxObject *arg2 = (wxObject *) 0 ;
14410 PyObject * obj0 = 0 ;
14411 PyObject * obj1 = 0 ;
14412 char *kwnames[] = {
14413 (char *) "self",(char *) "obj", NULL
14414 };
14415
14416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14418 if (SWIG_arg_fail(1)) SWIG_fail;
14419 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14420 if (SWIG_arg_fail(2)) SWIG_fail;
14421 {
14422 PyThreadState* __tstate = wxPyBeginAllowThreads();
14423 (arg1)->SetEventObject(arg2);
14424
14425 wxPyEndAllowThreads(__tstate);
14426 if (PyErr_Occurred()) SWIG_fail;
14427 }
14428 Py_INCREF(Py_None); resultobj = Py_None;
14429 return resultobj;
14430 fail:
14431 return NULL;
14432 }
14433
14434
14435 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14436 PyObject *resultobj;
14437 wxEvent *arg1 = (wxEvent *) 0 ;
14438 long result;
14439 PyObject * obj0 = 0 ;
14440 char *kwnames[] = {
14441 (char *) "self", NULL
14442 };
14443
14444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14446 if (SWIG_arg_fail(1)) SWIG_fail;
14447 {
14448 PyThreadState* __tstate = wxPyBeginAllowThreads();
14449 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14450
14451 wxPyEndAllowThreads(__tstate);
14452 if (PyErr_Occurred()) SWIG_fail;
14453 }
14454 {
14455 resultobj = SWIG_From_long((long)(result));
14456 }
14457 return resultobj;
14458 fail:
14459 return NULL;
14460 }
14461
14462
14463 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14464 PyObject *resultobj;
14465 wxEvent *arg1 = (wxEvent *) 0 ;
14466 long arg2 = (long) 0 ;
14467 PyObject * obj0 = 0 ;
14468 PyObject * obj1 = 0 ;
14469 char *kwnames[] = {
14470 (char *) "self",(char *) "ts", NULL
14471 };
14472
14473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14475 if (SWIG_arg_fail(1)) SWIG_fail;
14476 if (obj1) {
14477 {
14478 arg2 = (long)(SWIG_As_long(obj1));
14479 if (SWIG_arg_fail(2)) SWIG_fail;
14480 }
14481 }
14482 {
14483 PyThreadState* __tstate = wxPyBeginAllowThreads();
14484 (arg1)->SetTimestamp(arg2);
14485
14486 wxPyEndAllowThreads(__tstate);
14487 if (PyErr_Occurred()) SWIG_fail;
14488 }
14489 Py_INCREF(Py_None); resultobj = Py_None;
14490 return resultobj;
14491 fail:
14492 return NULL;
14493 }
14494
14495
14496 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14497 PyObject *resultobj;
14498 wxEvent *arg1 = (wxEvent *) 0 ;
14499 int result;
14500 PyObject * obj0 = 0 ;
14501 char *kwnames[] = {
14502 (char *) "self", NULL
14503 };
14504
14505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14507 if (SWIG_arg_fail(1)) SWIG_fail;
14508 {
14509 PyThreadState* __tstate = wxPyBeginAllowThreads();
14510 result = (int)((wxEvent const *)arg1)->GetId();
14511
14512 wxPyEndAllowThreads(__tstate);
14513 if (PyErr_Occurred()) SWIG_fail;
14514 }
14515 {
14516 resultobj = SWIG_From_int((int)(result));
14517 }
14518 return resultobj;
14519 fail:
14520 return NULL;
14521 }
14522
14523
14524 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14525 PyObject *resultobj;
14526 wxEvent *arg1 = (wxEvent *) 0 ;
14527 int arg2 ;
14528 PyObject * obj0 = 0 ;
14529 PyObject * obj1 = 0 ;
14530 char *kwnames[] = {
14531 (char *) "self",(char *) "Id", NULL
14532 };
14533
14534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14536 if (SWIG_arg_fail(1)) SWIG_fail;
14537 {
14538 arg2 = (int)(SWIG_As_int(obj1));
14539 if (SWIG_arg_fail(2)) SWIG_fail;
14540 }
14541 {
14542 PyThreadState* __tstate = wxPyBeginAllowThreads();
14543 (arg1)->SetId(arg2);
14544
14545 wxPyEndAllowThreads(__tstate);
14546 if (PyErr_Occurred()) SWIG_fail;
14547 }
14548 Py_INCREF(Py_None); resultobj = Py_None;
14549 return resultobj;
14550 fail:
14551 return NULL;
14552 }
14553
14554
14555 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14556 PyObject *resultobj;
14557 wxEvent *arg1 = (wxEvent *) 0 ;
14558 bool result;
14559 PyObject * obj0 = 0 ;
14560 char *kwnames[] = {
14561 (char *) "self", NULL
14562 };
14563
14564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14566 if (SWIG_arg_fail(1)) SWIG_fail;
14567 {
14568 PyThreadState* __tstate = wxPyBeginAllowThreads();
14569 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14570
14571 wxPyEndAllowThreads(__tstate);
14572 if (PyErr_Occurred()) SWIG_fail;
14573 }
14574 {
14575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14576 }
14577 return resultobj;
14578 fail:
14579 return NULL;
14580 }
14581
14582
14583 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14584 PyObject *resultobj;
14585 wxEvent *arg1 = (wxEvent *) 0 ;
14586 bool arg2 = (bool) true ;
14587 PyObject * obj0 = 0 ;
14588 PyObject * obj1 = 0 ;
14589 char *kwnames[] = {
14590 (char *) "self",(char *) "skip", NULL
14591 };
14592
14593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14595 if (SWIG_arg_fail(1)) SWIG_fail;
14596 if (obj1) {
14597 {
14598 arg2 = (bool)(SWIG_As_bool(obj1));
14599 if (SWIG_arg_fail(2)) SWIG_fail;
14600 }
14601 }
14602 {
14603 PyThreadState* __tstate = wxPyBeginAllowThreads();
14604 (arg1)->Skip(arg2);
14605
14606 wxPyEndAllowThreads(__tstate);
14607 if (PyErr_Occurred()) SWIG_fail;
14608 }
14609 Py_INCREF(Py_None); resultobj = Py_None;
14610 return resultobj;
14611 fail:
14612 return NULL;
14613 }
14614
14615
14616 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14617 PyObject *resultobj;
14618 wxEvent *arg1 = (wxEvent *) 0 ;
14619 bool result;
14620 PyObject * obj0 = 0 ;
14621 char *kwnames[] = {
14622 (char *) "self", NULL
14623 };
14624
14625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14627 if (SWIG_arg_fail(1)) SWIG_fail;
14628 {
14629 PyThreadState* __tstate = wxPyBeginAllowThreads();
14630 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14631
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 {
14636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14637 }
14638 return resultobj;
14639 fail:
14640 return NULL;
14641 }
14642
14643
14644 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14645 PyObject *resultobj;
14646 wxEvent *arg1 = (wxEvent *) 0 ;
14647 bool result;
14648 PyObject * obj0 = 0 ;
14649 char *kwnames[] = {
14650 (char *) "self", NULL
14651 };
14652
14653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14655 if (SWIG_arg_fail(1)) SWIG_fail;
14656 {
14657 PyThreadState* __tstate = wxPyBeginAllowThreads();
14658 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14659
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 {
14664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14665 }
14666 return resultobj;
14667 fail:
14668 return NULL;
14669 }
14670
14671
14672 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14673 PyObject *resultobj;
14674 wxEvent *arg1 = (wxEvent *) 0 ;
14675 int result;
14676 PyObject * obj0 = 0 ;
14677 char *kwnames[] = {
14678 (char *) "self", NULL
14679 };
14680
14681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14683 if (SWIG_arg_fail(1)) SWIG_fail;
14684 {
14685 PyThreadState* __tstate = wxPyBeginAllowThreads();
14686 result = (int)(arg1)->StopPropagation();
14687
14688 wxPyEndAllowThreads(__tstate);
14689 if (PyErr_Occurred()) SWIG_fail;
14690 }
14691 {
14692 resultobj = SWIG_From_int((int)(result));
14693 }
14694 return resultobj;
14695 fail:
14696 return NULL;
14697 }
14698
14699
14700 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14701 PyObject *resultobj;
14702 wxEvent *arg1 = (wxEvent *) 0 ;
14703 int arg2 ;
14704 PyObject * obj0 = 0 ;
14705 PyObject * obj1 = 0 ;
14706 char *kwnames[] = {
14707 (char *) "self",(char *) "propagationLevel", NULL
14708 };
14709
14710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14712 if (SWIG_arg_fail(1)) SWIG_fail;
14713 {
14714 arg2 = (int)(SWIG_As_int(obj1));
14715 if (SWIG_arg_fail(2)) SWIG_fail;
14716 }
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 (arg1)->ResumePropagation(arg2);
14720
14721 wxPyEndAllowThreads(__tstate);
14722 if (PyErr_Occurred()) SWIG_fail;
14723 }
14724 Py_INCREF(Py_None); resultobj = Py_None;
14725 return resultobj;
14726 fail:
14727 return NULL;
14728 }
14729
14730
14731 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14732 PyObject *resultobj;
14733 wxEvent *arg1 = (wxEvent *) 0 ;
14734 wxEvent *result;
14735 PyObject * obj0 = 0 ;
14736 char *kwnames[] = {
14737 (char *) "self", NULL
14738 };
14739
14740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14742 if (SWIG_arg_fail(1)) SWIG_fail;
14743 {
14744 PyThreadState* __tstate = wxPyBeginAllowThreads();
14745 result = (wxEvent *)(arg1)->Clone();
14746
14747 wxPyEndAllowThreads(__tstate);
14748 if (PyErr_Occurred()) SWIG_fail;
14749 }
14750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14751 return resultobj;
14752 fail:
14753 return NULL;
14754 }
14755
14756
14757 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14758 PyObject *obj;
14759 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14760 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14761 Py_INCREF(obj);
14762 return Py_BuildValue((char *)"");
14763 }
14764 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14765 PyObject *resultobj;
14766 wxEvent *arg1 = 0 ;
14767 wxPropagationDisabler *result;
14768 PyObject * obj0 = 0 ;
14769 char *kwnames[] = {
14770 (char *) "event", NULL
14771 };
14772
14773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14774 {
14775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14776 if (SWIG_arg_fail(1)) SWIG_fail;
14777 if (arg1 == NULL) {
14778 SWIG_null_ref("wxEvent");
14779 }
14780 if (SWIG_arg_fail(1)) SWIG_fail;
14781 }
14782 {
14783 PyThreadState* __tstate = wxPyBeginAllowThreads();
14784 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14785
14786 wxPyEndAllowThreads(__tstate);
14787 if (PyErr_Occurred()) SWIG_fail;
14788 }
14789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj;
14798 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14799 PyObject * obj0 = 0 ;
14800 char *kwnames[] = {
14801 (char *) "self", NULL
14802 };
14803
14804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14806 if (SWIG_arg_fail(1)) SWIG_fail;
14807 {
14808 PyThreadState* __tstate = wxPyBeginAllowThreads();
14809 delete arg1;
14810
14811 wxPyEndAllowThreads(__tstate);
14812 if (PyErr_Occurred()) SWIG_fail;
14813 }
14814 Py_INCREF(Py_None); resultobj = Py_None;
14815 return resultobj;
14816 fail:
14817 return NULL;
14818 }
14819
14820
14821 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
14822 PyObject *obj;
14823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14824 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
14825 Py_INCREF(obj);
14826 return Py_BuildValue((char *)"");
14827 }
14828 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14829 PyObject *resultobj;
14830 wxEvent *arg1 = 0 ;
14831 wxPropagateOnce *result;
14832 PyObject * obj0 = 0 ;
14833 char *kwnames[] = {
14834 (char *) "event", NULL
14835 };
14836
14837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
14838 {
14839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14840 if (SWIG_arg_fail(1)) SWIG_fail;
14841 if (arg1 == NULL) {
14842 SWIG_null_ref("wxEvent");
14843 }
14844 if (SWIG_arg_fail(1)) SWIG_fail;
14845 }
14846 {
14847 PyThreadState* __tstate = wxPyBeginAllowThreads();
14848 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
14849
14850 wxPyEndAllowThreads(__tstate);
14851 if (PyErr_Occurred()) SWIG_fail;
14852 }
14853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
14854 return resultobj;
14855 fail:
14856 return NULL;
14857 }
14858
14859
14860 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14861 PyObject *resultobj;
14862 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
14863 PyObject * obj0 = 0 ;
14864 char *kwnames[] = {
14865 (char *) "self", NULL
14866 };
14867
14868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
14869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
14870 if (SWIG_arg_fail(1)) SWIG_fail;
14871 {
14872 PyThreadState* __tstate = wxPyBeginAllowThreads();
14873 delete arg1;
14874
14875 wxPyEndAllowThreads(__tstate);
14876 if (PyErr_Occurred()) SWIG_fail;
14877 }
14878 Py_INCREF(Py_None); resultobj = Py_None;
14879 return resultobj;
14880 fail:
14881 return NULL;
14882 }
14883
14884
14885 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
14886 PyObject *obj;
14887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14888 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
14889 Py_INCREF(obj);
14890 return Py_BuildValue((char *)"");
14891 }
14892 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14893 PyObject *resultobj;
14894 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
14895 int arg2 = (int) 0 ;
14896 wxCommandEvent *result;
14897 PyObject * obj0 = 0 ;
14898 PyObject * obj1 = 0 ;
14899 char *kwnames[] = {
14900 (char *) "commandType",(char *) "winid", NULL
14901 };
14902
14903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
14904 if (obj0) {
14905 {
14906 arg1 = (wxEventType)(SWIG_As_int(obj0));
14907 if (SWIG_arg_fail(1)) SWIG_fail;
14908 }
14909 }
14910 if (obj1) {
14911 {
14912 arg2 = (int)(SWIG_As_int(obj1));
14913 if (SWIG_arg_fail(2)) SWIG_fail;
14914 }
14915 }
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
14919
14920 wxPyEndAllowThreads(__tstate);
14921 if (PyErr_Occurred()) SWIG_fail;
14922 }
14923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
14924 return resultobj;
14925 fail:
14926 return NULL;
14927 }
14928
14929
14930 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14931 PyObject *resultobj;
14932 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14933 int result;
14934 PyObject * obj0 = 0 ;
14935 char *kwnames[] = {
14936 (char *) "self", NULL
14937 };
14938
14939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
14940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14941 if (SWIG_arg_fail(1)) SWIG_fail;
14942 {
14943 PyThreadState* __tstate = wxPyBeginAllowThreads();
14944 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
14945
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 {
14950 resultobj = SWIG_From_int((int)(result));
14951 }
14952 return resultobj;
14953 fail:
14954 return NULL;
14955 }
14956
14957
14958 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
14959 PyObject *resultobj;
14960 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14961 wxString *arg2 = 0 ;
14962 bool temp2 = false ;
14963 PyObject * obj0 = 0 ;
14964 PyObject * obj1 = 0 ;
14965 char *kwnames[] = {
14966 (char *) "self",(char *) "s", NULL
14967 };
14968
14969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
14970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14971 if (SWIG_arg_fail(1)) SWIG_fail;
14972 {
14973 arg2 = wxString_in_helper(obj1);
14974 if (arg2 == NULL) SWIG_fail;
14975 temp2 = true;
14976 }
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 (arg1)->SetString((wxString const &)*arg2);
14980
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 Py_INCREF(Py_None); resultobj = Py_None;
14985 {
14986 if (temp2)
14987 delete arg2;
14988 }
14989 return resultobj;
14990 fail:
14991 {
14992 if (temp2)
14993 delete arg2;
14994 }
14995 return NULL;
14996 }
14997
14998
14999 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15000 PyObject *resultobj;
15001 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15002 wxString result;
15003 PyObject * obj0 = 0 ;
15004 char *kwnames[] = {
15005 (char *) "self", NULL
15006 };
15007
15008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15010 if (SWIG_arg_fail(1)) SWIG_fail;
15011 {
15012 PyThreadState* __tstate = wxPyBeginAllowThreads();
15013 result = ((wxCommandEvent const *)arg1)->GetString();
15014
15015 wxPyEndAllowThreads(__tstate);
15016 if (PyErr_Occurred()) SWIG_fail;
15017 }
15018 {
15019 #if wxUSE_UNICODE
15020 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15021 #else
15022 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15023 #endif
15024 }
15025 return resultobj;
15026 fail:
15027 return NULL;
15028 }
15029
15030
15031 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15032 PyObject *resultobj;
15033 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15034 bool result;
15035 PyObject * obj0 = 0 ;
15036 char *kwnames[] = {
15037 (char *) "self", NULL
15038 };
15039
15040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15042 if (SWIG_arg_fail(1)) SWIG_fail;
15043 {
15044 PyThreadState* __tstate = wxPyBeginAllowThreads();
15045 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15046
15047 wxPyEndAllowThreads(__tstate);
15048 if (PyErr_Occurred()) SWIG_fail;
15049 }
15050 {
15051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15052 }
15053 return resultobj;
15054 fail:
15055 return NULL;
15056 }
15057
15058
15059 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15060 PyObject *resultobj;
15061 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15062 bool result;
15063 PyObject * obj0 = 0 ;
15064 char *kwnames[] = {
15065 (char *) "self", NULL
15066 };
15067
15068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15070 if (SWIG_arg_fail(1)) SWIG_fail;
15071 {
15072 PyThreadState* __tstate = wxPyBeginAllowThreads();
15073 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15074
15075 wxPyEndAllowThreads(__tstate);
15076 if (PyErr_Occurred()) SWIG_fail;
15077 }
15078 {
15079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15080 }
15081 return resultobj;
15082 fail:
15083 return NULL;
15084 }
15085
15086
15087 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15088 PyObject *resultobj;
15089 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15090 long arg2 ;
15091 PyObject * obj0 = 0 ;
15092 PyObject * obj1 = 0 ;
15093 char *kwnames[] = {
15094 (char *) "self",(char *) "extraLong", NULL
15095 };
15096
15097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15099 if (SWIG_arg_fail(1)) SWIG_fail;
15100 {
15101 arg2 = (long)(SWIG_As_long(obj1));
15102 if (SWIG_arg_fail(2)) SWIG_fail;
15103 }
15104 {
15105 PyThreadState* __tstate = wxPyBeginAllowThreads();
15106 (arg1)->SetExtraLong(arg2);
15107
15108 wxPyEndAllowThreads(__tstate);
15109 if (PyErr_Occurred()) SWIG_fail;
15110 }
15111 Py_INCREF(Py_None); resultobj = Py_None;
15112 return resultobj;
15113 fail:
15114 return NULL;
15115 }
15116
15117
15118 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15119 PyObject *resultobj;
15120 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15121 long result;
15122 PyObject * obj0 = 0 ;
15123 char *kwnames[] = {
15124 (char *) "self", NULL
15125 };
15126
15127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15129 if (SWIG_arg_fail(1)) SWIG_fail;
15130 {
15131 PyThreadState* __tstate = wxPyBeginAllowThreads();
15132 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15133
15134 wxPyEndAllowThreads(__tstate);
15135 if (PyErr_Occurred()) SWIG_fail;
15136 }
15137 {
15138 resultobj = SWIG_From_long((long)(result));
15139 }
15140 return resultobj;
15141 fail:
15142 return NULL;
15143 }
15144
15145
15146 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15147 PyObject *resultobj;
15148 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15149 int arg2 ;
15150 PyObject * obj0 = 0 ;
15151 PyObject * obj1 = 0 ;
15152 char *kwnames[] = {
15153 (char *) "self",(char *) "i", NULL
15154 };
15155
15156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15158 if (SWIG_arg_fail(1)) SWIG_fail;
15159 {
15160 arg2 = (int)(SWIG_As_int(obj1));
15161 if (SWIG_arg_fail(2)) SWIG_fail;
15162 }
15163 {
15164 PyThreadState* __tstate = wxPyBeginAllowThreads();
15165 (arg1)->SetInt(arg2);
15166
15167 wxPyEndAllowThreads(__tstate);
15168 if (PyErr_Occurred()) SWIG_fail;
15169 }
15170 Py_INCREF(Py_None); resultobj = Py_None;
15171 return resultobj;
15172 fail:
15173 return NULL;
15174 }
15175
15176
15177 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15178 PyObject *resultobj;
15179 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15180 long result;
15181 PyObject * obj0 = 0 ;
15182 char *kwnames[] = {
15183 (char *) "self", NULL
15184 };
15185
15186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15188 if (SWIG_arg_fail(1)) SWIG_fail;
15189 {
15190 PyThreadState* __tstate = wxPyBeginAllowThreads();
15191 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15192
15193 wxPyEndAllowThreads(__tstate);
15194 if (PyErr_Occurred()) SWIG_fail;
15195 }
15196 {
15197 resultobj = SWIG_From_long((long)(result));
15198 }
15199 return resultobj;
15200 fail:
15201 return NULL;
15202 }
15203
15204
15205 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15206 PyObject *resultobj;
15207 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15208 wxEvent *result;
15209 PyObject * obj0 = 0 ;
15210 char *kwnames[] = {
15211 (char *) "self", NULL
15212 };
15213
15214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15216 if (SWIG_arg_fail(1)) SWIG_fail;
15217 {
15218 PyThreadState* __tstate = wxPyBeginAllowThreads();
15219 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15220
15221 wxPyEndAllowThreads(__tstate);
15222 if (PyErr_Occurred()) SWIG_fail;
15223 }
15224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15225 return resultobj;
15226 fail:
15227 return NULL;
15228 }
15229
15230
15231 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15232 PyObject *obj;
15233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15234 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15235 Py_INCREF(obj);
15236 return Py_BuildValue((char *)"");
15237 }
15238 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15239 PyObject *resultobj;
15240 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15241 int arg2 = (int) 0 ;
15242 wxNotifyEvent *result;
15243 PyObject * obj0 = 0 ;
15244 PyObject * obj1 = 0 ;
15245 char *kwnames[] = {
15246 (char *) "commandType",(char *) "winid", NULL
15247 };
15248
15249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15250 if (obj0) {
15251 {
15252 arg1 = (wxEventType)(SWIG_As_int(obj0));
15253 if (SWIG_arg_fail(1)) SWIG_fail;
15254 }
15255 }
15256 if (obj1) {
15257 {
15258 arg2 = (int)(SWIG_As_int(obj1));
15259 if (SWIG_arg_fail(2)) SWIG_fail;
15260 }
15261 }
15262 {
15263 PyThreadState* __tstate = wxPyBeginAllowThreads();
15264 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15265
15266 wxPyEndAllowThreads(__tstate);
15267 if (PyErr_Occurred()) SWIG_fail;
15268 }
15269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15270 return resultobj;
15271 fail:
15272 return NULL;
15273 }
15274
15275
15276 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15277 PyObject *resultobj;
15278 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15279 PyObject * obj0 = 0 ;
15280 char *kwnames[] = {
15281 (char *) "self", NULL
15282 };
15283
15284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15286 if (SWIG_arg_fail(1)) SWIG_fail;
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 (arg1)->Veto();
15290
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 Py_INCREF(Py_None); resultobj = Py_None;
15295 return resultobj;
15296 fail:
15297 return NULL;
15298 }
15299
15300
15301 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15302 PyObject *resultobj;
15303 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15304 PyObject * obj0 = 0 ;
15305 char *kwnames[] = {
15306 (char *) "self", NULL
15307 };
15308
15309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15311 if (SWIG_arg_fail(1)) SWIG_fail;
15312 {
15313 PyThreadState* __tstate = wxPyBeginAllowThreads();
15314 (arg1)->Allow();
15315
15316 wxPyEndAllowThreads(__tstate);
15317 if (PyErr_Occurred()) SWIG_fail;
15318 }
15319 Py_INCREF(Py_None); resultobj = Py_None;
15320 return resultobj;
15321 fail:
15322 return NULL;
15323 }
15324
15325
15326 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15327 PyObject *resultobj;
15328 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15329 bool result;
15330 PyObject * obj0 = 0 ;
15331 char *kwnames[] = {
15332 (char *) "self", NULL
15333 };
15334
15335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15337 if (SWIG_arg_fail(1)) SWIG_fail;
15338 {
15339 PyThreadState* __tstate = wxPyBeginAllowThreads();
15340 result = (bool)(arg1)->IsAllowed();
15341
15342 wxPyEndAllowThreads(__tstate);
15343 if (PyErr_Occurred()) SWIG_fail;
15344 }
15345 {
15346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15347 }
15348 return resultobj;
15349 fail:
15350 return NULL;
15351 }
15352
15353
15354 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15355 PyObject *obj;
15356 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15357 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15358 Py_INCREF(obj);
15359 return Py_BuildValue((char *)"");
15360 }
15361 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15362 PyObject *resultobj;
15363 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15364 int arg2 = (int) 0 ;
15365 int arg3 = (int) 0 ;
15366 int arg4 = (int) 0 ;
15367 wxScrollEvent *result;
15368 PyObject * obj0 = 0 ;
15369 PyObject * obj1 = 0 ;
15370 PyObject * obj2 = 0 ;
15371 PyObject * obj3 = 0 ;
15372 char *kwnames[] = {
15373 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15374 };
15375
15376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15377 if (obj0) {
15378 {
15379 arg1 = (wxEventType)(SWIG_As_int(obj0));
15380 if (SWIG_arg_fail(1)) SWIG_fail;
15381 }
15382 }
15383 if (obj1) {
15384 {
15385 arg2 = (int)(SWIG_As_int(obj1));
15386 if (SWIG_arg_fail(2)) SWIG_fail;
15387 }
15388 }
15389 if (obj2) {
15390 {
15391 arg3 = (int)(SWIG_As_int(obj2));
15392 if (SWIG_arg_fail(3)) SWIG_fail;
15393 }
15394 }
15395 if (obj3) {
15396 {
15397 arg4 = (int)(SWIG_As_int(obj3));
15398 if (SWIG_arg_fail(4)) SWIG_fail;
15399 }
15400 }
15401 {
15402 PyThreadState* __tstate = wxPyBeginAllowThreads();
15403 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15404
15405 wxPyEndAllowThreads(__tstate);
15406 if (PyErr_Occurred()) SWIG_fail;
15407 }
15408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15409 return resultobj;
15410 fail:
15411 return NULL;
15412 }
15413
15414
15415 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15416 PyObject *resultobj;
15417 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15418 int result;
15419 PyObject * obj0 = 0 ;
15420 char *kwnames[] = {
15421 (char *) "self", NULL
15422 };
15423
15424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15426 if (SWIG_arg_fail(1)) SWIG_fail;
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15430
15431 wxPyEndAllowThreads(__tstate);
15432 if (PyErr_Occurred()) SWIG_fail;
15433 }
15434 {
15435 resultobj = SWIG_From_int((int)(result));
15436 }
15437 return resultobj;
15438 fail:
15439 return NULL;
15440 }
15441
15442
15443 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15444 PyObject *resultobj;
15445 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15446 int result;
15447 PyObject * obj0 = 0 ;
15448 char *kwnames[] = {
15449 (char *) "self", NULL
15450 };
15451
15452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15454 if (SWIG_arg_fail(1)) SWIG_fail;
15455 {
15456 PyThreadState* __tstate = wxPyBeginAllowThreads();
15457 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15458
15459 wxPyEndAllowThreads(__tstate);
15460 if (PyErr_Occurred()) SWIG_fail;
15461 }
15462 {
15463 resultobj = SWIG_From_int((int)(result));
15464 }
15465 return resultobj;
15466 fail:
15467 return NULL;
15468 }
15469
15470
15471 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15472 PyObject *resultobj;
15473 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15474 int arg2 ;
15475 PyObject * obj0 = 0 ;
15476 PyObject * obj1 = 0 ;
15477 char *kwnames[] = {
15478 (char *) "self",(char *) "orient", NULL
15479 };
15480
15481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15483 if (SWIG_arg_fail(1)) SWIG_fail;
15484 {
15485 arg2 = (int)(SWIG_As_int(obj1));
15486 if (SWIG_arg_fail(2)) SWIG_fail;
15487 }
15488 {
15489 PyThreadState* __tstate = wxPyBeginAllowThreads();
15490 (arg1)->SetOrientation(arg2);
15491
15492 wxPyEndAllowThreads(__tstate);
15493 if (PyErr_Occurred()) SWIG_fail;
15494 }
15495 Py_INCREF(Py_None); resultobj = Py_None;
15496 return resultobj;
15497 fail:
15498 return NULL;
15499 }
15500
15501
15502 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15503 PyObject *resultobj;
15504 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15505 int arg2 ;
15506 PyObject * obj0 = 0 ;
15507 PyObject * obj1 = 0 ;
15508 char *kwnames[] = {
15509 (char *) "self",(char *) "pos", NULL
15510 };
15511
15512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15514 if (SWIG_arg_fail(1)) SWIG_fail;
15515 {
15516 arg2 = (int)(SWIG_As_int(obj1));
15517 if (SWIG_arg_fail(2)) SWIG_fail;
15518 }
15519 {
15520 PyThreadState* __tstate = wxPyBeginAllowThreads();
15521 (arg1)->SetPosition(arg2);
15522
15523 wxPyEndAllowThreads(__tstate);
15524 if (PyErr_Occurred()) SWIG_fail;
15525 }
15526 Py_INCREF(Py_None); resultobj = Py_None;
15527 return resultobj;
15528 fail:
15529 return NULL;
15530 }
15531
15532
15533 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15534 PyObject *obj;
15535 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15536 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15537 Py_INCREF(obj);
15538 return Py_BuildValue((char *)"");
15539 }
15540 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15541 PyObject *resultobj;
15542 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15543 int arg2 = (int) 0 ;
15544 int arg3 = (int) 0 ;
15545 wxScrollWinEvent *result;
15546 PyObject * obj0 = 0 ;
15547 PyObject * obj1 = 0 ;
15548 PyObject * obj2 = 0 ;
15549 char *kwnames[] = {
15550 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15551 };
15552
15553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15554 if (obj0) {
15555 {
15556 arg1 = (wxEventType)(SWIG_As_int(obj0));
15557 if (SWIG_arg_fail(1)) SWIG_fail;
15558 }
15559 }
15560 if (obj1) {
15561 {
15562 arg2 = (int)(SWIG_As_int(obj1));
15563 if (SWIG_arg_fail(2)) SWIG_fail;
15564 }
15565 }
15566 if (obj2) {
15567 {
15568 arg3 = (int)(SWIG_As_int(obj2));
15569 if (SWIG_arg_fail(3)) SWIG_fail;
15570 }
15571 }
15572 {
15573 PyThreadState* __tstate = wxPyBeginAllowThreads();
15574 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15575
15576 wxPyEndAllowThreads(__tstate);
15577 if (PyErr_Occurred()) SWIG_fail;
15578 }
15579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15580 return resultobj;
15581 fail:
15582 return NULL;
15583 }
15584
15585
15586 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15587 PyObject *resultobj;
15588 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15589 int result;
15590 PyObject * obj0 = 0 ;
15591 char *kwnames[] = {
15592 (char *) "self", NULL
15593 };
15594
15595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15597 if (SWIG_arg_fail(1)) SWIG_fail;
15598 {
15599 PyThreadState* __tstate = wxPyBeginAllowThreads();
15600 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15601
15602 wxPyEndAllowThreads(__tstate);
15603 if (PyErr_Occurred()) SWIG_fail;
15604 }
15605 {
15606 resultobj = SWIG_From_int((int)(result));
15607 }
15608 return resultobj;
15609 fail:
15610 return NULL;
15611 }
15612
15613
15614 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15615 PyObject *resultobj;
15616 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15617 int result;
15618 PyObject * obj0 = 0 ;
15619 char *kwnames[] = {
15620 (char *) "self", NULL
15621 };
15622
15623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15625 if (SWIG_arg_fail(1)) SWIG_fail;
15626 {
15627 PyThreadState* __tstate = wxPyBeginAllowThreads();
15628 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15629
15630 wxPyEndAllowThreads(__tstate);
15631 if (PyErr_Occurred()) SWIG_fail;
15632 }
15633 {
15634 resultobj = SWIG_From_int((int)(result));
15635 }
15636 return resultobj;
15637 fail:
15638 return NULL;
15639 }
15640
15641
15642 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15643 PyObject *resultobj;
15644 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15645 int arg2 ;
15646 PyObject * obj0 = 0 ;
15647 PyObject * obj1 = 0 ;
15648 char *kwnames[] = {
15649 (char *) "self",(char *) "orient", NULL
15650 };
15651
15652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15654 if (SWIG_arg_fail(1)) SWIG_fail;
15655 {
15656 arg2 = (int)(SWIG_As_int(obj1));
15657 if (SWIG_arg_fail(2)) SWIG_fail;
15658 }
15659 {
15660 PyThreadState* __tstate = wxPyBeginAllowThreads();
15661 (arg1)->SetOrientation(arg2);
15662
15663 wxPyEndAllowThreads(__tstate);
15664 if (PyErr_Occurred()) SWIG_fail;
15665 }
15666 Py_INCREF(Py_None); resultobj = Py_None;
15667 return resultobj;
15668 fail:
15669 return NULL;
15670 }
15671
15672
15673 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15674 PyObject *resultobj;
15675 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15676 int arg2 ;
15677 PyObject * obj0 = 0 ;
15678 PyObject * obj1 = 0 ;
15679 char *kwnames[] = {
15680 (char *) "self",(char *) "pos", NULL
15681 };
15682
15683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15685 if (SWIG_arg_fail(1)) SWIG_fail;
15686 {
15687 arg2 = (int)(SWIG_As_int(obj1));
15688 if (SWIG_arg_fail(2)) SWIG_fail;
15689 }
15690 {
15691 PyThreadState* __tstate = wxPyBeginAllowThreads();
15692 (arg1)->SetPosition(arg2);
15693
15694 wxPyEndAllowThreads(__tstate);
15695 if (PyErr_Occurred()) SWIG_fail;
15696 }
15697 Py_INCREF(Py_None); resultobj = Py_None;
15698 return resultobj;
15699 fail:
15700 return NULL;
15701 }
15702
15703
15704 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15705 PyObject *obj;
15706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15707 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15708 Py_INCREF(obj);
15709 return Py_BuildValue((char *)"");
15710 }
15711 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15712 PyObject *resultobj;
15713 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15714 wxMouseEvent *result;
15715 PyObject * obj0 = 0 ;
15716 char *kwnames[] = {
15717 (char *) "mouseType", NULL
15718 };
15719
15720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15721 if (obj0) {
15722 {
15723 arg1 = (wxEventType)(SWIG_As_int(obj0));
15724 if (SWIG_arg_fail(1)) SWIG_fail;
15725 }
15726 }
15727 {
15728 PyThreadState* __tstate = wxPyBeginAllowThreads();
15729 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15730
15731 wxPyEndAllowThreads(__tstate);
15732 if (PyErr_Occurred()) SWIG_fail;
15733 }
15734 {
15735 resultobj = wxPyMake_wxObject(result, 1);
15736 }
15737 return resultobj;
15738 fail:
15739 return NULL;
15740 }
15741
15742
15743 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15744 PyObject *resultobj;
15745 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15746 bool result;
15747 PyObject * obj0 = 0 ;
15748 char *kwnames[] = {
15749 (char *) "self", NULL
15750 };
15751
15752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15754 if (SWIG_arg_fail(1)) SWIG_fail;
15755 {
15756 PyThreadState* __tstate = wxPyBeginAllowThreads();
15757 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15758
15759 wxPyEndAllowThreads(__tstate);
15760 if (PyErr_Occurred()) SWIG_fail;
15761 }
15762 {
15763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15764 }
15765 return resultobj;
15766 fail:
15767 return NULL;
15768 }
15769
15770
15771 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15772 PyObject *resultobj;
15773 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15774 int arg2 = (int) wxMOUSE_BTN_ANY ;
15775 bool result;
15776 PyObject * obj0 = 0 ;
15777 PyObject * obj1 = 0 ;
15778 char *kwnames[] = {
15779 (char *) "self",(char *) "but", NULL
15780 };
15781
15782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15784 if (SWIG_arg_fail(1)) SWIG_fail;
15785 if (obj1) {
15786 {
15787 arg2 = (int)(SWIG_As_int(obj1));
15788 if (SWIG_arg_fail(2)) SWIG_fail;
15789 }
15790 }
15791 {
15792 PyThreadState* __tstate = wxPyBeginAllowThreads();
15793 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15794
15795 wxPyEndAllowThreads(__tstate);
15796 if (PyErr_Occurred()) SWIG_fail;
15797 }
15798 {
15799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15800 }
15801 return resultobj;
15802 fail:
15803 return NULL;
15804 }
15805
15806
15807 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15808 PyObject *resultobj;
15809 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15810 int arg2 = (int) wxMOUSE_BTN_ANY ;
15811 bool result;
15812 PyObject * obj0 = 0 ;
15813 PyObject * obj1 = 0 ;
15814 char *kwnames[] = {
15815 (char *) "self",(char *) "but", NULL
15816 };
15817
15818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
15819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15820 if (SWIG_arg_fail(1)) SWIG_fail;
15821 if (obj1) {
15822 {
15823 arg2 = (int)(SWIG_As_int(obj1));
15824 if (SWIG_arg_fail(2)) SWIG_fail;
15825 }
15826 }
15827 {
15828 PyThreadState* __tstate = wxPyBeginAllowThreads();
15829 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
15830
15831 wxPyEndAllowThreads(__tstate);
15832 if (PyErr_Occurred()) SWIG_fail;
15833 }
15834 {
15835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15836 }
15837 return resultobj;
15838 fail:
15839 return NULL;
15840 }
15841
15842
15843 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
15844 PyObject *resultobj;
15845 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15846 int arg2 = (int) wxMOUSE_BTN_ANY ;
15847 bool result;
15848 PyObject * obj0 = 0 ;
15849 PyObject * obj1 = 0 ;
15850 char *kwnames[] = {
15851 (char *) "self",(char *) "but", NULL
15852 };
15853
15854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
15855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15856 if (SWIG_arg_fail(1)) SWIG_fail;
15857 if (obj1) {
15858 {
15859 arg2 = (int)(SWIG_As_int(obj1));
15860 if (SWIG_arg_fail(2)) SWIG_fail;
15861 }
15862 }
15863 {
15864 PyThreadState* __tstate = wxPyBeginAllowThreads();
15865 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
15866
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 {
15871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15872 }
15873 return resultobj;
15874 fail:
15875 return NULL;
15876 }
15877
15878
15879 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
15880 PyObject *resultobj;
15881 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15882 int arg2 ;
15883 bool result;
15884 PyObject * obj0 = 0 ;
15885 PyObject * obj1 = 0 ;
15886 char *kwnames[] = {
15887 (char *) "self",(char *) "but", NULL
15888 };
15889
15890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
15891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15892 if (SWIG_arg_fail(1)) SWIG_fail;
15893 {
15894 arg2 = (int)(SWIG_As_int(obj1));
15895 if (SWIG_arg_fail(2)) SWIG_fail;
15896 }
15897 {
15898 PyThreadState* __tstate = wxPyBeginAllowThreads();
15899 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
15900
15901 wxPyEndAllowThreads(__tstate);
15902 if (PyErr_Occurred()) SWIG_fail;
15903 }
15904 {
15905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15906 }
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
15914 PyObject *resultobj;
15915 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15916 int arg2 ;
15917 bool result;
15918 PyObject * obj0 = 0 ;
15919 PyObject * obj1 = 0 ;
15920 char *kwnames[] = {
15921 (char *) "self",(char *) "but", NULL
15922 };
15923
15924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
15925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15926 if (SWIG_arg_fail(1)) SWIG_fail;
15927 {
15928 arg2 = (int)(SWIG_As_int(obj1));
15929 if (SWIG_arg_fail(2)) SWIG_fail;
15930 }
15931 {
15932 PyThreadState* __tstate = wxPyBeginAllowThreads();
15933 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
15934
15935 wxPyEndAllowThreads(__tstate);
15936 if (PyErr_Occurred()) SWIG_fail;
15937 }
15938 {
15939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15940 }
15941 return resultobj;
15942 fail:
15943 return NULL;
15944 }
15945
15946
15947 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
15948 PyObject *resultobj;
15949 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15950 int result;
15951 PyObject * obj0 = 0 ;
15952 char *kwnames[] = {
15953 (char *) "self", NULL
15954 };
15955
15956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
15957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15958 if (SWIG_arg_fail(1)) SWIG_fail;
15959 {
15960 PyThreadState* __tstate = wxPyBeginAllowThreads();
15961 result = (int)((wxMouseEvent const *)arg1)->GetButton();
15962
15963 wxPyEndAllowThreads(__tstate);
15964 if (PyErr_Occurred()) SWIG_fail;
15965 }
15966 {
15967 resultobj = SWIG_From_int((int)(result));
15968 }
15969 return resultobj;
15970 fail:
15971 return NULL;
15972 }
15973
15974
15975 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
15976 PyObject *resultobj;
15977 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15978 bool result;
15979 PyObject * obj0 = 0 ;
15980 char *kwnames[] = {
15981 (char *) "self", NULL
15982 };
15983
15984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
15985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15986 if (SWIG_arg_fail(1)) SWIG_fail;
15987 {
15988 PyThreadState* __tstate = wxPyBeginAllowThreads();
15989 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
15990
15991 wxPyEndAllowThreads(__tstate);
15992 if (PyErr_Occurred()) SWIG_fail;
15993 }
15994 {
15995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15996 }
15997 return resultobj;
15998 fail:
15999 return NULL;
16000 }
16001
16002
16003 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16004 PyObject *resultobj;
16005 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16006 bool result;
16007 PyObject * obj0 = 0 ;
16008 char *kwnames[] = {
16009 (char *) "self", NULL
16010 };
16011
16012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16014 if (SWIG_arg_fail(1)) SWIG_fail;
16015 {
16016 PyThreadState* __tstate = wxPyBeginAllowThreads();
16017 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16018
16019 wxPyEndAllowThreads(__tstate);
16020 if (PyErr_Occurred()) SWIG_fail;
16021 }
16022 {
16023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16024 }
16025 return resultobj;
16026 fail:
16027 return NULL;
16028 }
16029
16030
16031 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16032 PyObject *resultobj;
16033 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16034 bool result;
16035 PyObject * obj0 = 0 ;
16036 char *kwnames[] = {
16037 (char *) "self", NULL
16038 };
16039
16040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16042 if (SWIG_arg_fail(1)) SWIG_fail;
16043 {
16044 PyThreadState* __tstate = wxPyBeginAllowThreads();
16045 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16046
16047 wxPyEndAllowThreads(__tstate);
16048 if (PyErr_Occurred()) SWIG_fail;
16049 }
16050 {
16051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16052 }
16053 return resultobj;
16054 fail:
16055 return NULL;
16056 }
16057
16058
16059 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16060 PyObject *resultobj;
16061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16062 bool result;
16063 PyObject * obj0 = 0 ;
16064 char *kwnames[] = {
16065 (char *) "self", NULL
16066 };
16067
16068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16070 if (SWIG_arg_fail(1)) SWIG_fail;
16071 {
16072 PyThreadState* __tstate = wxPyBeginAllowThreads();
16073 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16074
16075 wxPyEndAllowThreads(__tstate);
16076 if (PyErr_Occurred()) SWIG_fail;
16077 }
16078 {
16079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16080 }
16081 return resultobj;
16082 fail:
16083 return NULL;
16084 }
16085
16086
16087 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16088 PyObject *resultobj;
16089 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16090 bool result;
16091 PyObject * obj0 = 0 ;
16092 char *kwnames[] = {
16093 (char *) "self", NULL
16094 };
16095
16096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16098 if (SWIG_arg_fail(1)) SWIG_fail;
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16102
16103 wxPyEndAllowThreads(__tstate);
16104 if (PyErr_Occurred()) SWIG_fail;
16105 }
16106 {
16107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16108 }
16109 return resultobj;
16110 fail:
16111 return NULL;
16112 }
16113
16114
16115 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16116 PyObject *resultobj;
16117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16118 bool result;
16119 PyObject * obj0 = 0 ;
16120 char *kwnames[] = {
16121 (char *) "self", NULL
16122 };
16123
16124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16126 if (SWIG_arg_fail(1)) SWIG_fail;
16127 {
16128 PyThreadState* __tstate = wxPyBeginAllowThreads();
16129 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16130
16131 wxPyEndAllowThreads(__tstate);
16132 if (PyErr_Occurred()) SWIG_fail;
16133 }
16134 {
16135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16136 }
16137 return resultobj;
16138 fail:
16139 return NULL;
16140 }
16141
16142
16143 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16144 PyObject *resultobj;
16145 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16146 bool result;
16147 PyObject * obj0 = 0 ;
16148 char *kwnames[] = {
16149 (char *) "self", NULL
16150 };
16151
16152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16154 if (SWIG_arg_fail(1)) SWIG_fail;
16155 {
16156 PyThreadState* __tstate = wxPyBeginAllowThreads();
16157 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16158
16159 wxPyEndAllowThreads(__tstate);
16160 if (PyErr_Occurred()) SWIG_fail;
16161 }
16162 {
16163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16164 }
16165 return resultobj;
16166 fail:
16167 return NULL;
16168 }
16169
16170
16171 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16172 PyObject *resultobj;
16173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16174 bool result;
16175 PyObject * obj0 = 0 ;
16176 char *kwnames[] = {
16177 (char *) "self", NULL
16178 };
16179
16180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16182 if (SWIG_arg_fail(1)) SWIG_fail;
16183 {
16184 PyThreadState* __tstate = wxPyBeginAllowThreads();
16185 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16186
16187 wxPyEndAllowThreads(__tstate);
16188 if (PyErr_Occurred()) SWIG_fail;
16189 }
16190 {
16191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16192 }
16193 return resultobj;
16194 fail:
16195 return NULL;
16196 }
16197
16198
16199 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16200 PyObject *resultobj;
16201 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16202 bool result;
16203 PyObject * obj0 = 0 ;
16204 char *kwnames[] = {
16205 (char *) "self", NULL
16206 };
16207
16208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16210 if (SWIG_arg_fail(1)) SWIG_fail;
16211 {
16212 PyThreadState* __tstate = wxPyBeginAllowThreads();
16213 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16214
16215 wxPyEndAllowThreads(__tstate);
16216 if (PyErr_Occurred()) SWIG_fail;
16217 }
16218 {
16219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16220 }
16221 return resultobj;
16222 fail:
16223 return NULL;
16224 }
16225
16226
16227 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16228 PyObject *resultobj;
16229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16230 bool result;
16231 PyObject * obj0 = 0 ;
16232 char *kwnames[] = {
16233 (char *) "self", NULL
16234 };
16235
16236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16238 if (SWIG_arg_fail(1)) SWIG_fail;
16239 {
16240 PyThreadState* __tstate = wxPyBeginAllowThreads();
16241 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16242
16243 wxPyEndAllowThreads(__tstate);
16244 if (PyErr_Occurred()) SWIG_fail;
16245 }
16246 {
16247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16248 }
16249 return resultobj;
16250 fail:
16251 return NULL;
16252 }
16253
16254
16255 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16256 PyObject *resultobj;
16257 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16258 bool result;
16259 PyObject * obj0 = 0 ;
16260 char *kwnames[] = {
16261 (char *) "self", NULL
16262 };
16263
16264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16266 if (SWIG_arg_fail(1)) SWIG_fail;
16267 {
16268 PyThreadState* __tstate = wxPyBeginAllowThreads();
16269 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16270
16271 wxPyEndAllowThreads(__tstate);
16272 if (PyErr_Occurred()) SWIG_fail;
16273 }
16274 {
16275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16276 }
16277 return resultobj;
16278 fail:
16279 return NULL;
16280 }
16281
16282
16283 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16284 PyObject *resultobj;
16285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16286 bool result;
16287 PyObject * obj0 = 0 ;
16288 char *kwnames[] = {
16289 (char *) "self", NULL
16290 };
16291
16292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16294 if (SWIG_arg_fail(1)) SWIG_fail;
16295 {
16296 PyThreadState* __tstate = wxPyBeginAllowThreads();
16297 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16298
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 {
16303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16304 }
16305 return resultobj;
16306 fail:
16307 return NULL;
16308 }
16309
16310
16311 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16312 PyObject *resultobj;
16313 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16314 bool result;
16315 PyObject * obj0 = 0 ;
16316 char *kwnames[] = {
16317 (char *) "self", NULL
16318 };
16319
16320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16322 if (SWIG_arg_fail(1)) SWIG_fail;
16323 {
16324 PyThreadState* __tstate = wxPyBeginAllowThreads();
16325 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16326
16327 wxPyEndAllowThreads(__tstate);
16328 if (PyErr_Occurred()) SWIG_fail;
16329 }
16330 {
16331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16332 }
16333 return resultobj;
16334 fail:
16335 return NULL;
16336 }
16337
16338
16339 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16340 PyObject *resultobj;
16341 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16342 bool result;
16343 PyObject * obj0 = 0 ;
16344 char *kwnames[] = {
16345 (char *) "self", NULL
16346 };
16347
16348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16350 if (SWIG_arg_fail(1)) SWIG_fail;
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
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_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16368 PyObject *resultobj;
16369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16370 bool result;
16371 PyObject * obj0 = 0 ;
16372 char *kwnames[] = {
16373 (char *) "self", NULL
16374 };
16375
16376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16378 if (SWIG_arg_fail(1)) SWIG_fail;
16379 {
16380 PyThreadState* __tstate = wxPyBeginAllowThreads();
16381 result = (bool)(arg1)->LeftIsDown();
16382
16383 wxPyEndAllowThreads(__tstate);
16384 if (PyErr_Occurred()) SWIG_fail;
16385 }
16386 {
16387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16388 }
16389 return resultobj;
16390 fail:
16391 return NULL;
16392 }
16393
16394
16395 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16396 PyObject *resultobj;
16397 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16398 bool result;
16399 PyObject * obj0 = 0 ;
16400 char *kwnames[] = {
16401 (char *) "self", NULL
16402 };
16403
16404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16406 if (SWIG_arg_fail(1)) SWIG_fail;
16407 {
16408 PyThreadState* __tstate = wxPyBeginAllowThreads();
16409 result = (bool)(arg1)->MiddleIsDown();
16410
16411 wxPyEndAllowThreads(__tstate);
16412 if (PyErr_Occurred()) SWIG_fail;
16413 }
16414 {
16415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16416 }
16417 return resultobj;
16418 fail:
16419 return NULL;
16420 }
16421
16422
16423 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16424 PyObject *resultobj;
16425 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16426 bool result;
16427 PyObject * obj0 = 0 ;
16428 char *kwnames[] = {
16429 (char *) "self", NULL
16430 };
16431
16432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16434 if (SWIG_arg_fail(1)) SWIG_fail;
16435 {
16436 PyThreadState* __tstate = wxPyBeginAllowThreads();
16437 result = (bool)(arg1)->RightIsDown();
16438
16439 wxPyEndAllowThreads(__tstate);
16440 if (PyErr_Occurred()) SWIG_fail;
16441 }
16442 {
16443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16444 }
16445 return resultobj;
16446 fail:
16447 return NULL;
16448 }
16449
16450
16451 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj;
16453 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16454 bool result;
16455 PyObject * obj0 = 0 ;
16456 char *kwnames[] = {
16457 (char *) "self", NULL
16458 };
16459
16460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16462 if (SWIG_arg_fail(1)) SWIG_fail;
16463 {
16464 PyThreadState* __tstate = wxPyBeginAllowThreads();
16465 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16466
16467 wxPyEndAllowThreads(__tstate);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 }
16470 {
16471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16472 }
16473 return resultobj;
16474 fail:
16475 return NULL;
16476 }
16477
16478
16479 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16480 PyObject *resultobj;
16481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16482 bool result;
16483 PyObject * obj0 = 0 ;
16484 char *kwnames[] = {
16485 (char *) "self", NULL
16486 };
16487
16488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16490 if (SWIG_arg_fail(1)) SWIG_fail;
16491 {
16492 PyThreadState* __tstate = wxPyBeginAllowThreads();
16493 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16494
16495 wxPyEndAllowThreads(__tstate);
16496 if (PyErr_Occurred()) SWIG_fail;
16497 }
16498 {
16499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16500 }
16501 return resultobj;
16502 fail:
16503 return NULL;
16504 }
16505
16506
16507 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16508 PyObject *resultobj;
16509 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16510 bool result;
16511 PyObject * obj0 = 0 ;
16512 char *kwnames[] = {
16513 (char *) "self", NULL
16514 };
16515
16516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16518 if (SWIG_arg_fail(1)) SWIG_fail;
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16522
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 {
16527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16528 }
16529 return resultobj;
16530 fail:
16531 return NULL;
16532 }
16533
16534
16535 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj;
16537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16538 bool result;
16539 PyObject * obj0 = 0 ;
16540 char *kwnames[] = {
16541 (char *) "self", NULL
16542 };
16543
16544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16546 if (SWIG_arg_fail(1)) SWIG_fail;
16547 {
16548 PyThreadState* __tstate = wxPyBeginAllowThreads();
16549 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16550
16551 wxPyEndAllowThreads(__tstate);
16552 if (PyErr_Occurred()) SWIG_fail;
16553 }
16554 {
16555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16556 }
16557 return resultobj;
16558 fail:
16559 return NULL;
16560 }
16561
16562
16563 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16564 PyObject *resultobj;
16565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16566 wxPoint result;
16567 PyObject * obj0 = 0 ;
16568 char *kwnames[] = {
16569 (char *) "self", NULL
16570 };
16571
16572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16574 if (SWIG_arg_fail(1)) SWIG_fail;
16575 {
16576 PyThreadState* __tstate = wxPyBeginAllowThreads();
16577 result = (arg1)->GetPosition();
16578
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 {
16583 wxPoint * resultptr;
16584 resultptr = new wxPoint((wxPoint &)(result));
16585 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16586 }
16587 return resultobj;
16588 fail:
16589 return NULL;
16590 }
16591
16592
16593 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16594 PyObject *resultobj;
16595 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16596 long *arg2 = (long *) 0 ;
16597 long *arg3 = (long *) 0 ;
16598 long temp2 ;
16599 int res2 = 0 ;
16600 long temp3 ;
16601 int res3 = 0 ;
16602 PyObject * obj0 = 0 ;
16603 char *kwnames[] = {
16604 (char *) "self", NULL
16605 };
16606
16607 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16608 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16611 if (SWIG_arg_fail(1)) SWIG_fail;
16612 {
16613 PyThreadState* __tstate = wxPyBeginAllowThreads();
16614 (arg1)->GetPosition(arg2,arg3);
16615
16616 wxPyEndAllowThreads(__tstate);
16617 if (PyErr_Occurred()) SWIG_fail;
16618 }
16619 Py_INCREF(Py_None); resultobj = Py_None;
16620 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16621 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16622 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16623 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16624 return resultobj;
16625 fail:
16626 return NULL;
16627 }
16628
16629
16630 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16631 PyObject *resultobj;
16632 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16633 wxDC *arg2 = 0 ;
16634 wxPoint result;
16635 PyObject * obj0 = 0 ;
16636 PyObject * obj1 = 0 ;
16637 char *kwnames[] = {
16638 (char *) "self",(char *) "dc", NULL
16639 };
16640
16641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16643 if (SWIG_arg_fail(1)) SWIG_fail;
16644 {
16645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16646 if (SWIG_arg_fail(2)) SWIG_fail;
16647 if (arg2 == NULL) {
16648 SWIG_null_ref("wxDC");
16649 }
16650 if (SWIG_arg_fail(2)) SWIG_fail;
16651 }
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16655
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 {
16660 wxPoint * resultptr;
16661 resultptr = new wxPoint((wxPoint &)(result));
16662 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16663 }
16664 return resultobj;
16665 fail:
16666 return NULL;
16667 }
16668
16669
16670 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16671 PyObject *resultobj;
16672 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16673 int result;
16674 PyObject * obj0 = 0 ;
16675 char *kwnames[] = {
16676 (char *) "self", NULL
16677 };
16678
16679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16681 if (SWIG_arg_fail(1)) SWIG_fail;
16682 {
16683 PyThreadState* __tstate = wxPyBeginAllowThreads();
16684 result = (int)((wxMouseEvent const *)arg1)->GetX();
16685
16686 wxPyEndAllowThreads(__tstate);
16687 if (PyErr_Occurred()) SWIG_fail;
16688 }
16689 {
16690 resultobj = SWIG_From_int((int)(result));
16691 }
16692 return resultobj;
16693 fail:
16694 return NULL;
16695 }
16696
16697
16698 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16699 PyObject *resultobj;
16700 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16701 int result;
16702 PyObject * obj0 = 0 ;
16703 char *kwnames[] = {
16704 (char *) "self", NULL
16705 };
16706
16707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16709 if (SWIG_arg_fail(1)) SWIG_fail;
16710 {
16711 PyThreadState* __tstate = wxPyBeginAllowThreads();
16712 result = (int)((wxMouseEvent const *)arg1)->GetY();
16713
16714 wxPyEndAllowThreads(__tstate);
16715 if (PyErr_Occurred()) SWIG_fail;
16716 }
16717 {
16718 resultobj = SWIG_From_int((int)(result));
16719 }
16720 return resultobj;
16721 fail:
16722 return NULL;
16723 }
16724
16725
16726 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16727 PyObject *resultobj;
16728 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16729 int result;
16730 PyObject * obj0 = 0 ;
16731 char *kwnames[] = {
16732 (char *) "self", NULL
16733 };
16734
16735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16737 if (SWIG_arg_fail(1)) SWIG_fail;
16738 {
16739 PyThreadState* __tstate = wxPyBeginAllowThreads();
16740 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16741
16742 wxPyEndAllowThreads(__tstate);
16743 if (PyErr_Occurred()) SWIG_fail;
16744 }
16745 {
16746 resultobj = SWIG_From_int((int)(result));
16747 }
16748 return resultobj;
16749 fail:
16750 return NULL;
16751 }
16752
16753
16754 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16755 PyObject *resultobj;
16756 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16757 int result;
16758 PyObject * obj0 = 0 ;
16759 char *kwnames[] = {
16760 (char *) "self", NULL
16761 };
16762
16763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16765 if (SWIG_arg_fail(1)) SWIG_fail;
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16769
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 {
16774 resultobj = SWIG_From_int((int)(result));
16775 }
16776 return resultobj;
16777 fail:
16778 return NULL;
16779 }
16780
16781
16782 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16783 PyObject *resultobj;
16784 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16785 int result;
16786 PyObject * obj0 = 0 ;
16787 char *kwnames[] = {
16788 (char *) "self", NULL
16789 };
16790
16791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16793 if (SWIG_arg_fail(1)) SWIG_fail;
16794 {
16795 PyThreadState* __tstate = wxPyBeginAllowThreads();
16796 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16797
16798 wxPyEndAllowThreads(__tstate);
16799 if (PyErr_Occurred()) SWIG_fail;
16800 }
16801 {
16802 resultobj = SWIG_From_int((int)(result));
16803 }
16804 return resultobj;
16805 fail:
16806 return NULL;
16807 }
16808
16809
16810 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
16811 PyObject *resultobj;
16812 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16813 bool result;
16814 PyObject * obj0 = 0 ;
16815 char *kwnames[] = {
16816 (char *) "self", NULL
16817 };
16818
16819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
16820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16821 if (SWIG_arg_fail(1)) SWIG_fail;
16822 {
16823 PyThreadState* __tstate = wxPyBeginAllowThreads();
16824 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
16825
16826 wxPyEndAllowThreads(__tstate);
16827 if (PyErr_Occurred()) SWIG_fail;
16828 }
16829 {
16830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16831 }
16832 return resultobj;
16833 fail:
16834 return NULL;
16835 }
16836
16837
16838 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
16839 PyObject *resultobj;
16840 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16841 int arg2 ;
16842 PyObject * obj0 = 0 ;
16843 PyObject * obj1 = 0 ;
16844 char *kwnames[] = {
16845 (char *) "self",(char *) "m_x", NULL
16846 };
16847
16848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
16849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16850 if (SWIG_arg_fail(1)) SWIG_fail;
16851 {
16852 arg2 = (int)(SWIG_As_int(obj1));
16853 if (SWIG_arg_fail(2)) SWIG_fail;
16854 }
16855 if (arg1) (arg1)->m_x = arg2;
16856
16857 Py_INCREF(Py_None); resultobj = Py_None;
16858 return resultobj;
16859 fail:
16860 return NULL;
16861 }
16862
16863
16864 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
16865 PyObject *resultobj;
16866 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16867 int result;
16868 PyObject * obj0 = 0 ;
16869 char *kwnames[] = {
16870 (char *) "self", NULL
16871 };
16872
16873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
16874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16875 if (SWIG_arg_fail(1)) SWIG_fail;
16876 result = (int) ((arg1)->m_x);
16877
16878 {
16879 resultobj = SWIG_From_int((int)(result));
16880 }
16881 return resultobj;
16882 fail:
16883 return NULL;
16884 }
16885
16886
16887 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
16888 PyObject *resultobj;
16889 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16890 int arg2 ;
16891 PyObject * obj0 = 0 ;
16892 PyObject * obj1 = 0 ;
16893 char *kwnames[] = {
16894 (char *) "self",(char *) "m_y", NULL
16895 };
16896
16897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
16898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16899 if (SWIG_arg_fail(1)) SWIG_fail;
16900 {
16901 arg2 = (int)(SWIG_As_int(obj1));
16902 if (SWIG_arg_fail(2)) SWIG_fail;
16903 }
16904 if (arg1) (arg1)->m_y = arg2;
16905
16906 Py_INCREF(Py_None); resultobj = Py_None;
16907 return resultobj;
16908 fail:
16909 return NULL;
16910 }
16911
16912
16913 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
16914 PyObject *resultobj;
16915 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16916 int result;
16917 PyObject * obj0 = 0 ;
16918 char *kwnames[] = {
16919 (char *) "self", NULL
16920 };
16921
16922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
16923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16924 if (SWIG_arg_fail(1)) SWIG_fail;
16925 result = (int) ((arg1)->m_y);
16926
16927 {
16928 resultobj = SWIG_From_int((int)(result));
16929 }
16930 return resultobj;
16931 fail:
16932 return NULL;
16933 }
16934
16935
16936 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16937 PyObject *resultobj;
16938 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16939 bool arg2 ;
16940 PyObject * obj0 = 0 ;
16941 PyObject * obj1 = 0 ;
16942 char *kwnames[] = {
16943 (char *) "self",(char *) "m_leftDown", NULL
16944 };
16945
16946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
16947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16948 if (SWIG_arg_fail(1)) SWIG_fail;
16949 {
16950 arg2 = (bool)(SWIG_As_bool(obj1));
16951 if (SWIG_arg_fail(2)) SWIG_fail;
16952 }
16953 if (arg1) (arg1)->m_leftDown = arg2;
16954
16955 Py_INCREF(Py_None); resultobj = Py_None;
16956 return resultobj;
16957 fail:
16958 return NULL;
16959 }
16960
16961
16962 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
16963 PyObject *resultobj;
16964 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16965 bool result;
16966 PyObject * obj0 = 0 ;
16967 char *kwnames[] = {
16968 (char *) "self", NULL
16969 };
16970
16971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
16972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16973 if (SWIG_arg_fail(1)) SWIG_fail;
16974 result = (bool) ((arg1)->m_leftDown);
16975
16976 {
16977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16978 }
16979 return resultobj;
16980 fail:
16981 return NULL;
16982 }
16983
16984
16985 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16986 PyObject *resultobj;
16987 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16988 bool arg2 ;
16989 PyObject * obj0 = 0 ;
16990 PyObject * obj1 = 0 ;
16991 char *kwnames[] = {
16992 (char *) "self",(char *) "m_middleDown", NULL
16993 };
16994
16995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
16996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16997 if (SWIG_arg_fail(1)) SWIG_fail;
16998 {
16999 arg2 = (bool)(SWIG_As_bool(obj1));
17000 if (SWIG_arg_fail(2)) SWIG_fail;
17001 }
17002 if (arg1) (arg1)->m_middleDown = arg2;
17003
17004 Py_INCREF(Py_None); resultobj = Py_None;
17005 return resultobj;
17006 fail:
17007 return NULL;
17008 }
17009
17010
17011 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17012 PyObject *resultobj;
17013 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17014 bool result;
17015 PyObject * obj0 = 0 ;
17016 char *kwnames[] = {
17017 (char *) "self", NULL
17018 };
17019
17020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17022 if (SWIG_arg_fail(1)) SWIG_fail;
17023 result = (bool) ((arg1)->m_middleDown);
17024
17025 {
17026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17027 }
17028 return resultobj;
17029 fail:
17030 return NULL;
17031 }
17032
17033
17034 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17035 PyObject *resultobj;
17036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17037 bool arg2 ;
17038 PyObject * obj0 = 0 ;
17039 PyObject * obj1 = 0 ;
17040 char *kwnames[] = {
17041 (char *) "self",(char *) "m_rightDown", NULL
17042 };
17043
17044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17046 if (SWIG_arg_fail(1)) SWIG_fail;
17047 {
17048 arg2 = (bool)(SWIG_As_bool(obj1));
17049 if (SWIG_arg_fail(2)) SWIG_fail;
17050 }
17051 if (arg1) (arg1)->m_rightDown = arg2;
17052
17053 Py_INCREF(Py_None); resultobj = Py_None;
17054 return resultobj;
17055 fail:
17056 return NULL;
17057 }
17058
17059
17060 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17061 PyObject *resultobj;
17062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17063 bool result;
17064 PyObject * obj0 = 0 ;
17065 char *kwnames[] = {
17066 (char *) "self", NULL
17067 };
17068
17069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17071 if (SWIG_arg_fail(1)) SWIG_fail;
17072 result = (bool) ((arg1)->m_rightDown);
17073
17074 {
17075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17076 }
17077 return resultobj;
17078 fail:
17079 return NULL;
17080 }
17081
17082
17083 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17084 PyObject *resultobj;
17085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17086 bool arg2 ;
17087 PyObject * obj0 = 0 ;
17088 PyObject * obj1 = 0 ;
17089 char *kwnames[] = {
17090 (char *) "self",(char *) "m_controlDown", NULL
17091 };
17092
17093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17095 if (SWIG_arg_fail(1)) SWIG_fail;
17096 {
17097 arg2 = (bool)(SWIG_As_bool(obj1));
17098 if (SWIG_arg_fail(2)) SWIG_fail;
17099 }
17100 if (arg1) (arg1)->m_controlDown = arg2;
17101
17102 Py_INCREF(Py_None); resultobj = Py_None;
17103 return resultobj;
17104 fail:
17105 return NULL;
17106 }
17107
17108
17109 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17110 PyObject *resultobj;
17111 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17112 bool result;
17113 PyObject * obj0 = 0 ;
17114 char *kwnames[] = {
17115 (char *) "self", NULL
17116 };
17117
17118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17120 if (SWIG_arg_fail(1)) SWIG_fail;
17121 result = (bool) ((arg1)->m_controlDown);
17122
17123 {
17124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17125 }
17126 return resultobj;
17127 fail:
17128 return NULL;
17129 }
17130
17131
17132 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17133 PyObject *resultobj;
17134 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17135 bool arg2 ;
17136 PyObject * obj0 = 0 ;
17137 PyObject * obj1 = 0 ;
17138 char *kwnames[] = {
17139 (char *) "self",(char *) "m_shiftDown", NULL
17140 };
17141
17142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17144 if (SWIG_arg_fail(1)) SWIG_fail;
17145 {
17146 arg2 = (bool)(SWIG_As_bool(obj1));
17147 if (SWIG_arg_fail(2)) SWIG_fail;
17148 }
17149 if (arg1) (arg1)->m_shiftDown = arg2;
17150
17151 Py_INCREF(Py_None); resultobj = Py_None;
17152 return resultobj;
17153 fail:
17154 return NULL;
17155 }
17156
17157
17158 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17159 PyObject *resultobj;
17160 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17161 bool result;
17162 PyObject * obj0 = 0 ;
17163 char *kwnames[] = {
17164 (char *) "self", NULL
17165 };
17166
17167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",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 result = (bool) ((arg1)->m_shiftDown);
17171
17172 {
17173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17174 }
17175 return resultobj;
17176 fail:
17177 return NULL;
17178 }
17179
17180
17181 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17182 PyObject *resultobj;
17183 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17184 bool arg2 ;
17185 PyObject * obj0 = 0 ;
17186 PyObject * obj1 = 0 ;
17187 char *kwnames[] = {
17188 (char *) "self",(char *) "m_altDown", NULL
17189 };
17190
17191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17193 if (SWIG_arg_fail(1)) SWIG_fail;
17194 {
17195 arg2 = (bool)(SWIG_As_bool(obj1));
17196 if (SWIG_arg_fail(2)) SWIG_fail;
17197 }
17198 if (arg1) (arg1)->m_altDown = arg2;
17199
17200 Py_INCREF(Py_None); resultobj = Py_None;
17201 return resultobj;
17202 fail:
17203 return NULL;
17204 }
17205
17206
17207 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17208 PyObject *resultobj;
17209 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17210 bool result;
17211 PyObject * obj0 = 0 ;
17212 char *kwnames[] = {
17213 (char *) "self", NULL
17214 };
17215
17216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17218 if (SWIG_arg_fail(1)) SWIG_fail;
17219 result = (bool) ((arg1)->m_altDown);
17220
17221 {
17222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17223 }
17224 return resultobj;
17225 fail:
17226 return NULL;
17227 }
17228
17229
17230 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17231 PyObject *resultobj;
17232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17233 bool arg2 ;
17234 PyObject * obj0 = 0 ;
17235 PyObject * obj1 = 0 ;
17236 char *kwnames[] = {
17237 (char *) "self",(char *) "m_metaDown", NULL
17238 };
17239
17240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17242 if (SWIG_arg_fail(1)) SWIG_fail;
17243 {
17244 arg2 = (bool)(SWIG_As_bool(obj1));
17245 if (SWIG_arg_fail(2)) SWIG_fail;
17246 }
17247 if (arg1) (arg1)->m_metaDown = arg2;
17248
17249 Py_INCREF(Py_None); resultobj = Py_None;
17250 return resultobj;
17251 fail:
17252 return NULL;
17253 }
17254
17255
17256 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17257 PyObject *resultobj;
17258 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17259 bool result;
17260 PyObject * obj0 = 0 ;
17261 char *kwnames[] = {
17262 (char *) "self", NULL
17263 };
17264
17265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17267 if (SWIG_arg_fail(1)) SWIG_fail;
17268 result = (bool) ((arg1)->m_metaDown);
17269
17270 {
17271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17272 }
17273 return resultobj;
17274 fail:
17275 return NULL;
17276 }
17277
17278
17279 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17280 PyObject *resultobj;
17281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17282 int arg2 ;
17283 PyObject * obj0 = 0 ;
17284 PyObject * obj1 = 0 ;
17285 char *kwnames[] = {
17286 (char *) "self",(char *) "m_wheelRotation", NULL
17287 };
17288
17289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17291 if (SWIG_arg_fail(1)) SWIG_fail;
17292 {
17293 arg2 = (int)(SWIG_As_int(obj1));
17294 if (SWIG_arg_fail(2)) SWIG_fail;
17295 }
17296 if (arg1) (arg1)->m_wheelRotation = arg2;
17297
17298 Py_INCREF(Py_None); resultobj = Py_None;
17299 return resultobj;
17300 fail:
17301 return NULL;
17302 }
17303
17304
17305 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17306 PyObject *resultobj;
17307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17308 int result;
17309 PyObject * obj0 = 0 ;
17310 char *kwnames[] = {
17311 (char *) "self", NULL
17312 };
17313
17314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17316 if (SWIG_arg_fail(1)) SWIG_fail;
17317 result = (int) ((arg1)->m_wheelRotation);
17318
17319 {
17320 resultobj = SWIG_From_int((int)(result));
17321 }
17322 return resultobj;
17323 fail:
17324 return NULL;
17325 }
17326
17327
17328 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17329 PyObject *resultobj;
17330 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17331 int arg2 ;
17332 PyObject * obj0 = 0 ;
17333 PyObject * obj1 = 0 ;
17334 char *kwnames[] = {
17335 (char *) "self",(char *) "m_wheelDelta", NULL
17336 };
17337
17338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17340 if (SWIG_arg_fail(1)) SWIG_fail;
17341 {
17342 arg2 = (int)(SWIG_As_int(obj1));
17343 if (SWIG_arg_fail(2)) SWIG_fail;
17344 }
17345 if (arg1) (arg1)->m_wheelDelta = arg2;
17346
17347 Py_INCREF(Py_None); resultobj = Py_None;
17348 return resultobj;
17349 fail:
17350 return NULL;
17351 }
17352
17353
17354 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17355 PyObject *resultobj;
17356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17357 int result;
17358 PyObject * obj0 = 0 ;
17359 char *kwnames[] = {
17360 (char *) "self", NULL
17361 };
17362
17363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17365 if (SWIG_arg_fail(1)) SWIG_fail;
17366 result = (int) ((arg1)->m_wheelDelta);
17367
17368 {
17369 resultobj = SWIG_From_int((int)(result));
17370 }
17371 return resultobj;
17372 fail:
17373 return NULL;
17374 }
17375
17376
17377 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17378 PyObject *resultobj;
17379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17380 int arg2 ;
17381 PyObject * obj0 = 0 ;
17382 PyObject * obj1 = 0 ;
17383 char *kwnames[] = {
17384 (char *) "self",(char *) "m_linesPerAction", NULL
17385 };
17386
17387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17389 if (SWIG_arg_fail(1)) SWIG_fail;
17390 {
17391 arg2 = (int)(SWIG_As_int(obj1));
17392 if (SWIG_arg_fail(2)) SWIG_fail;
17393 }
17394 if (arg1) (arg1)->m_linesPerAction = arg2;
17395
17396 Py_INCREF(Py_None); resultobj = Py_None;
17397 return resultobj;
17398 fail:
17399 return NULL;
17400 }
17401
17402
17403 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17404 PyObject *resultobj;
17405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17406 int result;
17407 PyObject * obj0 = 0 ;
17408 char *kwnames[] = {
17409 (char *) "self", NULL
17410 };
17411
17412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17414 if (SWIG_arg_fail(1)) SWIG_fail;
17415 result = (int) ((arg1)->m_linesPerAction);
17416
17417 {
17418 resultobj = SWIG_From_int((int)(result));
17419 }
17420 return resultobj;
17421 fail:
17422 return NULL;
17423 }
17424
17425
17426 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17427 PyObject *obj;
17428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17429 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17430 Py_INCREF(obj);
17431 return Py_BuildValue((char *)"");
17432 }
17433 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17434 PyObject *resultobj;
17435 int arg1 = (int) 0 ;
17436 int arg2 = (int) 0 ;
17437 wxSetCursorEvent *result;
17438 PyObject * obj0 = 0 ;
17439 PyObject * obj1 = 0 ;
17440 char *kwnames[] = {
17441 (char *) "x",(char *) "y", NULL
17442 };
17443
17444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17445 if (obj0) {
17446 {
17447 arg1 = (int)(SWIG_As_int(obj0));
17448 if (SWIG_arg_fail(1)) SWIG_fail;
17449 }
17450 }
17451 if (obj1) {
17452 {
17453 arg2 = (int)(SWIG_As_int(obj1));
17454 if (SWIG_arg_fail(2)) SWIG_fail;
17455 }
17456 }
17457 {
17458 PyThreadState* __tstate = wxPyBeginAllowThreads();
17459 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17460
17461 wxPyEndAllowThreads(__tstate);
17462 if (PyErr_Occurred()) SWIG_fail;
17463 }
17464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17465 return resultobj;
17466 fail:
17467 return NULL;
17468 }
17469
17470
17471 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17472 PyObject *resultobj;
17473 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17474 int result;
17475 PyObject * obj0 = 0 ;
17476 char *kwnames[] = {
17477 (char *) "self", NULL
17478 };
17479
17480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17482 if (SWIG_arg_fail(1)) SWIG_fail;
17483 {
17484 PyThreadState* __tstate = wxPyBeginAllowThreads();
17485 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17486
17487 wxPyEndAllowThreads(__tstate);
17488 if (PyErr_Occurred()) SWIG_fail;
17489 }
17490 {
17491 resultobj = SWIG_From_int((int)(result));
17492 }
17493 return resultobj;
17494 fail:
17495 return NULL;
17496 }
17497
17498
17499 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj;
17501 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17502 int result;
17503 PyObject * obj0 = 0 ;
17504 char *kwnames[] = {
17505 (char *) "self", NULL
17506 };
17507
17508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17510 if (SWIG_arg_fail(1)) SWIG_fail;
17511 {
17512 PyThreadState* __tstate = wxPyBeginAllowThreads();
17513 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17514
17515 wxPyEndAllowThreads(__tstate);
17516 if (PyErr_Occurred()) SWIG_fail;
17517 }
17518 {
17519 resultobj = SWIG_From_int((int)(result));
17520 }
17521 return resultobj;
17522 fail:
17523 return NULL;
17524 }
17525
17526
17527 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj;
17529 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17530 wxCursor *arg2 = 0 ;
17531 PyObject * obj0 = 0 ;
17532 PyObject * obj1 = 0 ;
17533 char *kwnames[] = {
17534 (char *) "self",(char *) "cursor", NULL
17535 };
17536
17537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17539 if (SWIG_arg_fail(1)) SWIG_fail;
17540 {
17541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17542 if (SWIG_arg_fail(2)) SWIG_fail;
17543 if (arg2 == NULL) {
17544 SWIG_null_ref("wxCursor");
17545 }
17546 if (SWIG_arg_fail(2)) SWIG_fail;
17547 }
17548 {
17549 PyThreadState* __tstate = wxPyBeginAllowThreads();
17550 (arg1)->SetCursor((wxCursor const &)*arg2);
17551
17552 wxPyEndAllowThreads(__tstate);
17553 if (PyErr_Occurred()) SWIG_fail;
17554 }
17555 Py_INCREF(Py_None); resultobj = Py_None;
17556 return resultobj;
17557 fail:
17558 return NULL;
17559 }
17560
17561
17562 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17563 PyObject *resultobj;
17564 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17565 wxCursor *result;
17566 PyObject * obj0 = 0 ;
17567 char *kwnames[] = {
17568 (char *) "self", NULL
17569 };
17570
17571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17573 if (SWIG_arg_fail(1)) SWIG_fail;
17574 {
17575 PyThreadState* __tstate = wxPyBeginAllowThreads();
17576 {
17577 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17578 result = (wxCursor *) &_result_ref;
17579 }
17580
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 {
17585 wxCursor* resultptr = new wxCursor(*result);
17586 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17587 }
17588 return resultobj;
17589 fail:
17590 return NULL;
17591 }
17592
17593
17594 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17595 PyObject *resultobj;
17596 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17597 bool result;
17598 PyObject * obj0 = 0 ;
17599 char *kwnames[] = {
17600 (char *) "self", NULL
17601 };
17602
17603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17605 if (SWIG_arg_fail(1)) SWIG_fail;
17606 {
17607 PyThreadState* __tstate = wxPyBeginAllowThreads();
17608 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17609
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 {
17614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17615 }
17616 return resultobj;
17617 fail:
17618 return NULL;
17619 }
17620
17621
17622 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17623 PyObject *obj;
17624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17625 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17626 Py_INCREF(obj);
17627 return Py_BuildValue((char *)"");
17628 }
17629 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17630 PyObject *resultobj;
17631 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17632 wxKeyEvent *result;
17633 PyObject * obj0 = 0 ;
17634 char *kwnames[] = {
17635 (char *) "keyType", NULL
17636 };
17637
17638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17639 if (obj0) {
17640 {
17641 arg1 = (wxEventType)(SWIG_As_int(obj0));
17642 if (SWIG_arg_fail(1)) SWIG_fail;
17643 }
17644 }
17645 {
17646 PyThreadState* __tstate = wxPyBeginAllowThreads();
17647 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17648
17649 wxPyEndAllowThreads(__tstate);
17650 if (PyErr_Occurred()) SWIG_fail;
17651 }
17652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17653 return resultobj;
17654 fail:
17655 return NULL;
17656 }
17657
17658
17659 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17660 PyObject *resultobj;
17661 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17662 bool result;
17663 PyObject * obj0 = 0 ;
17664 char *kwnames[] = {
17665 (char *) "self", NULL
17666 };
17667
17668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17670 if (SWIG_arg_fail(1)) SWIG_fail;
17671 {
17672 PyThreadState* __tstate = wxPyBeginAllowThreads();
17673 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17674
17675 wxPyEndAllowThreads(__tstate);
17676 if (PyErr_Occurred()) SWIG_fail;
17677 }
17678 {
17679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17680 }
17681 return resultobj;
17682 fail:
17683 return NULL;
17684 }
17685
17686
17687 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17688 PyObject *resultobj;
17689 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17690 bool result;
17691 PyObject * obj0 = 0 ;
17692 char *kwnames[] = {
17693 (char *) "self", NULL
17694 };
17695
17696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17698 if (SWIG_arg_fail(1)) SWIG_fail;
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17702
17703 wxPyEndAllowThreads(__tstate);
17704 if (PyErr_Occurred()) SWIG_fail;
17705 }
17706 {
17707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17708 }
17709 return resultobj;
17710 fail:
17711 return NULL;
17712 }
17713
17714
17715 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17716 PyObject *resultobj;
17717 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17718 bool result;
17719 PyObject * obj0 = 0 ;
17720 char *kwnames[] = {
17721 (char *) "self", NULL
17722 };
17723
17724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17726 if (SWIG_arg_fail(1)) SWIG_fail;
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17730
17731 wxPyEndAllowThreads(__tstate);
17732 if (PyErr_Occurred()) SWIG_fail;
17733 }
17734 {
17735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17736 }
17737 return resultobj;
17738 fail:
17739 return NULL;
17740 }
17741
17742
17743 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17744 PyObject *resultobj;
17745 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17746 bool result;
17747 PyObject * obj0 = 0 ;
17748 char *kwnames[] = {
17749 (char *) "self", NULL
17750 };
17751
17752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17754 if (SWIG_arg_fail(1)) SWIG_fail;
17755 {
17756 PyThreadState* __tstate = wxPyBeginAllowThreads();
17757 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17758
17759 wxPyEndAllowThreads(__tstate);
17760 if (PyErr_Occurred()) SWIG_fail;
17761 }
17762 {
17763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17764 }
17765 return resultobj;
17766 fail:
17767 return NULL;
17768 }
17769
17770
17771 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17772 PyObject *resultobj;
17773 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17774 bool result;
17775 PyObject * obj0 = 0 ;
17776 char *kwnames[] = {
17777 (char *) "self", NULL
17778 };
17779
17780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17782 if (SWIG_arg_fail(1)) SWIG_fail;
17783 {
17784 PyThreadState* __tstate = wxPyBeginAllowThreads();
17785 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17786
17787 wxPyEndAllowThreads(__tstate);
17788 if (PyErr_Occurred()) SWIG_fail;
17789 }
17790 {
17791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17792 }
17793 return resultobj;
17794 fail:
17795 return NULL;
17796 }
17797
17798
17799 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17800 PyObject *resultobj;
17801 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17802 bool result;
17803 PyObject * obj0 = 0 ;
17804 char *kwnames[] = {
17805 (char *) "self", NULL
17806 };
17807
17808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17810 if (SWIG_arg_fail(1)) SWIG_fail;
17811 {
17812 PyThreadState* __tstate = wxPyBeginAllowThreads();
17813 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
17814
17815 wxPyEndAllowThreads(__tstate);
17816 if (PyErr_Occurred()) SWIG_fail;
17817 }
17818 {
17819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17820 }
17821 return resultobj;
17822 fail:
17823 return NULL;
17824 }
17825
17826
17827 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17828 PyObject *resultobj;
17829 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17830 int result;
17831 PyObject * obj0 = 0 ;
17832 char *kwnames[] = {
17833 (char *) "self", NULL
17834 };
17835
17836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
17837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17838 if (SWIG_arg_fail(1)) SWIG_fail;
17839 {
17840 PyThreadState* __tstate = wxPyBeginAllowThreads();
17841 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
17842
17843 wxPyEndAllowThreads(__tstate);
17844 if (PyErr_Occurred()) SWIG_fail;
17845 }
17846 {
17847 resultobj = SWIG_From_int((int)(result));
17848 }
17849 return resultobj;
17850 fail:
17851 return NULL;
17852 }
17853
17854
17855 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
17856 PyObject *resultobj;
17857 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17858 int result;
17859 PyObject * obj0 = 0 ;
17860 char *kwnames[] = {
17861 (char *) "self", NULL
17862 };
17863
17864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
17865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17866 if (SWIG_arg_fail(1)) SWIG_fail;
17867 {
17868 PyThreadState* __tstate = wxPyBeginAllowThreads();
17869 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
17870
17871 wxPyEndAllowThreads(__tstate);
17872 if (PyErr_Occurred()) SWIG_fail;
17873 }
17874 {
17875 resultobj = SWIG_From_int((int)(result));
17876 }
17877 return resultobj;
17878 fail:
17879 return NULL;
17880 }
17881
17882
17883 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17884 PyObject *resultobj;
17885 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17886 unsigned int result;
17887 PyObject * obj0 = 0 ;
17888 char *kwnames[] = {
17889 (char *) "self", NULL
17890 };
17891
17892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
17893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17894 if (SWIG_arg_fail(1)) SWIG_fail;
17895 {
17896 PyThreadState* __tstate = wxPyBeginAllowThreads();
17897 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
17898
17899 wxPyEndAllowThreads(__tstate);
17900 if (PyErr_Occurred()) SWIG_fail;
17901 }
17902 {
17903 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17904 }
17905 return resultobj;
17906 fail:
17907 return NULL;
17908 }
17909
17910
17911 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
17912 PyObject *resultobj;
17913 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17914 unsigned int result;
17915 PyObject * obj0 = 0 ;
17916 char *kwnames[] = {
17917 (char *) "self", NULL
17918 };
17919
17920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
17921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17922 if (SWIG_arg_fail(1)) SWIG_fail;
17923 {
17924 PyThreadState* __tstate = wxPyBeginAllowThreads();
17925 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
17926
17927 wxPyEndAllowThreads(__tstate);
17928 if (PyErr_Occurred()) SWIG_fail;
17929 }
17930 {
17931 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17932 }
17933 return resultobj;
17934 fail:
17935 return NULL;
17936 }
17937
17938
17939 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17940 PyObject *resultobj;
17941 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17942 wxPoint result;
17943 PyObject * obj0 = 0 ;
17944 char *kwnames[] = {
17945 (char *) "self", NULL
17946 };
17947
17948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
17949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17950 if (SWIG_arg_fail(1)) SWIG_fail;
17951 {
17952 PyThreadState* __tstate = wxPyBeginAllowThreads();
17953 result = (arg1)->GetPosition();
17954
17955 wxPyEndAllowThreads(__tstate);
17956 if (PyErr_Occurred()) SWIG_fail;
17957 }
17958 {
17959 wxPoint * resultptr;
17960 resultptr = new wxPoint((wxPoint &)(result));
17961 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17962 }
17963 return resultobj;
17964 fail:
17965 return NULL;
17966 }
17967
17968
17969 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17970 PyObject *resultobj;
17971 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17972 long *arg2 = (long *) 0 ;
17973 long *arg3 = (long *) 0 ;
17974 long temp2 ;
17975 int res2 = 0 ;
17976 long temp3 ;
17977 int res3 = 0 ;
17978 PyObject * obj0 = 0 ;
17979 char *kwnames[] = {
17980 (char *) "self", NULL
17981 };
17982
17983 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17984 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17987 if (SWIG_arg_fail(1)) SWIG_fail;
17988 {
17989 PyThreadState* __tstate = wxPyBeginAllowThreads();
17990 (arg1)->GetPosition(arg2,arg3);
17991
17992 wxPyEndAllowThreads(__tstate);
17993 if (PyErr_Occurred()) SWIG_fail;
17994 }
17995 Py_INCREF(Py_None); resultobj = Py_None;
17996 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17997 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17998 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17999 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18007 PyObject *resultobj;
18008 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18009 int result;
18010 PyObject * obj0 = 0 ;
18011 char *kwnames[] = {
18012 (char *) "self", NULL
18013 };
18014
18015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18017 if (SWIG_arg_fail(1)) SWIG_fail;
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 result = (int)((wxKeyEvent const *)arg1)->GetX();
18021
18022 wxPyEndAllowThreads(__tstate);
18023 if (PyErr_Occurred()) SWIG_fail;
18024 }
18025 {
18026 resultobj = SWIG_From_int((int)(result));
18027 }
18028 return resultobj;
18029 fail:
18030 return NULL;
18031 }
18032
18033
18034 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18035 PyObject *resultobj;
18036 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18037 int result;
18038 PyObject * obj0 = 0 ;
18039 char *kwnames[] = {
18040 (char *) "self", NULL
18041 };
18042
18043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18045 if (SWIG_arg_fail(1)) SWIG_fail;
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 result = (int)((wxKeyEvent const *)arg1)->GetY();
18049
18050 wxPyEndAllowThreads(__tstate);
18051 if (PyErr_Occurred()) SWIG_fail;
18052 }
18053 {
18054 resultobj = SWIG_From_int((int)(result));
18055 }
18056 return resultobj;
18057 fail:
18058 return NULL;
18059 }
18060
18061
18062 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18063 PyObject *resultobj;
18064 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18065 int arg2 ;
18066 PyObject * obj0 = 0 ;
18067 PyObject * obj1 = 0 ;
18068 char *kwnames[] = {
18069 (char *) "self",(char *) "m_x", NULL
18070 };
18071
18072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18074 if (SWIG_arg_fail(1)) SWIG_fail;
18075 {
18076 arg2 = (int)(SWIG_As_int(obj1));
18077 if (SWIG_arg_fail(2)) SWIG_fail;
18078 }
18079 if (arg1) (arg1)->m_x = arg2;
18080
18081 Py_INCREF(Py_None); resultobj = Py_None;
18082 return resultobj;
18083 fail:
18084 return NULL;
18085 }
18086
18087
18088 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18089 PyObject *resultobj;
18090 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18091 int result;
18092 PyObject * obj0 = 0 ;
18093 char *kwnames[] = {
18094 (char *) "self", NULL
18095 };
18096
18097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18099 if (SWIG_arg_fail(1)) SWIG_fail;
18100 result = (int) ((arg1)->m_x);
18101
18102 {
18103 resultobj = SWIG_From_int((int)(result));
18104 }
18105 return resultobj;
18106 fail:
18107 return NULL;
18108 }
18109
18110
18111 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18112 PyObject *resultobj;
18113 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18114 int arg2 ;
18115 PyObject * obj0 = 0 ;
18116 PyObject * obj1 = 0 ;
18117 char *kwnames[] = {
18118 (char *) "self",(char *) "m_y", NULL
18119 };
18120
18121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18123 if (SWIG_arg_fail(1)) SWIG_fail;
18124 {
18125 arg2 = (int)(SWIG_As_int(obj1));
18126 if (SWIG_arg_fail(2)) SWIG_fail;
18127 }
18128 if (arg1) (arg1)->m_y = arg2;
18129
18130 Py_INCREF(Py_None); resultobj = Py_None;
18131 return resultobj;
18132 fail:
18133 return NULL;
18134 }
18135
18136
18137 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18138 PyObject *resultobj;
18139 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18140 int result;
18141 PyObject * obj0 = 0 ;
18142 char *kwnames[] = {
18143 (char *) "self", NULL
18144 };
18145
18146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18148 if (SWIG_arg_fail(1)) SWIG_fail;
18149 result = (int) ((arg1)->m_y);
18150
18151 {
18152 resultobj = SWIG_From_int((int)(result));
18153 }
18154 return resultobj;
18155 fail:
18156 return NULL;
18157 }
18158
18159
18160 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18161 PyObject *resultobj;
18162 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18163 long arg2 ;
18164 PyObject * obj0 = 0 ;
18165 PyObject * obj1 = 0 ;
18166 char *kwnames[] = {
18167 (char *) "self",(char *) "m_keyCode", NULL
18168 };
18169
18170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18172 if (SWIG_arg_fail(1)) SWIG_fail;
18173 {
18174 arg2 = (long)(SWIG_As_long(obj1));
18175 if (SWIG_arg_fail(2)) SWIG_fail;
18176 }
18177 if (arg1) (arg1)->m_keyCode = arg2;
18178
18179 Py_INCREF(Py_None); resultobj = Py_None;
18180 return resultobj;
18181 fail:
18182 return NULL;
18183 }
18184
18185
18186 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18187 PyObject *resultobj;
18188 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18189 long result;
18190 PyObject * obj0 = 0 ;
18191 char *kwnames[] = {
18192 (char *) "self", NULL
18193 };
18194
18195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18197 if (SWIG_arg_fail(1)) SWIG_fail;
18198 result = (long) ((arg1)->m_keyCode);
18199
18200 {
18201 resultobj = SWIG_From_long((long)(result));
18202 }
18203 return resultobj;
18204 fail:
18205 return NULL;
18206 }
18207
18208
18209 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18210 PyObject *resultobj;
18211 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18212 bool arg2 ;
18213 PyObject * obj0 = 0 ;
18214 PyObject * obj1 = 0 ;
18215 char *kwnames[] = {
18216 (char *) "self",(char *) "m_controlDown", NULL
18217 };
18218
18219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18221 if (SWIG_arg_fail(1)) SWIG_fail;
18222 {
18223 arg2 = (bool)(SWIG_As_bool(obj1));
18224 if (SWIG_arg_fail(2)) SWIG_fail;
18225 }
18226 if (arg1) (arg1)->m_controlDown = arg2;
18227
18228 Py_INCREF(Py_None); resultobj = Py_None;
18229 return resultobj;
18230 fail:
18231 return NULL;
18232 }
18233
18234
18235 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18236 PyObject *resultobj;
18237 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18238 bool result;
18239 PyObject * obj0 = 0 ;
18240 char *kwnames[] = {
18241 (char *) "self", NULL
18242 };
18243
18244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18246 if (SWIG_arg_fail(1)) SWIG_fail;
18247 result = (bool) ((arg1)->m_controlDown);
18248
18249 {
18250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18251 }
18252 return resultobj;
18253 fail:
18254 return NULL;
18255 }
18256
18257
18258 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18259 PyObject *resultobj;
18260 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18261 bool arg2 ;
18262 PyObject * obj0 = 0 ;
18263 PyObject * obj1 = 0 ;
18264 char *kwnames[] = {
18265 (char *) "self",(char *) "m_shiftDown", NULL
18266 };
18267
18268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) 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 arg2 = (bool)(SWIG_As_bool(obj1));
18273 if (SWIG_arg_fail(2)) SWIG_fail;
18274 }
18275 if (arg1) (arg1)->m_shiftDown = arg2;
18276
18277 Py_INCREF(Py_None); resultobj = Py_None;
18278 return resultobj;
18279 fail:
18280 return NULL;
18281 }
18282
18283
18284 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18285 PyObject *resultobj;
18286 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18287 bool result;
18288 PyObject * obj0 = 0 ;
18289 char *kwnames[] = {
18290 (char *) "self", NULL
18291 };
18292
18293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18295 if (SWIG_arg_fail(1)) SWIG_fail;
18296 result = (bool) ((arg1)->m_shiftDown);
18297
18298 {
18299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18300 }
18301 return resultobj;
18302 fail:
18303 return NULL;
18304 }
18305
18306
18307 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18308 PyObject *resultobj;
18309 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18310 bool arg2 ;
18311 PyObject * obj0 = 0 ;
18312 PyObject * obj1 = 0 ;
18313 char *kwnames[] = {
18314 (char *) "self",(char *) "m_altDown", NULL
18315 };
18316
18317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18319 if (SWIG_arg_fail(1)) SWIG_fail;
18320 {
18321 arg2 = (bool)(SWIG_As_bool(obj1));
18322 if (SWIG_arg_fail(2)) SWIG_fail;
18323 }
18324 if (arg1) (arg1)->m_altDown = arg2;
18325
18326 Py_INCREF(Py_None); resultobj = Py_None;
18327 return resultobj;
18328 fail:
18329 return NULL;
18330 }
18331
18332
18333 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18334 PyObject *resultobj;
18335 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18336 bool result;
18337 PyObject * obj0 = 0 ;
18338 char *kwnames[] = {
18339 (char *) "self", NULL
18340 };
18341
18342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18344 if (SWIG_arg_fail(1)) SWIG_fail;
18345 result = (bool) ((arg1)->m_altDown);
18346
18347 {
18348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18349 }
18350 return resultobj;
18351 fail:
18352 return NULL;
18353 }
18354
18355
18356 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18357 PyObject *resultobj;
18358 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18359 bool arg2 ;
18360 PyObject * obj0 = 0 ;
18361 PyObject * obj1 = 0 ;
18362 char *kwnames[] = {
18363 (char *) "self",(char *) "m_metaDown", NULL
18364 };
18365
18366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18368 if (SWIG_arg_fail(1)) SWIG_fail;
18369 {
18370 arg2 = (bool)(SWIG_As_bool(obj1));
18371 if (SWIG_arg_fail(2)) SWIG_fail;
18372 }
18373 if (arg1) (arg1)->m_metaDown = arg2;
18374
18375 Py_INCREF(Py_None); resultobj = Py_None;
18376 return resultobj;
18377 fail:
18378 return NULL;
18379 }
18380
18381
18382 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18383 PyObject *resultobj;
18384 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18385 bool result;
18386 PyObject * obj0 = 0 ;
18387 char *kwnames[] = {
18388 (char *) "self", NULL
18389 };
18390
18391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18393 if (SWIG_arg_fail(1)) SWIG_fail;
18394 result = (bool) ((arg1)->m_metaDown);
18395
18396 {
18397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18398 }
18399 return resultobj;
18400 fail:
18401 return NULL;
18402 }
18403
18404
18405 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18406 PyObject *resultobj;
18407 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18408 bool arg2 ;
18409 PyObject * obj0 = 0 ;
18410 PyObject * obj1 = 0 ;
18411 char *kwnames[] = {
18412 (char *) "self",(char *) "m_scanCode", NULL
18413 };
18414
18415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18417 if (SWIG_arg_fail(1)) SWIG_fail;
18418 {
18419 arg2 = (bool)(SWIG_As_bool(obj1));
18420 if (SWIG_arg_fail(2)) SWIG_fail;
18421 }
18422 if (arg1) (arg1)->m_scanCode = arg2;
18423
18424 Py_INCREF(Py_None); resultobj = Py_None;
18425 return resultobj;
18426 fail:
18427 return NULL;
18428 }
18429
18430
18431 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18432 PyObject *resultobj;
18433 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18434 bool result;
18435 PyObject * obj0 = 0 ;
18436 char *kwnames[] = {
18437 (char *) "self", NULL
18438 };
18439
18440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18442 if (SWIG_arg_fail(1)) SWIG_fail;
18443 result = (bool) ((arg1)->m_scanCode);
18444
18445 {
18446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18447 }
18448 return resultobj;
18449 fail:
18450 return NULL;
18451 }
18452
18453
18454 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18455 PyObject *resultobj;
18456 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18457 unsigned int arg2 ;
18458 PyObject * obj0 = 0 ;
18459 PyObject * obj1 = 0 ;
18460 char *kwnames[] = {
18461 (char *) "self",(char *) "m_rawCode", NULL
18462 };
18463
18464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18466 if (SWIG_arg_fail(1)) SWIG_fail;
18467 {
18468 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18469 if (SWIG_arg_fail(2)) SWIG_fail;
18470 }
18471 if (arg1) (arg1)->m_rawCode = arg2;
18472
18473 Py_INCREF(Py_None); resultobj = Py_None;
18474 return resultobj;
18475 fail:
18476 return NULL;
18477 }
18478
18479
18480 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18481 PyObject *resultobj;
18482 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18483 unsigned int result;
18484 PyObject * obj0 = 0 ;
18485 char *kwnames[] = {
18486 (char *) "self", NULL
18487 };
18488
18489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18491 if (SWIG_arg_fail(1)) SWIG_fail;
18492 result = (unsigned int) ((arg1)->m_rawCode);
18493
18494 {
18495 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18496 }
18497 return resultobj;
18498 fail:
18499 return NULL;
18500 }
18501
18502
18503 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18504 PyObject *resultobj;
18505 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18506 unsigned int arg2 ;
18507 PyObject * obj0 = 0 ;
18508 PyObject * obj1 = 0 ;
18509 char *kwnames[] = {
18510 (char *) "self",(char *) "m_rawFlags", NULL
18511 };
18512
18513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18515 if (SWIG_arg_fail(1)) SWIG_fail;
18516 {
18517 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18518 if (SWIG_arg_fail(2)) SWIG_fail;
18519 }
18520 if (arg1) (arg1)->m_rawFlags = arg2;
18521
18522 Py_INCREF(Py_None); resultobj = Py_None;
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18530 PyObject *resultobj;
18531 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18532 unsigned int result;
18533 PyObject * obj0 = 0 ;
18534 char *kwnames[] = {
18535 (char *) "self", NULL
18536 };
18537
18538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18540 if (SWIG_arg_fail(1)) SWIG_fail;
18541 result = (unsigned int) ((arg1)->m_rawFlags);
18542
18543 {
18544 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18545 }
18546 return resultobj;
18547 fail:
18548 return NULL;
18549 }
18550
18551
18552 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18553 PyObject *obj;
18554 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18555 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18556 Py_INCREF(obj);
18557 return Py_BuildValue((char *)"");
18558 }
18559 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18560 PyObject *resultobj;
18561 wxSize const &arg1_defvalue = wxDefaultSize ;
18562 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18563 int arg2 = (int) 0 ;
18564 wxSizeEvent *result;
18565 wxSize temp1 ;
18566 PyObject * obj0 = 0 ;
18567 PyObject * obj1 = 0 ;
18568 char *kwnames[] = {
18569 (char *) "sz",(char *) "winid", NULL
18570 };
18571
18572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18573 if (obj0) {
18574 {
18575 arg1 = &temp1;
18576 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18577 }
18578 }
18579 if (obj1) {
18580 {
18581 arg2 = (int)(SWIG_As_int(obj1));
18582 if (SWIG_arg_fail(2)) SWIG_fail;
18583 }
18584 }
18585 {
18586 PyThreadState* __tstate = wxPyBeginAllowThreads();
18587 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18588
18589 wxPyEndAllowThreads(__tstate);
18590 if (PyErr_Occurred()) SWIG_fail;
18591 }
18592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18593 return resultobj;
18594 fail:
18595 return NULL;
18596 }
18597
18598
18599 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18600 PyObject *resultobj;
18601 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18602 wxSize result;
18603 PyObject * obj0 = 0 ;
18604 char *kwnames[] = {
18605 (char *) "self", NULL
18606 };
18607
18608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18610 if (SWIG_arg_fail(1)) SWIG_fail;
18611 {
18612 PyThreadState* __tstate = wxPyBeginAllowThreads();
18613 result = ((wxSizeEvent const *)arg1)->GetSize();
18614
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 {
18619 wxSize * resultptr;
18620 resultptr = new wxSize((wxSize &)(result));
18621 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18622 }
18623 return resultobj;
18624 fail:
18625 return NULL;
18626 }
18627
18628
18629 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18630 PyObject *resultobj;
18631 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18632 wxRect result;
18633 PyObject * obj0 = 0 ;
18634 char *kwnames[] = {
18635 (char *) "self", NULL
18636 };
18637
18638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18640 if (SWIG_arg_fail(1)) SWIG_fail;
18641 {
18642 PyThreadState* __tstate = wxPyBeginAllowThreads();
18643 result = ((wxSizeEvent const *)arg1)->GetRect();
18644
18645 wxPyEndAllowThreads(__tstate);
18646 if (PyErr_Occurred()) SWIG_fail;
18647 }
18648 {
18649 wxRect * resultptr;
18650 resultptr = new wxRect((wxRect &)(result));
18651 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18652 }
18653 return resultobj;
18654 fail:
18655 return NULL;
18656 }
18657
18658
18659 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18660 PyObject *resultobj;
18661 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18662 wxRect arg2 ;
18663 PyObject * obj0 = 0 ;
18664 PyObject * obj1 = 0 ;
18665 char *kwnames[] = {
18666 (char *) "self",(char *) "rect", NULL
18667 };
18668
18669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18671 if (SWIG_arg_fail(1)) SWIG_fail;
18672 {
18673 wxRect * argp;
18674 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18675 if (SWIG_arg_fail(2)) SWIG_fail;
18676 if (argp == NULL) {
18677 SWIG_null_ref("wxRect");
18678 }
18679 if (SWIG_arg_fail(2)) SWIG_fail;
18680 arg2 = *argp;
18681 }
18682 {
18683 PyThreadState* __tstate = wxPyBeginAllowThreads();
18684 (arg1)->SetRect(arg2);
18685
18686 wxPyEndAllowThreads(__tstate);
18687 if (PyErr_Occurred()) SWIG_fail;
18688 }
18689 Py_INCREF(Py_None); resultobj = Py_None;
18690 return resultobj;
18691 fail:
18692 return NULL;
18693 }
18694
18695
18696 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18697 PyObject *resultobj;
18698 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18699 wxSize arg2 ;
18700 PyObject * obj0 = 0 ;
18701 PyObject * obj1 = 0 ;
18702 char *kwnames[] = {
18703 (char *) "self",(char *) "size", NULL
18704 };
18705
18706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18708 if (SWIG_arg_fail(1)) SWIG_fail;
18709 {
18710 wxSize * argp;
18711 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18712 if (SWIG_arg_fail(2)) SWIG_fail;
18713 if (argp == NULL) {
18714 SWIG_null_ref("wxSize");
18715 }
18716 if (SWIG_arg_fail(2)) SWIG_fail;
18717 arg2 = *argp;
18718 }
18719 {
18720 PyThreadState* __tstate = wxPyBeginAllowThreads();
18721 wxSizeEvent_SetSize(arg1,arg2);
18722
18723 wxPyEndAllowThreads(__tstate);
18724 if (PyErr_Occurred()) SWIG_fail;
18725 }
18726 Py_INCREF(Py_None); resultobj = Py_None;
18727 return resultobj;
18728 fail:
18729 return NULL;
18730 }
18731
18732
18733 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18734 PyObject *resultobj;
18735 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18736 wxSize *arg2 = (wxSize *) 0 ;
18737 PyObject * obj0 = 0 ;
18738 PyObject * obj1 = 0 ;
18739 char *kwnames[] = {
18740 (char *) "self",(char *) "m_size", NULL
18741 };
18742
18743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18745 if (SWIG_arg_fail(1)) SWIG_fail;
18746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18747 if (SWIG_arg_fail(2)) SWIG_fail;
18748 if (arg1) (arg1)->m_size = *arg2;
18749
18750 Py_INCREF(Py_None); resultobj = Py_None;
18751 return resultobj;
18752 fail:
18753 return NULL;
18754 }
18755
18756
18757 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18758 PyObject *resultobj;
18759 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18760 wxSize *result;
18761 PyObject * obj0 = 0 ;
18762 char *kwnames[] = {
18763 (char *) "self", NULL
18764 };
18765
18766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18768 if (SWIG_arg_fail(1)) SWIG_fail;
18769 result = (wxSize *)& ((arg1)->m_size);
18770
18771 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18772 return resultobj;
18773 fail:
18774 return NULL;
18775 }
18776
18777
18778 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18779 PyObject *resultobj;
18780 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18781 wxRect *arg2 = (wxRect *) 0 ;
18782 PyObject * obj0 = 0 ;
18783 PyObject * obj1 = 0 ;
18784 char *kwnames[] = {
18785 (char *) "self",(char *) "m_rect", NULL
18786 };
18787
18788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18790 if (SWIG_arg_fail(1)) SWIG_fail;
18791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18792 if (SWIG_arg_fail(2)) SWIG_fail;
18793 if (arg1) (arg1)->m_rect = *arg2;
18794
18795 Py_INCREF(Py_None); resultobj = Py_None;
18796 return resultobj;
18797 fail:
18798 return NULL;
18799 }
18800
18801
18802 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18803 PyObject *resultobj;
18804 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18805 wxRect *result;
18806 PyObject * obj0 = 0 ;
18807 char *kwnames[] = {
18808 (char *) "self", NULL
18809 };
18810
18811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
18812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18813 if (SWIG_arg_fail(1)) SWIG_fail;
18814 result = (wxRect *)& ((arg1)->m_rect);
18815
18816 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
18817 return resultobj;
18818 fail:
18819 return NULL;
18820 }
18821
18822
18823 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
18824 PyObject *obj;
18825 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18826 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
18827 Py_INCREF(obj);
18828 return Py_BuildValue((char *)"");
18829 }
18830 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18831 PyObject *resultobj;
18832 wxPoint const &arg1_defvalue = wxDefaultPosition ;
18833 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
18834 int arg2 = (int) 0 ;
18835 wxMoveEvent *result;
18836 wxPoint temp1 ;
18837 PyObject * obj0 = 0 ;
18838 PyObject * obj1 = 0 ;
18839 char *kwnames[] = {
18840 (char *) "pos",(char *) "winid", NULL
18841 };
18842
18843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
18844 if (obj0) {
18845 {
18846 arg1 = &temp1;
18847 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
18848 }
18849 }
18850 if (obj1) {
18851 {
18852 arg2 = (int)(SWIG_As_int(obj1));
18853 if (SWIG_arg_fail(2)) SWIG_fail;
18854 }
18855 }
18856 {
18857 PyThreadState* __tstate = wxPyBeginAllowThreads();
18858 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
18859
18860 wxPyEndAllowThreads(__tstate);
18861 if (PyErr_Occurred()) SWIG_fail;
18862 }
18863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
18864 return resultobj;
18865 fail:
18866 return NULL;
18867 }
18868
18869
18870 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18871 PyObject *resultobj;
18872 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18873 wxPoint result;
18874 PyObject * obj0 = 0 ;
18875 char *kwnames[] = {
18876 (char *) "self", NULL
18877 };
18878
18879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
18880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18881 if (SWIG_arg_fail(1)) SWIG_fail;
18882 {
18883 PyThreadState* __tstate = wxPyBeginAllowThreads();
18884 result = ((wxMoveEvent const *)arg1)->GetPosition();
18885
18886 wxPyEndAllowThreads(__tstate);
18887 if (PyErr_Occurred()) SWIG_fail;
18888 }
18889 {
18890 wxPoint * resultptr;
18891 resultptr = new wxPoint((wxPoint &)(result));
18892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18893 }
18894 return resultobj;
18895 fail:
18896 return NULL;
18897 }
18898
18899
18900 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18901 PyObject *resultobj;
18902 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18903 wxRect result;
18904 PyObject * obj0 = 0 ;
18905 char *kwnames[] = {
18906 (char *) "self", NULL
18907 };
18908
18909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
18910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18911 if (SWIG_arg_fail(1)) SWIG_fail;
18912 {
18913 PyThreadState* __tstate = wxPyBeginAllowThreads();
18914 result = ((wxMoveEvent const *)arg1)->GetRect();
18915
18916 wxPyEndAllowThreads(__tstate);
18917 if (PyErr_Occurred()) SWIG_fail;
18918 }
18919 {
18920 wxRect * resultptr;
18921 resultptr = new wxRect((wxRect &)(result));
18922 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18923 }
18924 return resultobj;
18925 fail:
18926 return NULL;
18927 }
18928
18929
18930 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18931 PyObject *resultobj;
18932 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18933 wxRect arg2 ;
18934 PyObject * obj0 = 0 ;
18935 PyObject * obj1 = 0 ;
18936 char *kwnames[] = {
18937 (char *) "self",(char *) "rect", NULL
18938 };
18939
18940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18942 if (SWIG_arg_fail(1)) SWIG_fail;
18943 {
18944 wxRect * argp;
18945 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18946 if (SWIG_arg_fail(2)) SWIG_fail;
18947 if (argp == NULL) {
18948 SWIG_null_ref("wxRect");
18949 }
18950 if (SWIG_arg_fail(2)) SWIG_fail;
18951 arg2 = *argp;
18952 }
18953 {
18954 PyThreadState* __tstate = wxPyBeginAllowThreads();
18955 (arg1)->SetRect(arg2);
18956
18957 wxPyEndAllowThreads(__tstate);
18958 if (PyErr_Occurred()) SWIG_fail;
18959 }
18960 Py_INCREF(Py_None); resultobj = Py_None;
18961 return resultobj;
18962 fail:
18963 return NULL;
18964 }
18965
18966
18967 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18968 PyObject *resultobj;
18969 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18970 wxPoint arg2 ;
18971 PyObject * obj0 = 0 ;
18972 PyObject * obj1 = 0 ;
18973 char *kwnames[] = {
18974 (char *) "self",(char *) "pos", NULL
18975 };
18976
18977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
18978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18979 if (SWIG_arg_fail(1)) SWIG_fail;
18980 {
18981 wxPoint * argp;
18982 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
18983 if (SWIG_arg_fail(2)) SWIG_fail;
18984 if (argp == NULL) {
18985 SWIG_null_ref("wxPoint");
18986 }
18987 if (SWIG_arg_fail(2)) SWIG_fail;
18988 arg2 = *argp;
18989 }
18990 {
18991 PyThreadState* __tstate = wxPyBeginAllowThreads();
18992 wxMoveEvent_SetPosition(arg1,arg2);
18993
18994 wxPyEndAllowThreads(__tstate);
18995 if (PyErr_Occurred()) SWIG_fail;
18996 }
18997 Py_INCREF(Py_None); resultobj = Py_None;
18998 return resultobj;
18999 fail:
19000 return NULL;
19001 }
19002
19003
19004 static PyObject *_wrap_MoveEvent_m_pos_set(PyObject *, PyObject *args, PyObject *kwargs) {
19005 PyObject *resultobj;
19006 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19007 wxPoint *arg2 = (wxPoint *) 0 ;
19008 PyObject * obj0 = 0 ;
19009 PyObject * obj1 = 0 ;
19010 char *kwnames[] = {
19011 (char *) "self",(char *) "m_pos", NULL
19012 };
19013
19014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_m_pos_set",kwnames,&obj0,&obj1)) goto fail;
19015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19016 if (SWIG_arg_fail(1)) SWIG_fail;
19017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
19018 if (SWIG_arg_fail(2)) SWIG_fail;
19019 if (arg1) (arg1)->m_pos = *arg2;
19020
19021 Py_INCREF(Py_None); resultobj = Py_None;
19022 return resultobj;
19023 fail:
19024 return NULL;
19025 }
19026
19027
19028 static PyObject *_wrap_MoveEvent_m_pos_get(PyObject *, PyObject *args, PyObject *kwargs) {
19029 PyObject *resultobj;
19030 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19031 wxPoint *result;
19032 PyObject * obj0 = 0 ;
19033 char *kwnames[] = {
19034 (char *) "self", NULL
19035 };
19036
19037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_m_pos_get",kwnames,&obj0)) goto fail;
19038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19039 if (SWIG_arg_fail(1)) SWIG_fail;
19040 result = (wxPoint *)& ((arg1)->m_pos);
19041
19042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
19043 return resultobj;
19044 fail:
19045 return NULL;
19046 }
19047
19048
19049 static PyObject *_wrap_MoveEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19050 PyObject *resultobj;
19051 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19052 wxRect *arg2 = (wxRect *) 0 ;
19053 PyObject * obj0 = 0 ;
19054 PyObject * obj1 = 0 ;
19055 char *kwnames[] = {
19056 (char *) "self",(char *) "m_rect", NULL
19057 };
19058
19059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19061 if (SWIG_arg_fail(1)) SWIG_fail;
19062 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19063 if (SWIG_arg_fail(2)) SWIG_fail;
19064 if (arg1) (arg1)->m_rect = *arg2;
19065
19066 Py_INCREF(Py_None); resultobj = Py_None;
19067 return resultobj;
19068 fail:
19069 return NULL;
19070 }
19071
19072
19073 static PyObject *_wrap_MoveEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19074 PyObject *resultobj;
19075 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19076 wxRect *result;
19077 PyObject * obj0 = 0 ;
19078 char *kwnames[] = {
19079 (char *) "self", NULL
19080 };
19081
19082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_m_rect_get",kwnames,&obj0)) goto fail;
19083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19084 if (SWIG_arg_fail(1)) SWIG_fail;
19085 result = (wxRect *)& ((arg1)->m_rect);
19086
19087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19088 return resultobj;
19089 fail:
19090 return NULL;
19091 }
19092
19093
19094 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19095 PyObject *obj;
19096 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19097 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19098 Py_INCREF(obj);
19099 return Py_BuildValue((char *)"");
19100 }
19101 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19102 PyObject *resultobj;
19103 int arg1 = (int) 0 ;
19104 wxPaintEvent *result;
19105 PyObject * obj0 = 0 ;
19106 char *kwnames[] = {
19107 (char *) "Id", NULL
19108 };
19109
19110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19111 if (obj0) {
19112 {
19113 arg1 = (int)(SWIG_As_int(obj0));
19114 if (SWIG_arg_fail(1)) SWIG_fail;
19115 }
19116 }
19117 {
19118 PyThreadState* __tstate = wxPyBeginAllowThreads();
19119 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19120
19121 wxPyEndAllowThreads(__tstate);
19122 if (PyErr_Occurred()) SWIG_fail;
19123 }
19124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19125 return resultobj;
19126 fail:
19127 return NULL;
19128 }
19129
19130
19131 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19132 PyObject *obj;
19133 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19134 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19135 Py_INCREF(obj);
19136 return Py_BuildValue((char *)"");
19137 }
19138 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19139 PyObject *resultobj;
19140 int arg1 = (int) 0 ;
19141 wxNcPaintEvent *result;
19142 PyObject * obj0 = 0 ;
19143 char *kwnames[] = {
19144 (char *) "winid", NULL
19145 };
19146
19147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19148 if (obj0) {
19149 {
19150 arg1 = (int)(SWIG_As_int(obj0));
19151 if (SWIG_arg_fail(1)) SWIG_fail;
19152 }
19153 }
19154 {
19155 PyThreadState* __tstate = wxPyBeginAllowThreads();
19156 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19157
19158 wxPyEndAllowThreads(__tstate);
19159 if (PyErr_Occurred()) SWIG_fail;
19160 }
19161 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19162 return resultobj;
19163 fail:
19164 return NULL;
19165 }
19166
19167
19168 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19169 PyObject *obj;
19170 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19171 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19172 Py_INCREF(obj);
19173 return Py_BuildValue((char *)"");
19174 }
19175 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19176 PyObject *resultobj;
19177 int arg1 = (int) 0 ;
19178 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19179 wxEraseEvent *result;
19180 PyObject * obj0 = 0 ;
19181 PyObject * obj1 = 0 ;
19182 char *kwnames[] = {
19183 (char *) "Id",(char *) "dc", NULL
19184 };
19185
19186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19187 if (obj0) {
19188 {
19189 arg1 = (int)(SWIG_As_int(obj0));
19190 if (SWIG_arg_fail(1)) SWIG_fail;
19191 }
19192 }
19193 if (obj1) {
19194 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19195 if (SWIG_arg_fail(2)) SWIG_fail;
19196 }
19197 {
19198 PyThreadState* __tstate = wxPyBeginAllowThreads();
19199 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19200
19201 wxPyEndAllowThreads(__tstate);
19202 if (PyErr_Occurred()) SWIG_fail;
19203 }
19204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19205 return resultobj;
19206 fail:
19207 return NULL;
19208 }
19209
19210
19211 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj;
19213 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19214 wxDC *result;
19215 PyObject * obj0 = 0 ;
19216 char *kwnames[] = {
19217 (char *) "self", NULL
19218 };
19219
19220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19222 if (SWIG_arg_fail(1)) SWIG_fail;
19223 {
19224 PyThreadState* __tstate = wxPyBeginAllowThreads();
19225 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19226
19227 wxPyEndAllowThreads(__tstate);
19228 if (PyErr_Occurred()) SWIG_fail;
19229 }
19230 {
19231 resultobj = wxPyMake_wxObject(result, 0);
19232 }
19233 return resultobj;
19234 fail:
19235 return NULL;
19236 }
19237
19238
19239 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19240 PyObject *obj;
19241 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19242 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19243 Py_INCREF(obj);
19244 return Py_BuildValue((char *)"");
19245 }
19246 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19247 PyObject *resultobj;
19248 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19249 int arg2 = (int) 0 ;
19250 wxFocusEvent *result;
19251 PyObject * obj0 = 0 ;
19252 PyObject * obj1 = 0 ;
19253 char *kwnames[] = {
19254 (char *) "type",(char *) "winid", NULL
19255 };
19256
19257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19258 if (obj0) {
19259 {
19260 arg1 = (wxEventType)(SWIG_As_int(obj0));
19261 if (SWIG_arg_fail(1)) SWIG_fail;
19262 }
19263 }
19264 if (obj1) {
19265 {
19266 arg2 = (int)(SWIG_As_int(obj1));
19267 if (SWIG_arg_fail(2)) SWIG_fail;
19268 }
19269 }
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19273
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19278 return resultobj;
19279 fail:
19280 return NULL;
19281 }
19282
19283
19284 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19285 PyObject *resultobj;
19286 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19287 wxWindow *result;
19288 PyObject * obj0 = 0 ;
19289 char *kwnames[] = {
19290 (char *) "self", NULL
19291 };
19292
19293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19295 if (SWIG_arg_fail(1)) SWIG_fail;
19296 {
19297 PyThreadState* __tstate = wxPyBeginAllowThreads();
19298 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19299
19300 wxPyEndAllowThreads(__tstate);
19301 if (PyErr_Occurred()) SWIG_fail;
19302 }
19303 {
19304 resultobj = wxPyMake_wxObject(result, 0);
19305 }
19306 return resultobj;
19307 fail:
19308 return NULL;
19309 }
19310
19311
19312 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19313 PyObject *resultobj;
19314 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19315 wxWindow *arg2 = (wxWindow *) 0 ;
19316 PyObject * obj0 = 0 ;
19317 PyObject * obj1 = 0 ;
19318 char *kwnames[] = {
19319 (char *) "self",(char *) "win", NULL
19320 };
19321
19322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19324 if (SWIG_arg_fail(1)) SWIG_fail;
19325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19326 if (SWIG_arg_fail(2)) SWIG_fail;
19327 {
19328 PyThreadState* __tstate = wxPyBeginAllowThreads();
19329 (arg1)->SetWindow(arg2);
19330
19331 wxPyEndAllowThreads(__tstate);
19332 if (PyErr_Occurred()) SWIG_fail;
19333 }
19334 Py_INCREF(Py_None); resultobj = Py_None;
19335 return resultobj;
19336 fail:
19337 return NULL;
19338 }
19339
19340
19341 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19342 PyObject *obj;
19343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19344 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19345 Py_INCREF(obj);
19346 return Py_BuildValue((char *)"");
19347 }
19348 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19349 PyObject *resultobj;
19350 wxWindow *arg1 = (wxWindow *) NULL ;
19351 wxChildFocusEvent *result;
19352 PyObject * obj0 = 0 ;
19353 char *kwnames[] = {
19354 (char *) "win", NULL
19355 };
19356
19357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19358 if (obj0) {
19359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19360 if (SWIG_arg_fail(1)) SWIG_fail;
19361 }
19362 {
19363 PyThreadState* __tstate = wxPyBeginAllowThreads();
19364 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19365
19366 wxPyEndAllowThreads(__tstate);
19367 if (PyErr_Occurred()) SWIG_fail;
19368 }
19369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19370 return resultobj;
19371 fail:
19372 return NULL;
19373 }
19374
19375
19376 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19377 PyObject *resultobj;
19378 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19379 wxWindow *result;
19380 PyObject * obj0 = 0 ;
19381 char *kwnames[] = {
19382 (char *) "self", NULL
19383 };
19384
19385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19387 if (SWIG_arg_fail(1)) SWIG_fail;
19388 {
19389 PyThreadState* __tstate = wxPyBeginAllowThreads();
19390 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19391
19392 wxPyEndAllowThreads(__tstate);
19393 if (PyErr_Occurred()) SWIG_fail;
19394 }
19395 {
19396 resultobj = wxPyMake_wxObject(result, 0);
19397 }
19398 return resultobj;
19399 fail:
19400 return NULL;
19401 }
19402
19403
19404 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19405 PyObject *obj;
19406 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19407 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19408 Py_INCREF(obj);
19409 return Py_BuildValue((char *)"");
19410 }
19411 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19412 PyObject *resultobj;
19413 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19414 bool arg2 = (bool) true ;
19415 int arg3 = (int) 0 ;
19416 wxActivateEvent *result;
19417 PyObject * obj0 = 0 ;
19418 PyObject * obj1 = 0 ;
19419 PyObject * obj2 = 0 ;
19420 char *kwnames[] = {
19421 (char *) "type",(char *) "active",(char *) "Id", NULL
19422 };
19423
19424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19425 if (obj0) {
19426 {
19427 arg1 = (wxEventType)(SWIG_As_int(obj0));
19428 if (SWIG_arg_fail(1)) SWIG_fail;
19429 }
19430 }
19431 if (obj1) {
19432 {
19433 arg2 = (bool)(SWIG_As_bool(obj1));
19434 if (SWIG_arg_fail(2)) SWIG_fail;
19435 }
19436 }
19437 if (obj2) {
19438 {
19439 arg3 = (int)(SWIG_As_int(obj2));
19440 if (SWIG_arg_fail(3)) SWIG_fail;
19441 }
19442 }
19443 {
19444 PyThreadState* __tstate = wxPyBeginAllowThreads();
19445 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19446
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19458 PyObject *resultobj;
19459 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19460 bool result;
19461 PyObject * obj0 = 0 ;
19462 char *kwnames[] = {
19463 (char *) "self", NULL
19464 };
19465
19466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19468 if (SWIG_arg_fail(1)) SWIG_fail;
19469 {
19470 PyThreadState* __tstate = wxPyBeginAllowThreads();
19471 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19472
19473 wxPyEndAllowThreads(__tstate);
19474 if (PyErr_Occurred()) SWIG_fail;
19475 }
19476 {
19477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19478 }
19479 return resultobj;
19480 fail:
19481 return NULL;
19482 }
19483
19484
19485 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19486 PyObject *obj;
19487 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19488 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19489 Py_INCREF(obj);
19490 return Py_BuildValue((char *)"");
19491 }
19492 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19493 PyObject *resultobj;
19494 int arg1 = (int) 0 ;
19495 wxInitDialogEvent *result;
19496 PyObject * obj0 = 0 ;
19497 char *kwnames[] = {
19498 (char *) "Id", NULL
19499 };
19500
19501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19502 if (obj0) {
19503 {
19504 arg1 = (int)(SWIG_As_int(obj0));
19505 if (SWIG_arg_fail(1)) SWIG_fail;
19506 }
19507 }
19508 {
19509 PyThreadState* __tstate = wxPyBeginAllowThreads();
19510 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19511
19512 wxPyEndAllowThreads(__tstate);
19513 if (PyErr_Occurred()) SWIG_fail;
19514 }
19515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19516 return resultobj;
19517 fail:
19518 return NULL;
19519 }
19520
19521
19522 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19523 PyObject *obj;
19524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19525 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19526 Py_INCREF(obj);
19527 return Py_BuildValue((char *)"");
19528 }
19529 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19530 PyObject *resultobj;
19531 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19532 int arg2 = (int) 0 ;
19533 wxMenu *arg3 = (wxMenu *) NULL ;
19534 wxMenuEvent *result;
19535 PyObject * obj0 = 0 ;
19536 PyObject * obj1 = 0 ;
19537 PyObject * obj2 = 0 ;
19538 char *kwnames[] = {
19539 (char *) "type",(char *) "winid",(char *) "menu", NULL
19540 };
19541
19542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19543 if (obj0) {
19544 {
19545 arg1 = (wxEventType)(SWIG_As_int(obj0));
19546 if (SWIG_arg_fail(1)) SWIG_fail;
19547 }
19548 }
19549 if (obj1) {
19550 {
19551 arg2 = (int)(SWIG_As_int(obj1));
19552 if (SWIG_arg_fail(2)) SWIG_fail;
19553 }
19554 }
19555 if (obj2) {
19556 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19557 if (SWIG_arg_fail(3)) SWIG_fail;
19558 }
19559 {
19560 PyThreadState* __tstate = wxPyBeginAllowThreads();
19561 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19562
19563 wxPyEndAllowThreads(__tstate);
19564 if (PyErr_Occurred()) SWIG_fail;
19565 }
19566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19567 return resultobj;
19568 fail:
19569 return NULL;
19570 }
19571
19572
19573 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19574 PyObject *resultobj;
19575 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19576 int result;
19577 PyObject * obj0 = 0 ;
19578 char *kwnames[] = {
19579 (char *) "self", NULL
19580 };
19581
19582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19584 if (SWIG_arg_fail(1)) SWIG_fail;
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19588
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 {
19593 resultobj = SWIG_From_int((int)(result));
19594 }
19595 return resultobj;
19596 fail:
19597 return NULL;
19598 }
19599
19600
19601 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19602 PyObject *resultobj;
19603 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19604 bool result;
19605 PyObject * obj0 = 0 ;
19606 char *kwnames[] = {
19607 (char *) "self", NULL
19608 };
19609
19610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19612 if (SWIG_arg_fail(1)) SWIG_fail;
19613 {
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19616
19617 wxPyEndAllowThreads(__tstate);
19618 if (PyErr_Occurred()) SWIG_fail;
19619 }
19620 {
19621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19622 }
19623 return resultobj;
19624 fail:
19625 return NULL;
19626 }
19627
19628
19629 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19630 PyObject *resultobj;
19631 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19632 wxMenu *result;
19633 PyObject * obj0 = 0 ;
19634 char *kwnames[] = {
19635 (char *) "self", NULL
19636 };
19637
19638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19640 if (SWIG_arg_fail(1)) SWIG_fail;
19641 {
19642 PyThreadState* __tstate = wxPyBeginAllowThreads();
19643 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19644
19645 wxPyEndAllowThreads(__tstate);
19646 if (PyErr_Occurred()) SWIG_fail;
19647 }
19648 {
19649 resultobj = wxPyMake_wxObject(result, 0);
19650 }
19651 return resultobj;
19652 fail:
19653 return NULL;
19654 }
19655
19656
19657 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19658 PyObject *obj;
19659 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19660 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19661 Py_INCREF(obj);
19662 return Py_BuildValue((char *)"");
19663 }
19664 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19665 PyObject *resultobj;
19666 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19667 int arg2 = (int) 0 ;
19668 wxCloseEvent *result;
19669 PyObject * obj0 = 0 ;
19670 PyObject * obj1 = 0 ;
19671 char *kwnames[] = {
19672 (char *) "type",(char *) "winid", NULL
19673 };
19674
19675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19676 if (obj0) {
19677 {
19678 arg1 = (wxEventType)(SWIG_As_int(obj0));
19679 if (SWIG_arg_fail(1)) SWIG_fail;
19680 }
19681 }
19682 if (obj1) {
19683 {
19684 arg2 = (int)(SWIG_As_int(obj1));
19685 if (SWIG_arg_fail(2)) SWIG_fail;
19686 }
19687 }
19688 {
19689 PyThreadState* __tstate = wxPyBeginAllowThreads();
19690 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19691
19692 wxPyEndAllowThreads(__tstate);
19693 if (PyErr_Occurred()) SWIG_fail;
19694 }
19695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19696 return resultobj;
19697 fail:
19698 return NULL;
19699 }
19700
19701
19702 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19703 PyObject *resultobj;
19704 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19705 bool arg2 ;
19706 PyObject * obj0 = 0 ;
19707 PyObject * obj1 = 0 ;
19708 char *kwnames[] = {
19709 (char *) "self",(char *) "logOff", NULL
19710 };
19711
19712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19714 if (SWIG_arg_fail(1)) SWIG_fail;
19715 {
19716 arg2 = (bool)(SWIG_As_bool(obj1));
19717 if (SWIG_arg_fail(2)) SWIG_fail;
19718 }
19719 {
19720 PyThreadState* __tstate = wxPyBeginAllowThreads();
19721 (arg1)->SetLoggingOff(arg2);
19722
19723 wxPyEndAllowThreads(__tstate);
19724 if (PyErr_Occurred()) SWIG_fail;
19725 }
19726 Py_INCREF(Py_None); resultobj = Py_None;
19727 return resultobj;
19728 fail:
19729 return NULL;
19730 }
19731
19732
19733 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19734 PyObject *resultobj;
19735 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19736 bool result;
19737 PyObject * obj0 = 0 ;
19738 char *kwnames[] = {
19739 (char *) "self", NULL
19740 };
19741
19742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19744 if (SWIG_arg_fail(1)) SWIG_fail;
19745 {
19746 PyThreadState* __tstate = wxPyBeginAllowThreads();
19747 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19748
19749 wxPyEndAllowThreads(__tstate);
19750 if (PyErr_Occurred()) SWIG_fail;
19751 }
19752 {
19753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19754 }
19755 return resultobj;
19756 fail:
19757 return NULL;
19758 }
19759
19760
19761 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19764 bool arg2 = (bool) true ;
19765 PyObject * obj0 = 0 ;
19766 PyObject * obj1 = 0 ;
19767 char *kwnames[] = {
19768 (char *) "self",(char *) "veto", NULL
19769 };
19770
19771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19773 if (SWIG_arg_fail(1)) SWIG_fail;
19774 if (obj1) {
19775 {
19776 arg2 = (bool)(SWIG_As_bool(obj1));
19777 if (SWIG_arg_fail(2)) SWIG_fail;
19778 }
19779 }
19780 {
19781 PyThreadState* __tstate = wxPyBeginAllowThreads();
19782 (arg1)->Veto(arg2);
19783
19784 wxPyEndAllowThreads(__tstate);
19785 if (PyErr_Occurred()) SWIG_fail;
19786 }
19787 Py_INCREF(Py_None); resultobj = Py_None;
19788 return resultobj;
19789 fail:
19790 return NULL;
19791 }
19792
19793
19794 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19795 PyObject *resultobj;
19796 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19797 bool arg2 ;
19798 PyObject * obj0 = 0 ;
19799 PyObject * obj1 = 0 ;
19800 char *kwnames[] = {
19801 (char *) "self",(char *) "canVeto", NULL
19802 };
19803
19804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19806 if (SWIG_arg_fail(1)) SWIG_fail;
19807 {
19808 arg2 = (bool)(SWIG_As_bool(obj1));
19809 if (SWIG_arg_fail(2)) SWIG_fail;
19810 }
19811 {
19812 PyThreadState* __tstate = wxPyBeginAllowThreads();
19813 (arg1)->SetCanVeto(arg2);
19814
19815 wxPyEndAllowThreads(__tstate);
19816 if (PyErr_Occurred()) SWIG_fail;
19817 }
19818 Py_INCREF(Py_None); resultobj = Py_None;
19819 return resultobj;
19820 fail:
19821 return NULL;
19822 }
19823
19824
19825 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19826 PyObject *resultobj;
19827 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19828 bool result;
19829 PyObject * obj0 = 0 ;
19830 char *kwnames[] = {
19831 (char *) "self", NULL
19832 };
19833
19834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19836 if (SWIG_arg_fail(1)) SWIG_fail;
19837 {
19838 PyThreadState* __tstate = wxPyBeginAllowThreads();
19839 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19840
19841 wxPyEndAllowThreads(__tstate);
19842 if (PyErr_Occurred()) SWIG_fail;
19843 }
19844 {
19845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19846 }
19847 return resultobj;
19848 fail:
19849 return NULL;
19850 }
19851
19852
19853 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19854 PyObject *resultobj;
19855 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19856 bool result;
19857 PyObject * obj0 = 0 ;
19858 char *kwnames[] = {
19859 (char *) "self", NULL
19860 };
19861
19862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19864 if (SWIG_arg_fail(1)) SWIG_fail;
19865 {
19866 PyThreadState* __tstate = wxPyBeginAllowThreads();
19867 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19868
19869 wxPyEndAllowThreads(__tstate);
19870 if (PyErr_Occurred()) SWIG_fail;
19871 }
19872 {
19873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19874 }
19875 return resultobj;
19876 fail:
19877 return NULL;
19878 }
19879
19880
19881 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19882 PyObject *obj;
19883 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19884 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19885 Py_INCREF(obj);
19886 return Py_BuildValue((char *)"");
19887 }
19888 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19889 PyObject *resultobj;
19890 int arg1 = (int) 0 ;
19891 bool arg2 = (bool) false ;
19892 wxShowEvent *result;
19893 PyObject * obj0 = 0 ;
19894 PyObject * obj1 = 0 ;
19895 char *kwnames[] = {
19896 (char *) "winid",(char *) "show", NULL
19897 };
19898
19899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19900 if (obj0) {
19901 {
19902 arg1 = (int)(SWIG_As_int(obj0));
19903 if (SWIG_arg_fail(1)) SWIG_fail;
19904 }
19905 }
19906 if (obj1) {
19907 {
19908 arg2 = (bool)(SWIG_As_bool(obj1));
19909 if (SWIG_arg_fail(2)) SWIG_fail;
19910 }
19911 }
19912 {
19913 PyThreadState* __tstate = wxPyBeginAllowThreads();
19914 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
19915
19916 wxPyEndAllowThreads(__tstate);
19917 if (PyErr_Occurred()) SWIG_fail;
19918 }
19919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
19920 return resultobj;
19921 fail:
19922 return NULL;
19923 }
19924
19925
19926 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19927 PyObject *resultobj;
19928 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19929 bool arg2 ;
19930 PyObject * obj0 = 0 ;
19931 PyObject * obj1 = 0 ;
19932 char *kwnames[] = {
19933 (char *) "self",(char *) "show", NULL
19934 };
19935
19936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
19937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19938 if (SWIG_arg_fail(1)) SWIG_fail;
19939 {
19940 arg2 = (bool)(SWIG_As_bool(obj1));
19941 if (SWIG_arg_fail(2)) SWIG_fail;
19942 }
19943 {
19944 PyThreadState* __tstate = wxPyBeginAllowThreads();
19945 (arg1)->SetShow(arg2);
19946
19947 wxPyEndAllowThreads(__tstate);
19948 if (PyErr_Occurred()) SWIG_fail;
19949 }
19950 Py_INCREF(Py_None); resultobj = Py_None;
19951 return resultobj;
19952 fail:
19953 return NULL;
19954 }
19955
19956
19957 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19958 PyObject *resultobj;
19959 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19960 bool result;
19961 PyObject * obj0 = 0 ;
19962 char *kwnames[] = {
19963 (char *) "self", NULL
19964 };
19965
19966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
19967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19968 if (SWIG_arg_fail(1)) SWIG_fail;
19969 {
19970 PyThreadState* __tstate = wxPyBeginAllowThreads();
19971 result = (bool)((wxShowEvent const *)arg1)->GetShow();
19972
19973 wxPyEndAllowThreads(__tstate);
19974 if (PyErr_Occurred()) SWIG_fail;
19975 }
19976 {
19977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19978 }
19979 return resultobj;
19980 fail:
19981 return NULL;
19982 }
19983
19984
19985 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
19986 PyObject *obj;
19987 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19988 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
19989 Py_INCREF(obj);
19990 return Py_BuildValue((char *)"");
19991 }
19992 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19993 PyObject *resultobj;
19994 int arg1 = (int) 0 ;
19995 bool arg2 = (bool) true ;
19996 wxIconizeEvent *result;
19997 PyObject * obj0 = 0 ;
19998 PyObject * obj1 = 0 ;
19999 char *kwnames[] = {
20000 (char *) "id",(char *) "iconized", NULL
20001 };
20002
20003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20004 if (obj0) {
20005 {
20006 arg1 = (int)(SWIG_As_int(obj0));
20007 if (SWIG_arg_fail(1)) SWIG_fail;
20008 }
20009 }
20010 if (obj1) {
20011 {
20012 arg2 = (bool)(SWIG_As_bool(obj1));
20013 if (SWIG_arg_fail(2)) SWIG_fail;
20014 }
20015 }
20016 {
20017 PyThreadState* __tstate = wxPyBeginAllowThreads();
20018 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20019
20020 wxPyEndAllowThreads(__tstate);
20021 if (PyErr_Occurred()) SWIG_fail;
20022 }
20023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20024 return resultobj;
20025 fail:
20026 return NULL;
20027 }
20028
20029
20030 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20031 PyObject *resultobj;
20032 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20033 bool result;
20034 PyObject * obj0 = 0 ;
20035 char *kwnames[] = {
20036 (char *) "self", NULL
20037 };
20038
20039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20041 if (SWIG_arg_fail(1)) SWIG_fail;
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 result = (bool)(arg1)->Iconized();
20045
20046 wxPyEndAllowThreads(__tstate);
20047 if (PyErr_Occurred()) SWIG_fail;
20048 }
20049 {
20050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20051 }
20052 return resultobj;
20053 fail:
20054 return NULL;
20055 }
20056
20057
20058 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20059 PyObject *obj;
20060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20061 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20062 Py_INCREF(obj);
20063 return Py_BuildValue((char *)"");
20064 }
20065 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20066 PyObject *resultobj;
20067 int arg1 = (int) 0 ;
20068 wxMaximizeEvent *result;
20069 PyObject * obj0 = 0 ;
20070 char *kwnames[] = {
20071 (char *) "id", NULL
20072 };
20073
20074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20075 if (obj0) {
20076 {
20077 arg1 = (int)(SWIG_As_int(obj0));
20078 if (SWIG_arg_fail(1)) SWIG_fail;
20079 }
20080 }
20081 {
20082 PyThreadState* __tstate = wxPyBeginAllowThreads();
20083 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20084
20085 wxPyEndAllowThreads(__tstate);
20086 if (PyErr_Occurred()) SWIG_fail;
20087 }
20088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20089 return resultobj;
20090 fail:
20091 return NULL;
20092 }
20093
20094
20095 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20096 PyObject *obj;
20097 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20098 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20099 Py_INCREF(obj);
20100 return Py_BuildValue((char *)"");
20101 }
20102 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20103 PyObject *resultobj;
20104 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20105 wxPoint result;
20106 PyObject * obj0 = 0 ;
20107 char *kwnames[] = {
20108 (char *) "self", NULL
20109 };
20110
20111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20113 if (SWIG_arg_fail(1)) SWIG_fail;
20114 {
20115 PyThreadState* __tstate = wxPyBeginAllowThreads();
20116 result = (arg1)->GetPosition();
20117
20118 wxPyEndAllowThreads(__tstate);
20119 if (PyErr_Occurred()) SWIG_fail;
20120 }
20121 {
20122 wxPoint * resultptr;
20123 resultptr = new wxPoint((wxPoint &)(result));
20124 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20125 }
20126 return resultobj;
20127 fail:
20128 return NULL;
20129 }
20130
20131
20132 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj;
20134 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20135 int result;
20136 PyObject * obj0 = 0 ;
20137 char *kwnames[] = {
20138 (char *) "self", NULL
20139 };
20140
20141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20143 if (SWIG_arg_fail(1)) SWIG_fail;
20144 {
20145 PyThreadState* __tstate = wxPyBeginAllowThreads();
20146 result = (int)(arg1)->GetNumberOfFiles();
20147
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 {
20152 resultobj = SWIG_From_int((int)(result));
20153 }
20154 return resultobj;
20155 fail:
20156 return NULL;
20157 }
20158
20159
20160 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20161 PyObject *resultobj;
20162 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20163 PyObject *result;
20164 PyObject * obj0 = 0 ;
20165 char *kwnames[] = {
20166 (char *) "self", NULL
20167 };
20168
20169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20171 if (SWIG_arg_fail(1)) SWIG_fail;
20172 {
20173 PyThreadState* __tstate = wxPyBeginAllowThreads();
20174 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20175
20176 wxPyEndAllowThreads(__tstate);
20177 if (PyErr_Occurred()) SWIG_fail;
20178 }
20179 resultobj = result;
20180 return resultobj;
20181 fail:
20182 return NULL;
20183 }
20184
20185
20186 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20187 PyObject *obj;
20188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20189 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20190 Py_INCREF(obj);
20191 return Py_BuildValue((char *)"");
20192 }
20193 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20194 PyObject *resultobj;
20195 int arg1 = (int) 0 ;
20196 wxUpdateUIEvent *result;
20197 PyObject * obj0 = 0 ;
20198 char *kwnames[] = {
20199 (char *) "commandId", NULL
20200 };
20201
20202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20203 if (obj0) {
20204 {
20205 arg1 = (int)(SWIG_As_int(obj0));
20206 if (SWIG_arg_fail(1)) SWIG_fail;
20207 }
20208 }
20209 {
20210 PyThreadState* __tstate = wxPyBeginAllowThreads();
20211 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20212
20213 wxPyEndAllowThreads(__tstate);
20214 if (PyErr_Occurred()) SWIG_fail;
20215 }
20216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20217 return resultobj;
20218 fail:
20219 return NULL;
20220 }
20221
20222
20223 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20224 PyObject *resultobj;
20225 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20226 bool result;
20227 PyObject * obj0 = 0 ;
20228 char *kwnames[] = {
20229 (char *) "self", NULL
20230 };
20231
20232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20234 if (SWIG_arg_fail(1)) SWIG_fail;
20235 {
20236 PyThreadState* __tstate = wxPyBeginAllowThreads();
20237 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20238
20239 wxPyEndAllowThreads(__tstate);
20240 if (PyErr_Occurred()) SWIG_fail;
20241 }
20242 {
20243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20244 }
20245 return resultobj;
20246 fail:
20247 return NULL;
20248 }
20249
20250
20251 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20252 PyObject *resultobj;
20253 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20254 bool result;
20255 PyObject * obj0 = 0 ;
20256 char *kwnames[] = {
20257 (char *) "self", NULL
20258 };
20259
20260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20262 if (SWIG_arg_fail(1)) SWIG_fail;
20263 {
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20266
20267 wxPyEndAllowThreads(__tstate);
20268 if (PyErr_Occurred()) SWIG_fail;
20269 }
20270 {
20271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20272 }
20273 return resultobj;
20274 fail:
20275 return NULL;
20276 }
20277
20278
20279 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20280 PyObject *resultobj;
20281 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20282 wxString result;
20283 PyObject * obj0 = 0 ;
20284 char *kwnames[] = {
20285 (char *) "self", NULL
20286 };
20287
20288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20290 if (SWIG_arg_fail(1)) SWIG_fail;
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20294
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 {
20299 #if wxUSE_UNICODE
20300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20301 #else
20302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20303 #endif
20304 }
20305 return resultobj;
20306 fail:
20307 return NULL;
20308 }
20309
20310
20311 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20312 PyObject *resultobj;
20313 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20314 bool result;
20315 PyObject * obj0 = 0 ;
20316 char *kwnames[] = {
20317 (char *) "self", NULL
20318 };
20319
20320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20322 if (SWIG_arg_fail(1)) SWIG_fail;
20323 {
20324 PyThreadState* __tstate = wxPyBeginAllowThreads();
20325 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20326
20327 wxPyEndAllowThreads(__tstate);
20328 if (PyErr_Occurred()) SWIG_fail;
20329 }
20330 {
20331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20332 }
20333 return resultobj;
20334 fail:
20335 return NULL;
20336 }
20337
20338
20339 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20340 PyObject *resultobj;
20341 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20342 bool result;
20343 PyObject * obj0 = 0 ;
20344 char *kwnames[] = {
20345 (char *) "self", NULL
20346 };
20347
20348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20350 if (SWIG_arg_fail(1)) SWIG_fail;
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20354
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 {
20359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20360 }
20361 return resultobj;
20362 fail:
20363 return NULL;
20364 }
20365
20366
20367 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20368 PyObject *resultobj;
20369 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20370 bool result;
20371 PyObject * obj0 = 0 ;
20372 char *kwnames[] = {
20373 (char *) "self", NULL
20374 };
20375
20376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20378 if (SWIG_arg_fail(1)) SWIG_fail;
20379 {
20380 PyThreadState* __tstate = wxPyBeginAllowThreads();
20381 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20382
20383 wxPyEndAllowThreads(__tstate);
20384 if (PyErr_Occurred()) SWIG_fail;
20385 }
20386 {
20387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20388 }
20389 return resultobj;
20390 fail:
20391 return NULL;
20392 }
20393
20394
20395 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20396 PyObject *resultobj;
20397 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20398 bool arg2 ;
20399 PyObject * obj0 = 0 ;
20400 PyObject * obj1 = 0 ;
20401 char *kwnames[] = {
20402 (char *) "self",(char *) "check", NULL
20403 };
20404
20405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20407 if (SWIG_arg_fail(1)) SWIG_fail;
20408 {
20409 arg2 = (bool)(SWIG_As_bool(obj1));
20410 if (SWIG_arg_fail(2)) SWIG_fail;
20411 }
20412 {
20413 PyThreadState* __tstate = wxPyBeginAllowThreads();
20414 (arg1)->Check(arg2);
20415
20416 wxPyEndAllowThreads(__tstate);
20417 if (PyErr_Occurred()) SWIG_fail;
20418 }
20419 Py_INCREF(Py_None); resultobj = Py_None;
20420 return resultobj;
20421 fail:
20422 return NULL;
20423 }
20424
20425
20426 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20427 PyObject *resultobj;
20428 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20429 bool arg2 ;
20430 PyObject * obj0 = 0 ;
20431 PyObject * obj1 = 0 ;
20432 char *kwnames[] = {
20433 (char *) "self",(char *) "enable", NULL
20434 };
20435
20436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20438 if (SWIG_arg_fail(1)) SWIG_fail;
20439 {
20440 arg2 = (bool)(SWIG_As_bool(obj1));
20441 if (SWIG_arg_fail(2)) SWIG_fail;
20442 }
20443 {
20444 PyThreadState* __tstate = wxPyBeginAllowThreads();
20445 (arg1)->Enable(arg2);
20446
20447 wxPyEndAllowThreads(__tstate);
20448 if (PyErr_Occurred()) SWIG_fail;
20449 }
20450 Py_INCREF(Py_None); resultobj = Py_None;
20451 return resultobj;
20452 fail:
20453 return NULL;
20454 }
20455
20456
20457 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20458 PyObject *resultobj;
20459 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20460 wxString *arg2 = 0 ;
20461 bool temp2 = false ;
20462 PyObject * obj0 = 0 ;
20463 PyObject * obj1 = 0 ;
20464 char *kwnames[] = {
20465 (char *) "self",(char *) "text", NULL
20466 };
20467
20468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20470 if (SWIG_arg_fail(1)) SWIG_fail;
20471 {
20472 arg2 = wxString_in_helper(obj1);
20473 if (arg2 == NULL) SWIG_fail;
20474 temp2 = true;
20475 }
20476 {
20477 PyThreadState* __tstate = wxPyBeginAllowThreads();
20478 (arg1)->SetText((wxString const &)*arg2);
20479
20480 wxPyEndAllowThreads(__tstate);
20481 if (PyErr_Occurred()) SWIG_fail;
20482 }
20483 Py_INCREF(Py_None); resultobj = Py_None;
20484 {
20485 if (temp2)
20486 delete arg2;
20487 }
20488 return resultobj;
20489 fail:
20490 {
20491 if (temp2)
20492 delete arg2;
20493 }
20494 return NULL;
20495 }
20496
20497
20498 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20499 PyObject *resultobj;
20500 long arg1 ;
20501 PyObject * obj0 = 0 ;
20502 char *kwnames[] = {
20503 (char *) "updateInterval", NULL
20504 };
20505
20506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20507 {
20508 arg1 = (long)(SWIG_As_long(obj0));
20509 if (SWIG_arg_fail(1)) SWIG_fail;
20510 }
20511 {
20512 PyThreadState* __tstate = wxPyBeginAllowThreads();
20513 wxUpdateUIEvent::SetUpdateInterval(arg1);
20514
20515 wxPyEndAllowThreads(__tstate);
20516 if (PyErr_Occurred()) SWIG_fail;
20517 }
20518 Py_INCREF(Py_None); resultobj = Py_None;
20519 return resultobj;
20520 fail:
20521 return NULL;
20522 }
20523
20524
20525 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20526 PyObject *resultobj;
20527 long result;
20528 char *kwnames[] = {
20529 NULL
20530 };
20531
20532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20533 {
20534 PyThreadState* __tstate = wxPyBeginAllowThreads();
20535 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20536
20537 wxPyEndAllowThreads(__tstate);
20538 if (PyErr_Occurred()) SWIG_fail;
20539 }
20540 {
20541 resultobj = SWIG_From_long((long)(result));
20542 }
20543 return resultobj;
20544 fail:
20545 return NULL;
20546 }
20547
20548
20549 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20550 PyObject *resultobj;
20551 wxWindow *arg1 = (wxWindow *) 0 ;
20552 bool result;
20553 PyObject * obj0 = 0 ;
20554 char *kwnames[] = {
20555 (char *) "win", NULL
20556 };
20557
20558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20560 if (SWIG_arg_fail(1)) SWIG_fail;
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20564
20565 wxPyEndAllowThreads(__tstate);
20566 if (PyErr_Occurred()) SWIG_fail;
20567 }
20568 {
20569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20570 }
20571 return resultobj;
20572 fail:
20573 return NULL;
20574 }
20575
20576
20577 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20578 PyObject *resultobj;
20579 char *kwnames[] = {
20580 NULL
20581 };
20582
20583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20584 {
20585 PyThreadState* __tstate = wxPyBeginAllowThreads();
20586 wxUpdateUIEvent::ResetUpdateTime();
20587
20588 wxPyEndAllowThreads(__tstate);
20589 if (PyErr_Occurred()) SWIG_fail;
20590 }
20591 Py_INCREF(Py_None); resultobj = Py_None;
20592 return resultobj;
20593 fail:
20594 return NULL;
20595 }
20596
20597
20598 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20599 PyObject *resultobj;
20600 wxUpdateUIMode arg1 ;
20601 PyObject * obj0 = 0 ;
20602 char *kwnames[] = {
20603 (char *) "mode", NULL
20604 };
20605
20606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20607 {
20608 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20609 if (SWIG_arg_fail(1)) SWIG_fail;
20610 }
20611 {
20612 PyThreadState* __tstate = wxPyBeginAllowThreads();
20613 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20614
20615 wxPyEndAllowThreads(__tstate);
20616 if (PyErr_Occurred()) SWIG_fail;
20617 }
20618 Py_INCREF(Py_None); resultobj = Py_None;
20619 return resultobj;
20620 fail:
20621 return NULL;
20622 }
20623
20624
20625 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20626 PyObject *resultobj;
20627 wxUpdateUIMode result;
20628 char *kwnames[] = {
20629 NULL
20630 };
20631
20632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20633 {
20634 PyThreadState* __tstate = wxPyBeginAllowThreads();
20635 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20636
20637 wxPyEndAllowThreads(__tstate);
20638 if (PyErr_Occurred()) SWIG_fail;
20639 }
20640 resultobj = SWIG_From_int((result));
20641 return resultobj;
20642 fail:
20643 return NULL;
20644 }
20645
20646
20647 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20648 PyObject *obj;
20649 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20650 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20651 Py_INCREF(obj);
20652 return Py_BuildValue((char *)"");
20653 }
20654 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20655 PyObject *resultobj;
20656 wxSysColourChangedEvent *result;
20657 char *kwnames[] = {
20658 NULL
20659 };
20660
20661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20662 {
20663 PyThreadState* __tstate = wxPyBeginAllowThreads();
20664 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20665
20666 wxPyEndAllowThreads(__tstate);
20667 if (PyErr_Occurred()) SWIG_fail;
20668 }
20669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20670 return resultobj;
20671 fail:
20672 return NULL;
20673 }
20674
20675
20676 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20677 PyObject *obj;
20678 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20679 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20680 Py_INCREF(obj);
20681 return Py_BuildValue((char *)"");
20682 }
20683 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20684 PyObject *resultobj;
20685 int arg1 = (int) 0 ;
20686 wxWindow *arg2 = (wxWindow *) NULL ;
20687 wxMouseCaptureChangedEvent *result;
20688 PyObject * obj0 = 0 ;
20689 PyObject * obj1 = 0 ;
20690 char *kwnames[] = {
20691 (char *) "winid",(char *) "gainedCapture", NULL
20692 };
20693
20694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20695 if (obj0) {
20696 {
20697 arg1 = (int)(SWIG_As_int(obj0));
20698 if (SWIG_arg_fail(1)) SWIG_fail;
20699 }
20700 }
20701 if (obj1) {
20702 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20703 if (SWIG_arg_fail(2)) SWIG_fail;
20704 }
20705 {
20706 PyThreadState* __tstate = wxPyBeginAllowThreads();
20707 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20708
20709 wxPyEndAllowThreads(__tstate);
20710 if (PyErr_Occurred()) SWIG_fail;
20711 }
20712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20713 return resultobj;
20714 fail:
20715 return NULL;
20716 }
20717
20718
20719 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20720 PyObject *resultobj;
20721 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20722 wxWindow *result;
20723 PyObject * obj0 = 0 ;
20724 char *kwnames[] = {
20725 (char *) "self", NULL
20726 };
20727
20728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20730 if (SWIG_arg_fail(1)) SWIG_fail;
20731 {
20732 PyThreadState* __tstate = wxPyBeginAllowThreads();
20733 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20734
20735 wxPyEndAllowThreads(__tstate);
20736 if (PyErr_Occurred()) SWIG_fail;
20737 }
20738 {
20739 resultobj = wxPyMake_wxObject(result, 0);
20740 }
20741 return resultobj;
20742 fail:
20743 return NULL;
20744 }
20745
20746
20747 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20748 PyObject *obj;
20749 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20750 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20751 Py_INCREF(obj);
20752 return Py_BuildValue((char *)"");
20753 }
20754 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20755 PyObject *resultobj;
20756 wxDisplayChangedEvent *result;
20757 char *kwnames[] = {
20758 NULL
20759 };
20760
20761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20762 {
20763 PyThreadState* __tstate = wxPyBeginAllowThreads();
20764 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20765
20766 wxPyEndAllowThreads(__tstate);
20767 if (PyErr_Occurred()) SWIG_fail;
20768 }
20769 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20770 return resultobj;
20771 fail:
20772 return NULL;
20773 }
20774
20775
20776 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20777 PyObject *obj;
20778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20779 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20780 Py_INCREF(obj);
20781 return Py_BuildValue((char *)"");
20782 }
20783 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20784 PyObject *resultobj;
20785 int arg1 = (int) 0 ;
20786 wxPaletteChangedEvent *result;
20787 PyObject * obj0 = 0 ;
20788 char *kwnames[] = {
20789 (char *) "id", NULL
20790 };
20791
20792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20793 if (obj0) {
20794 {
20795 arg1 = (int)(SWIG_As_int(obj0));
20796 if (SWIG_arg_fail(1)) SWIG_fail;
20797 }
20798 }
20799 {
20800 PyThreadState* __tstate = wxPyBeginAllowThreads();
20801 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20802
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20814 PyObject *resultobj;
20815 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20816 wxWindow *arg2 = (wxWindow *) 0 ;
20817 PyObject * obj0 = 0 ;
20818 PyObject * obj1 = 0 ;
20819 char *kwnames[] = {
20820 (char *) "self",(char *) "win", NULL
20821 };
20822
20823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20825 if (SWIG_arg_fail(1)) SWIG_fail;
20826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20827 if (SWIG_arg_fail(2)) SWIG_fail;
20828 {
20829 PyThreadState* __tstate = wxPyBeginAllowThreads();
20830 (arg1)->SetChangedWindow(arg2);
20831
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 Py_INCREF(Py_None); resultobj = Py_None;
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20843 PyObject *resultobj;
20844 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20845 wxWindow *result;
20846 PyObject * obj0 = 0 ;
20847 char *kwnames[] = {
20848 (char *) "self", NULL
20849 };
20850
20851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20853 if (SWIG_arg_fail(1)) SWIG_fail;
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 result = (wxWindow *)(arg1)->GetChangedWindow();
20857
20858 wxPyEndAllowThreads(__tstate);
20859 if (PyErr_Occurred()) SWIG_fail;
20860 }
20861 {
20862 resultobj = wxPyMake_wxObject(result, 0);
20863 }
20864 return resultobj;
20865 fail:
20866 return NULL;
20867 }
20868
20869
20870 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20871 PyObject *obj;
20872 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20873 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20874 Py_INCREF(obj);
20875 return Py_BuildValue((char *)"");
20876 }
20877 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20878 PyObject *resultobj;
20879 int arg1 = (int) 0 ;
20880 wxQueryNewPaletteEvent *result;
20881 PyObject * obj0 = 0 ;
20882 char *kwnames[] = {
20883 (char *) "winid", NULL
20884 };
20885
20886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20887 if (obj0) {
20888 {
20889 arg1 = (int)(SWIG_As_int(obj0));
20890 if (SWIG_arg_fail(1)) SWIG_fail;
20891 }
20892 }
20893 {
20894 PyThreadState* __tstate = wxPyBeginAllowThreads();
20895 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20896
20897 wxPyEndAllowThreads(__tstate);
20898 if (PyErr_Occurred()) SWIG_fail;
20899 }
20900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20901 return resultobj;
20902 fail:
20903 return NULL;
20904 }
20905
20906
20907 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20908 PyObject *resultobj;
20909 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20910 bool arg2 ;
20911 PyObject * obj0 = 0 ;
20912 PyObject * obj1 = 0 ;
20913 char *kwnames[] = {
20914 (char *) "self",(char *) "realized", NULL
20915 };
20916
20917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
20918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20919 if (SWIG_arg_fail(1)) SWIG_fail;
20920 {
20921 arg2 = (bool)(SWIG_As_bool(obj1));
20922 if (SWIG_arg_fail(2)) SWIG_fail;
20923 }
20924 {
20925 PyThreadState* __tstate = wxPyBeginAllowThreads();
20926 (arg1)->SetPaletteRealized(arg2);
20927
20928 wxPyEndAllowThreads(__tstate);
20929 if (PyErr_Occurred()) SWIG_fail;
20930 }
20931 Py_INCREF(Py_None); resultobj = Py_None;
20932 return resultobj;
20933 fail:
20934 return NULL;
20935 }
20936
20937
20938 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20939 PyObject *resultobj;
20940 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20941 bool result;
20942 PyObject * obj0 = 0 ;
20943 char *kwnames[] = {
20944 (char *) "self", NULL
20945 };
20946
20947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
20948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20949 if (SWIG_arg_fail(1)) SWIG_fail;
20950 {
20951 PyThreadState* __tstate = wxPyBeginAllowThreads();
20952 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
20953
20954 wxPyEndAllowThreads(__tstate);
20955 if (PyErr_Occurred()) SWIG_fail;
20956 }
20957 {
20958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20959 }
20960 return resultobj;
20961 fail:
20962 return NULL;
20963 }
20964
20965
20966 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
20967 PyObject *obj;
20968 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20969 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
20970 Py_INCREF(obj);
20971 return Py_BuildValue((char *)"");
20972 }
20973 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20974 PyObject *resultobj;
20975 wxNavigationKeyEvent *result;
20976 char *kwnames[] = {
20977 NULL
20978 };
20979
20980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
20981 {
20982 PyThreadState* __tstate = wxPyBeginAllowThreads();
20983 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
20984
20985 wxPyEndAllowThreads(__tstate);
20986 if (PyErr_Occurred()) SWIG_fail;
20987 }
20988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
20989 return resultobj;
20990 fail:
20991 return NULL;
20992 }
20993
20994
20995 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
20996 PyObject *resultobj;
20997 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20998 bool result;
20999 PyObject * obj0 = 0 ;
21000 char *kwnames[] = {
21001 (char *) "self", NULL
21002 };
21003
21004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21006 if (SWIG_arg_fail(1)) SWIG_fail;
21007 {
21008 PyThreadState* __tstate = wxPyBeginAllowThreads();
21009 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21010
21011 wxPyEndAllowThreads(__tstate);
21012 if (PyErr_Occurred()) SWIG_fail;
21013 }
21014 {
21015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21016 }
21017 return resultobj;
21018 fail:
21019 return NULL;
21020 }
21021
21022
21023 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21024 PyObject *resultobj;
21025 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21026 bool arg2 ;
21027 PyObject * obj0 = 0 ;
21028 PyObject * obj1 = 0 ;
21029 char *kwnames[] = {
21030 (char *) "self",(char *) "forward", NULL
21031 };
21032
21033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21035 if (SWIG_arg_fail(1)) SWIG_fail;
21036 {
21037 arg2 = (bool)(SWIG_As_bool(obj1));
21038 if (SWIG_arg_fail(2)) SWIG_fail;
21039 }
21040 {
21041 PyThreadState* __tstate = wxPyBeginAllowThreads();
21042 (arg1)->SetDirection(arg2);
21043
21044 wxPyEndAllowThreads(__tstate);
21045 if (PyErr_Occurred()) SWIG_fail;
21046 }
21047 Py_INCREF(Py_None); resultobj = Py_None;
21048 return resultobj;
21049 fail:
21050 return NULL;
21051 }
21052
21053
21054 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21055 PyObject *resultobj;
21056 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21057 bool result;
21058 PyObject * obj0 = 0 ;
21059 char *kwnames[] = {
21060 (char *) "self", NULL
21061 };
21062
21063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21065 if (SWIG_arg_fail(1)) SWIG_fail;
21066 {
21067 PyThreadState* __tstate = wxPyBeginAllowThreads();
21068 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21069
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 {
21074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21075 }
21076 return resultobj;
21077 fail:
21078 return NULL;
21079 }
21080
21081
21082 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21083 PyObject *resultobj;
21084 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21085 bool arg2 ;
21086 PyObject * obj0 = 0 ;
21087 PyObject * obj1 = 0 ;
21088 char *kwnames[] = {
21089 (char *) "self",(char *) "ischange", NULL
21090 };
21091
21092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21094 if (SWIG_arg_fail(1)) SWIG_fail;
21095 {
21096 arg2 = (bool)(SWIG_As_bool(obj1));
21097 if (SWIG_arg_fail(2)) SWIG_fail;
21098 }
21099 {
21100 PyThreadState* __tstate = wxPyBeginAllowThreads();
21101 (arg1)->SetWindowChange(arg2);
21102
21103 wxPyEndAllowThreads(__tstate);
21104 if (PyErr_Occurred()) SWIG_fail;
21105 }
21106 Py_INCREF(Py_None); resultobj = Py_None;
21107 return resultobj;
21108 fail:
21109 return NULL;
21110 }
21111
21112
21113 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21114 PyObject *resultobj;
21115 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21116 long arg2 ;
21117 PyObject * obj0 = 0 ;
21118 PyObject * obj1 = 0 ;
21119 char *kwnames[] = {
21120 (char *) "self",(char *) "flags", NULL
21121 };
21122
21123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21125 if (SWIG_arg_fail(1)) SWIG_fail;
21126 {
21127 arg2 = (long)(SWIG_As_long(obj1));
21128 if (SWIG_arg_fail(2)) SWIG_fail;
21129 }
21130 {
21131 PyThreadState* __tstate = wxPyBeginAllowThreads();
21132 (arg1)->SetFlags(arg2);
21133
21134 wxPyEndAllowThreads(__tstate);
21135 if (PyErr_Occurred()) SWIG_fail;
21136 }
21137 Py_INCREF(Py_None); resultobj = Py_None;
21138 return resultobj;
21139 fail:
21140 return NULL;
21141 }
21142
21143
21144 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21145 PyObject *resultobj;
21146 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21147 wxWindow *result;
21148 PyObject * obj0 = 0 ;
21149 char *kwnames[] = {
21150 (char *) "self", NULL
21151 };
21152
21153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21155 if (SWIG_arg_fail(1)) SWIG_fail;
21156 {
21157 PyThreadState* __tstate = wxPyBeginAllowThreads();
21158 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21159
21160 wxPyEndAllowThreads(__tstate);
21161 if (PyErr_Occurred()) SWIG_fail;
21162 }
21163 {
21164 resultobj = wxPyMake_wxObject(result, 0);
21165 }
21166 return resultobj;
21167 fail:
21168 return NULL;
21169 }
21170
21171
21172 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21173 PyObject *resultobj;
21174 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21175 wxWindow *arg2 = (wxWindow *) 0 ;
21176 PyObject * obj0 = 0 ;
21177 PyObject * obj1 = 0 ;
21178 char *kwnames[] = {
21179 (char *) "self",(char *) "win", NULL
21180 };
21181
21182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21184 if (SWIG_arg_fail(1)) SWIG_fail;
21185 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21186 if (SWIG_arg_fail(2)) SWIG_fail;
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 (arg1)->SetCurrentFocus(arg2);
21190
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 Py_INCREF(Py_None); resultobj = Py_None;
21195 return resultobj;
21196 fail:
21197 return NULL;
21198 }
21199
21200
21201 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21202 PyObject *obj;
21203 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21204 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21205 Py_INCREF(obj);
21206 return Py_BuildValue((char *)"");
21207 }
21208 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21209 PyObject *resultobj;
21210 wxWindow *arg1 = (wxWindow *) NULL ;
21211 wxWindowCreateEvent *result;
21212 PyObject * obj0 = 0 ;
21213 char *kwnames[] = {
21214 (char *) "win", NULL
21215 };
21216
21217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21218 if (obj0) {
21219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21220 if (SWIG_arg_fail(1)) SWIG_fail;
21221 }
21222 {
21223 PyThreadState* __tstate = wxPyBeginAllowThreads();
21224 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21225
21226 wxPyEndAllowThreads(__tstate);
21227 if (PyErr_Occurred()) SWIG_fail;
21228 }
21229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21230 return resultobj;
21231 fail:
21232 return NULL;
21233 }
21234
21235
21236 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21237 PyObject *resultobj;
21238 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21239 wxWindow *result;
21240 PyObject * obj0 = 0 ;
21241 char *kwnames[] = {
21242 (char *) "self", NULL
21243 };
21244
21245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21247 if (SWIG_arg_fail(1)) SWIG_fail;
21248 {
21249 PyThreadState* __tstate = wxPyBeginAllowThreads();
21250 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21251
21252 wxPyEndAllowThreads(__tstate);
21253 if (PyErr_Occurred()) SWIG_fail;
21254 }
21255 {
21256 resultobj = wxPyMake_wxObject(result, 0);
21257 }
21258 return resultobj;
21259 fail:
21260 return NULL;
21261 }
21262
21263
21264 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21265 PyObject *obj;
21266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21267 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21268 Py_INCREF(obj);
21269 return Py_BuildValue((char *)"");
21270 }
21271 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21272 PyObject *resultobj;
21273 wxWindow *arg1 = (wxWindow *) NULL ;
21274 wxWindowDestroyEvent *result;
21275 PyObject * obj0 = 0 ;
21276 char *kwnames[] = {
21277 (char *) "win", NULL
21278 };
21279
21280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21281 if (obj0) {
21282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21283 if (SWIG_arg_fail(1)) SWIG_fail;
21284 }
21285 {
21286 PyThreadState* __tstate = wxPyBeginAllowThreads();
21287 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21288
21289 wxPyEndAllowThreads(__tstate);
21290 if (PyErr_Occurred()) SWIG_fail;
21291 }
21292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21293 return resultobj;
21294 fail:
21295 return NULL;
21296 }
21297
21298
21299 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21300 PyObject *resultobj;
21301 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21302 wxWindow *result;
21303 PyObject * obj0 = 0 ;
21304 char *kwnames[] = {
21305 (char *) "self", NULL
21306 };
21307
21308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21310 if (SWIG_arg_fail(1)) SWIG_fail;
21311 {
21312 PyThreadState* __tstate = wxPyBeginAllowThreads();
21313 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21314
21315 wxPyEndAllowThreads(__tstate);
21316 if (PyErr_Occurred()) SWIG_fail;
21317 }
21318 {
21319 resultobj = wxPyMake_wxObject(result, 0);
21320 }
21321 return resultobj;
21322 fail:
21323 return NULL;
21324 }
21325
21326
21327 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21328 PyObject *obj;
21329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21330 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21331 Py_INCREF(obj);
21332 return Py_BuildValue((char *)"");
21333 }
21334 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21335 PyObject *resultobj;
21336 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21337 int arg2 = (int) 0 ;
21338 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21339 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21340 wxContextMenuEvent *result;
21341 wxPoint temp3 ;
21342 PyObject * obj0 = 0 ;
21343 PyObject * obj1 = 0 ;
21344 PyObject * obj2 = 0 ;
21345 char *kwnames[] = {
21346 (char *) "type",(char *) "winid",(char *) "pt", NULL
21347 };
21348
21349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21350 if (obj0) {
21351 {
21352 arg1 = (wxEventType)(SWIG_As_int(obj0));
21353 if (SWIG_arg_fail(1)) SWIG_fail;
21354 }
21355 }
21356 if (obj1) {
21357 {
21358 arg2 = (int)(SWIG_As_int(obj1));
21359 if (SWIG_arg_fail(2)) SWIG_fail;
21360 }
21361 }
21362 if (obj2) {
21363 {
21364 arg3 = &temp3;
21365 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21366 }
21367 }
21368 {
21369 PyThreadState* __tstate = wxPyBeginAllowThreads();
21370 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21371
21372 wxPyEndAllowThreads(__tstate);
21373 if (PyErr_Occurred()) SWIG_fail;
21374 }
21375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21376 return resultobj;
21377 fail:
21378 return NULL;
21379 }
21380
21381
21382 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21383 PyObject *resultobj;
21384 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21385 wxPoint *result;
21386 PyObject * obj0 = 0 ;
21387 char *kwnames[] = {
21388 (char *) "self", NULL
21389 };
21390
21391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21393 if (SWIG_arg_fail(1)) SWIG_fail;
21394 {
21395 PyThreadState* __tstate = wxPyBeginAllowThreads();
21396 {
21397 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21398 result = (wxPoint *) &_result_ref;
21399 }
21400
21401 wxPyEndAllowThreads(__tstate);
21402 if (PyErr_Occurred()) SWIG_fail;
21403 }
21404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21405 return resultobj;
21406 fail:
21407 return NULL;
21408 }
21409
21410
21411 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21412 PyObject *resultobj;
21413 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21414 wxPoint *arg2 = 0 ;
21415 wxPoint temp2 ;
21416 PyObject * obj0 = 0 ;
21417 PyObject * obj1 = 0 ;
21418 char *kwnames[] = {
21419 (char *) "self",(char *) "pos", NULL
21420 };
21421
21422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21424 if (SWIG_arg_fail(1)) SWIG_fail;
21425 {
21426 arg2 = &temp2;
21427 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21428 }
21429 {
21430 PyThreadState* __tstate = wxPyBeginAllowThreads();
21431 (arg1)->SetPosition((wxPoint const &)*arg2);
21432
21433 wxPyEndAllowThreads(__tstate);
21434 if (PyErr_Occurred()) SWIG_fail;
21435 }
21436 Py_INCREF(Py_None); resultobj = Py_None;
21437 return resultobj;
21438 fail:
21439 return NULL;
21440 }
21441
21442
21443 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21444 PyObject *obj;
21445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21446 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21447 Py_INCREF(obj);
21448 return Py_BuildValue((char *)"");
21449 }
21450 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21451 PyObject *resultobj;
21452 wxIdleEvent *result;
21453 char *kwnames[] = {
21454 NULL
21455 };
21456
21457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21458 {
21459 PyThreadState* __tstate = wxPyBeginAllowThreads();
21460 result = (wxIdleEvent *)new wxIdleEvent();
21461
21462 wxPyEndAllowThreads(__tstate);
21463 if (PyErr_Occurred()) SWIG_fail;
21464 }
21465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21466 return resultobj;
21467 fail:
21468 return NULL;
21469 }
21470
21471
21472 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21473 PyObject *resultobj;
21474 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21475 bool arg2 = (bool) true ;
21476 PyObject * obj0 = 0 ;
21477 PyObject * obj1 = 0 ;
21478 char *kwnames[] = {
21479 (char *) "self",(char *) "needMore", NULL
21480 };
21481
21482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21484 if (SWIG_arg_fail(1)) SWIG_fail;
21485 if (obj1) {
21486 {
21487 arg2 = (bool)(SWIG_As_bool(obj1));
21488 if (SWIG_arg_fail(2)) SWIG_fail;
21489 }
21490 }
21491 {
21492 PyThreadState* __tstate = wxPyBeginAllowThreads();
21493 (arg1)->RequestMore(arg2);
21494
21495 wxPyEndAllowThreads(__tstate);
21496 if (PyErr_Occurred()) SWIG_fail;
21497 }
21498 Py_INCREF(Py_None); resultobj = Py_None;
21499 return resultobj;
21500 fail:
21501 return NULL;
21502 }
21503
21504
21505 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21506 PyObject *resultobj;
21507 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21508 bool result;
21509 PyObject * obj0 = 0 ;
21510 char *kwnames[] = {
21511 (char *) "self", NULL
21512 };
21513
21514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21516 if (SWIG_arg_fail(1)) SWIG_fail;
21517 {
21518 PyThreadState* __tstate = wxPyBeginAllowThreads();
21519 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21520
21521 wxPyEndAllowThreads(__tstate);
21522 if (PyErr_Occurred()) SWIG_fail;
21523 }
21524 {
21525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21526 }
21527 return resultobj;
21528 fail:
21529 return NULL;
21530 }
21531
21532
21533 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21534 PyObject *resultobj;
21535 wxIdleMode arg1 ;
21536 PyObject * obj0 = 0 ;
21537 char *kwnames[] = {
21538 (char *) "mode", NULL
21539 };
21540
21541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21542 {
21543 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21544 if (SWIG_arg_fail(1)) SWIG_fail;
21545 }
21546 {
21547 PyThreadState* __tstate = wxPyBeginAllowThreads();
21548 wxIdleEvent::SetMode((wxIdleMode )arg1);
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_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21561 PyObject *resultobj;
21562 wxIdleMode result;
21563 char *kwnames[] = {
21564 NULL
21565 };
21566
21567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21568 {
21569 PyThreadState* __tstate = wxPyBeginAllowThreads();
21570 result = (wxIdleMode)wxIdleEvent::GetMode();
21571
21572 wxPyEndAllowThreads(__tstate);
21573 if (PyErr_Occurred()) SWIG_fail;
21574 }
21575 resultobj = SWIG_From_int((result));
21576 return resultobj;
21577 fail:
21578 return NULL;
21579 }
21580
21581
21582 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21583 PyObject *resultobj;
21584 wxWindow *arg1 = (wxWindow *) 0 ;
21585 bool result;
21586 PyObject * obj0 = 0 ;
21587 char *kwnames[] = {
21588 (char *) "win", NULL
21589 };
21590
21591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21593 if (SWIG_arg_fail(1)) SWIG_fail;
21594 {
21595 PyThreadState* __tstate = wxPyBeginAllowThreads();
21596 result = (bool)wxIdleEvent::CanSend(arg1);
21597
21598 wxPyEndAllowThreads(__tstate);
21599 if (PyErr_Occurred()) SWIG_fail;
21600 }
21601 {
21602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21603 }
21604 return resultobj;
21605 fail:
21606 return NULL;
21607 }
21608
21609
21610 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21611 PyObject *obj;
21612 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21613 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21614 Py_INCREF(obj);
21615 return Py_BuildValue((char *)"");
21616 }
21617 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21618 PyObject *resultobj;
21619 int arg1 = (int) 0 ;
21620 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21621 wxPyEvent *result;
21622 PyObject * obj0 = 0 ;
21623 PyObject * obj1 = 0 ;
21624 char *kwnames[] = {
21625 (char *) "winid",(char *) "commandType", NULL
21626 };
21627
21628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21629 if (obj0) {
21630 {
21631 arg1 = (int)(SWIG_As_int(obj0));
21632 if (SWIG_arg_fail(1)) SWIG_fail;
21633 }
21634 }
21635 if (obj1) {
21636 {
21637 arg2 = (wxEventType)(SWIG_As_int(obj1));
21638 if (SWIG_arg_fail(2)) SWIG_fail;
21639 }
21640 }
21641 {
21642 PyThreadState* __tstate = wxPyBeginAllowThreads();
21643 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21644
21645 wxPyEndAllowThreads(__tstate);
21646 if (PyErr_Occurred()) SWIG_fail;
21647 }
21648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21649 return resultobj;
21650 fail:
21651 return NULL;
21652 }
21653
21654
21655 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21656 PyObject *resultobj;
21657 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21658 PyObject * obj0 = 0 ;
21659 char *kwnames[] = {
21660 (char *) "self", NULL
21661 };
21662
21663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21665 if (SWIG_arg_fail(1)) SWIG_fail;
21666 {
21667 PyThreadState* __tstate = wxPyBeginAllowThreads();
21668 delete arg1;
21669
21670 wxPyEndAllowThreads(__tstate);
21671 if (PyErr_Occurred()) SWIG_fail;
21672 }
21673 Py_INCREF(Py_None); resultobj = Py_None;
21674 return resultobj;
21675 fail:
21676 return NULL;
21677 }
21678
21679
21680 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21681 PyObject *resultobj;
21682 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21683 PyObject *arg2 = (PyObject *) 0 ;
21684 PyObject * obj0 = 0 ;
21685 PyObject * obj1 = 0 ;
21686 char *kwnames[] = {
21687 (char *) "self",(char *) "self", NULL
21688 };
21689
21690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21692 if (SWIG_arg_fail(1)) SWIG_fail;
21693 arg2 = obj1;
21694 {
21695 PyThreadState* __tstate = wxPyBeginAllowThreads();
21696 (arg1)->SetSelf(arg2);
21697
21698 wxPyEndAllowThreads(__tstate);
21699 if (PyErr_Occurred()) SWIG_fail;
21700 }
21701 Py_INCREF(Py_None); resultobj = Py_None;
21702 return resultobj;
21703 fail:
21704 return NULL;
21705 }
21706
21707
21708 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21709 PyObject *resultobj;
21710 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21711 PyObject *result;
21712 PyObject * obj0 = 0 ;
21713 char *kwnames[] = {
21714 (char *) "self", NULL
21715 };
21716
21717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21719 if (SWIG_arg_fail(1)) SWIG_fail;
21720 {
21721 PyThreadState* __tstate = wxPyBeginAllowThreads();
21722 result = (PyObject *)(arg1)->GetSelf();
21723
21724 wxPyEndAllowThreads(__tstate);
21725 if (PyErr_Occurred()) SWIG_fail;
21726 }
21727 resultobj = result;
21728 return resultobj;
21729 fail:
21730 return NULL;
21731 }
21732
21733
21734 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21735 PyObject *obj;
21736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21737 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21738 Py_INCREF(obj);
21739 return Py_BuildValue((char *)"");
21740 }
21741 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21742 PyObject *resultobj;
21743 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21744 int arg2 = (int) 0 ;
21745 wxPyCommandEvent *result;
21746 PyObject * obj0 = 0 ;
21747 PyObject * obj1 = 0 ;
21748 char *kwnames[] = {
21749 (char *) "commandType",(char *) "id", NULL
21750 };
21751
21752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21753 if (obj0) {
21754 {
21755 arg1 = (wxEventType)(SWIG_As_int(obj0));
21756 if (SWIG_arg_fail(1)) SWIG_fail;
21757 }
21758 }
21759 if (obj1) {
21760 {
21761 arg2 = (int)(SWIG_As_int(obj1));
21762 if (SWIG_arg_fail(2)) SWIG_fail;
21763 }
21764 }
21765 {
21766 PyThreadState* __tstate = wxPyBeginAllowThreads();
21767 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21768
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21780 PyObject *resultobj;
21781 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21782 PyObject * obj0 = 0 ;
21783 char *kwnames[] = {
21784 (char *) "self", NULL
21785 };
21786
21787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21789 if (SWIG_arg_fail(1)) SWIG_fail;
21790 {
21791 PyThreadState* __tstate = wxPyBeginAllowThreads();
21792 delete arg1;
21793
21794 wxPyEndAllowThreads(__tstate);
21795 if (PyErr_Occurred()) SWIG_fail;
21796 }
21797 Py_INCREF(Py_None); resultobj = Py_None;
21798 return resultobj;
21799 fail:
21800 return NULL;
21801 }
21802
21803
21804 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21805 PyObject *resultobj;
21806 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21807 PyObject *arg2 = (PyObject *) 0 ;
21808 PyObject * obj0 = 0 ;
21809 PyObject * obj1 = 0 ;
21810 char *kwnames[] = {
21811 (char *) "self",(char *) "self", NULL
21812 };
21813
21814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21816 if (SWIG_arg_fail(1)) SWIG_fail;
21817 arg2 = obj1;
21818 {
21819 PyThreadState* __tstate = wxPyBeginAllowThreads();
21820 (arg1)->SetSelf(arg2);
21821
21822 wxPyEndAllowThreads(__tstate);
21823 if (PyErr_Occurred()) SWIG_fail;
21824 }
21825 Py_INCREF(Py_None); resultobj = Py_None;
21826 return resultobj;
21827 fail:
21828 return NULL;
21829 }
21830
21831
21832 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21833 PyObject *resultobj;
21834 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21835 PyObject *result;
21836 PyObject * obj0 = 0 ;
21837 char *kwnames[] = {
21838 (char *) "self", NULL
21839 };
21840
21841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21843 if (SWIG_arg_fail(1)) SWIG_fail;
21844 {
21845 PyThreadState* __tstate = wxPyBeginAllowThreads();
21846 result = (PyObject *)(arg1)->GetSelf();
21847
21848 wxPyEndAllowThreads(__tstate);
21849 if (PyErr_Occurred()) SWIG_fail;
21850 }
21851 resultobj = result;
21852 return resultobj;
21853 fail:
21854 return NULL;
21855 }
21856
21857
21858 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
21859 PyObject *obj;
21860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21861 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
21862 Py_INCREF(obj);
21863 return Py_BuildValue((char *)"");
21864 }
21865 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21866 PyObject *resultobj;
21867 wxPyApp *result;
21868 char *kwnames[] = {
21869 NULL
21870 };
21871
21872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
21873 {
21874 PyThreadState* __tstate = wxPyBeginAllowThreads();
21875 result = (wxPyApp *)new_wxPyApp();
21876
21877 wxPyEndAllowThreads(__tstate);
21878 if (PyErr_Occurred()) SWIG_fail;
21879 }
21880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
21881 return resultobj;
21882 fail:
21883 return NULL;
21884 }
21885
21886
21887 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21888 PyObject *resultobj;
21889 wxPyApp *arg1 = (wxPyApp *) 0 ;
21890 PyObject * obj0 = 0 ;
21891 char *kwnames[] = {
21892 (char *) "self", NULL
21893 };
21894
21895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
21896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21897 if (SWIG_arg_fail(1)) SWIG_fail;
21898 {
21899 PyThreadState* __tstate = wxPyBeginAllowThreads();
21900 delete arg1;
21901
21902 wxPyEndAllowThreads(__tstate);
21903 if (PyErr_Occurred()) SWIG_fail;
21904 }
21905 Py_INCREF(Py_None); resultobj = Py_None;
21906 return resultobj;
21907 fail:
21908 return NULL;
21909 }
21910
21911
21912 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
21913 PyObject *resultobj;
21914 wxPyApp *arg1 = (wxPyApp *) 0 ;
21915 PyObject *arg2 = (PyObject *) 0 ;
21916 PyObject *arg3 = (PyObject *) 0 ;
21917 PyObject * obj0 = 0 ;
21918 PyObject * obj1 = 0 ;
21919 PyObject * obj2 = 0 ;
21920 char *kwnames[] = {
21921 (char *) "self",(char *) "self",(char *) "_class", NULL
21922 };
21923
21924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21926 if (SWIG_arg_fail(1)) SWIG_fail;
21927 arg2 = obj1;
21928 arg3 = obj2;
21929 {
21930 PyThreadState* __tstate = wxPyBeginAllowThreads();
21931 (arg1)->_setCallbackInfo(arg2,arg3);
21932
21933 wxPyEndAllowThreads(__tstate);
21934 if (PyErr_Occurred()) SWIG_fail;
21935 }
21936 Py_INCREF(Py_None); resultobj = Py_None;
21937 return resultobj;
21938 fail:
21939 return NULL;
21940 }
21941
21942
21943 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21944 PyObject *resultobj;
21945 wxPyApp *arg1 = (wxPyApp *) 0 ;
21946 wxString result;
21947 PyObject * obj0 = 0 ;
21948 char *kwnames[] = {
21949 (char *) "self", NULL
21950 };
21951
21952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
21953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21954 if (SWIG_arg_fail(1)) SWIG_fail;
21955 {
21956 PyThreadState* __tstate = wxPyBeginAllowThreads();
21957 result = ((wxPyApp const *)arg1)->GetAppName();
21958
21959 wxPyEndAllowThreads(__tstate);
21960 if (PyErr_Occurred()) SWIG_fail;
21961 }
21962 {
21963 #if wxUSE_UNICODE
21964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21965 #else
21966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21967 #endif
21968 }
21969 return resultobj;
21970 fail:
21971 return NULL;
21972 }
21973
21974
21975 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21976 PyObject *resultobj;
21977 wxPyApp *arg1 = (wxPyApp *) 0 ;
21978 wxString *arg2 = 0 ;
21979 bool temp2 = false ;
21980 PyObject * obj0 = 0 ;
21981 PyObject * obj1 = 0 ;
21982 char *kwnames[] = {
21983 (char *) "self",(char *) "name", NULL
21984 };
21985
21986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
21987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21988 if (SWIG_arg_fail(1)) SWIG_fail;
21989 {
21990 arg2 = wxString_in_helper(obj1);
21991 if (arg2 == NULL) SWIG_fail;
21992 temp2 = true;
21993 }
21994 {
21995 PyThreadState* __tstate = wxPyBeginAllowThreads();
21996 (arg1)->SetAppName((wxString const &)*arg2);
21997
21998 wxPyEndAllowThreads(__tstate);
21999 if (PyErr_Occurred()) SWIG_fail;
22000 }
22001 Py_INCREF(Py_None); resultobj = Py_None;
22002 {
22003 if (temp2)
22004 delete arg2;
22005 }
22006 return resultobj;
22007 fail:
22008 {
22009 if (temp2)
22010 delete arg2;
22011 }
22012 return NULL;
22013 }
22014
22015
22016 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22017 PyObject *resultobj;
22018 wxPyApp *arg1 = (wxPyApp *) 0 ;
22019 wxString result;
22020 PyObject * obj0 = 0 ;
22021 char *kwnames[] = {
22022 (char *) "self", NULL
22023 };
22024
22025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22027 if (SWIG_arg_fail(1)) SWIG_fail;
22028 {
22029 PyThreadState* __tstate = wxPyBeginAllowThreads();
22030 result = ((wxPyApp const *)arg1)->GetClassName();
22031
22032 wxPyEndAllowThreads(__tstate);
22033 if (PyErr_Occurred()) SWIG_fail;
22034 }
22035 {
22036 #if wxUSE_UNICODE
22037 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22038 #else
22039 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22040 #endif
22041 }
22042 return resultobj;
22043 fail:
22044 return NULL;
22045 }
22046
22047
22048 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22049 PyObject *resultobj;
22050 wxPyApp *arg1 = (wxPyApp *) 0 ;
22051 wxString *arg2 = 0 ;
22052 bool temp2 = false ;
22053 PyObject * obj0 = 0 ;
22054 PyObject * obj1 = 0 ;
22055 char *kwnames[] = {
22056 (char *) "self",(char *) "name", NULL
22057 };
22058
22059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22061 if (SWIG_arg_fail(1)) SWIG_fail;
22062 {
22063 arg2 = wxString_in_helper(obj1);
22064 if (arg2 == NULL) SWIG_fail;
22065 temp2 = true;
22066 }
22067 {
22068 PyThreadState* __tstate = wxPyBeginAllowThreads();
22069 (arg1)->SetClassName((wxString const &)*arg2);
22070
22071 wxPyEndAllowThreads(__tstate);
22072 if (PyErr_Occurred()) SWIG_fail;
22073 }
22074 Py_INCREF(Py_None); resultobj = Py_None;
22075 {
22076 if (temp2)
22077 delete arg2;
22078 }
22079 return resultobj;
22080 fail:
22081 {
22082 if (temp2)
22083 delete arg2;
22084 }
22085 return NULL;
22086 }
22087
22088
22089 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22090 PyObject *resultobj;
22091 wxPyApp *arg1 = (wxPyApp *) 0 ;
22092 wxString *result;
22093 PyObject * obj0 = 0 ;
22094 char *kwnames[] = {
22095 (char *) "self", NULL
22096 };
22097
22098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22100 if (SWIG_arg_fail(1)) SWIG_fail;
22101 {
22102 PyThreadState* __tstate = wxPyBeginAllowThreads();
22103 {
22104 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22105 result = (wxString *) &_result_ref;
22106 }
22107
22108 wxPyEndAllowThreads(__tstate);
22109 if (PyErr_Occurred()) SWIG_fail;
22110 }
22111 {
22112 #if wxUSE_UNICODE
22113 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22114 #else
22115 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22116 #endif
22117 }
22118 return resultobj;
22119 fail:
22120 return NULL;
22121 }
22122
22123
22124 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22125 PyObject *resultobj;
22126 wxPyApp *arg1 = (wxPyApp *) 0 ;
22127 wxString *arg2 = 0 ;
22128 bool temp2 = false ;
22129 PyObject * obj0 = 0 ;
22130 PyObject * obj1 = 0 ;
22131 char *kwnames[] = {
22132 (char *) "self",(char *) "name", NULL
22133 };
22134
22135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22137 if (SWIG_arg_fail(1)) SWIG_fail;
22138 {
22139 arg2 = wxString_in_helper(obj1);
22140 if (arg2 == NULL) SWIG_fail;
22141 temp2 = true;
22142 }
22143 {
22144 PyThreadState* __tstate = wxPyBeginAllowThreads();
22145 (arg1)->SetVendorName((wxString const &)*arg2);
22146
22147 wxPyEndAllowThreads(__tstate);
22148 if (PyErr_Occurred()) SWIG_fail;
22149 }
22150 Py_INCREF(Py_None); resultobj = Py_None;
22151 {
22152 if (temp2)
22153 delete arg2;
22154 }
22155 return resultobj;
22156 fail:
22157 {
22158 if (temp2)
22159 delete arg2;
22160 }
22161 return NULL;
22162 }
22163
22164
22165 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22166 PyObject *resultobj;
22167 wxPyApp *arg1 = (wxPyApp *) 0 ;
22168 wxAppTraits *result;
22169 PyObject * obj0 = 0 ;
22170 char *kwnames[] = {
22171 (char *) "self", NULL
22172 };
22173
22174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22176 if (SWIG_arg_fail(1)) SWIG_fail;
22177 {
22178 PyThreadState* __tstate = wxPyBeginAllowThreads();
22179 result = (wxAppTraits *)(arg1)->GetTraits();
22180
22181 wxPyEndAllowThreads(__tstate);
22182 if (PyErr_Occurred()) SWIG_fail;
22183 }
22184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22185 return resultobj;
22186 fail:
22187 return NULL;
22188 }
22189
22190
22191 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22192 PyObject *resultobj;
22193 wxPyApp *arg1 = (wxPyApp *) 0 ;
22194 PyObject * obj0 = 0 ;
22195 char *kwnames[] = {
22196 (char *) "self", NULL
22197 };
22198
22199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22201 if (SWIG_arg_fail(1)) SWIG_fail;
22202 {
22203 PyThreadState* __tstate = wxPyBeginAllowThreads();
22204 (arg1)->ProcessPendingEvents();
22205
22206 wxPyEndAllowThreads(__tstate);
22207 if (PyErr_Occurred()) SWIG_fail;
22208 }
22209 Py_INCREF(Py_None); resultobj = Py_None;
22210 return resultobj;
22211 fail:
22212 return NULL;
22213 }
22214
22215
22216 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj;
22218 wxPyApp *arg1 = (wxPyApp *) 0 ;
22219 bool arg2 = (bool) false ;
22220 bool result;
22221 PyObject * obj0 = 0 ;
22222 PyObject * obj1 = 0 ;
22223 char *kwnames[] = {
22224 (char *) "self",(char *) "onlyIfNeeded", NULL
22225 };
22226
22227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22229 if (SWIG_arg_fail(1)) SWIG_fail;
22230 if (obj1) {
22231 {
22232 arg2 = (bool)(SWIG_As_bool(obj1));
22233 if (SWIG_arg_fail(2)) SWIG_fail;
22234 }
22235 }
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 result = (bool)(arg1)->Yield(arg2);
22239
22240 wxPyEndAllowThreads(__tstate);
22241 if (PyErr_Occurred()) SWIG_fail;
22242 }
22243 {
22244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22245 }
22246 return resultobj;
22247 fail:
22248 return NULL;
22249 }
22250
22251
22252 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22253 PyObject *resultobj;
22254 wxPyApp *arg1 = (wxPyApp *) 0 ;
22255 PyObject * obj0 = 0 ;
22256 char *kwnames[] = {
22257 (char *) "self", NULL
22258 };
22259
22260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22262 if (SWIG_arg_fail(1)) SWIG_fail;
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 (arg1)->WakeUpIdle();
22266
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 Py_INCREF(Py_None); resultobj = Py_None;
22271 return resultobj;
22272 fail:
22273 return NULL;
22274 }
22275
22276
22277 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22278 PyObject *resultobj;
22279 bool result;
22280 char *kwnames[] = {
22281 NULL
22282 };
22283
22284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22285 {
22286 PyThreadState* __tstate = wxPyBeginAllowThreads();
22287 result = (bool)wxPyApp::IsMainLoopRunning();
22288
22289 wxPyEndAllowThreads(__tstate);
22290 if (PyErr_Occurred()) SWIG_fail;
22291 }
22292 {
22293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22294 }
22295 return resultobj;
22296 fail:
22297 return NULL;
22298 }
22299
22300
22301 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22302 PyObject *resultobj;
22303 wxPyApp *arg1 = (wxPyApp *) 0 ;
22304 int result;
22305 PyObject * obj0 = 0 ;
22306 char *kwnames[] = {
22307 (char *) "self", NULL
22308 };
22309
22310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22312 if (SWIG_arg_fail(1)) SWIG_fail;
22313 {
22314 PyThreadState* __tstate = wxPyBeginAllowThreads();
22315 result = (int)(arg1)->MainLoop();
22316
22317 wxPyEndAllowThreads(__tstate);
22318 if (PyErr_Occurred()) SWIG_fail;
22319 }
22320 {
22321 resultobj = SWIG_From_int((int)(result));
22322 }
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22330 PyObject *resultobj;
22331 wxPyApp *arg1 = (wxPyApp *) 0 ;
22332 PyObject * obj0 = 0 ;
22333 char *kwnames[] = {
22334 (char *) "self", NULL
22335 };
22336
22337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22339 if (SWIG_arg_fail(1)) SWIG_fail;
22340 {
22341 PyThreadState* __tstate = wxPyBeginAllowThreads();
22342 (arg1)->Exit();
22343
22344 wxPyEndAllowThreads(__tstate);
22345 if (PyErr_Occurred()) SWIG_fail;
22346 }
22347 Py_INCREF(Py_None); resultobj = Py_None;
22348 return resultobj;
22349 fail:
22350 return NULL;
22351 }
22352
22353
22354 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22355 PyObject *resultobj;
22356 wxPyApp *arg1 = (wxPyApp *) 0 ;
22357 PyObject * obj0 = 0 ;
22358 char *kwnames[] = {
22359 (char *) "self", NULL
22360 };
22361
22362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22364 if (SWIG_arg_fail(1)) SWIG_fail;
22365 {
22366 PyThreadState* __tstate = wxPyBeginAllowThreads();
22367 (arg1)->ExitMainLoop();
22368
22369 wxPyEndAllowThreads(__tstate);
22370 if (PyErr_Occurred()) SWIG_fail;
22371 }
22372 Py_INCREF(Py_None); resultobj = Py_None;
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22380 PyObject *resultobj;
22381 wxPyApp *arg1 = (wxPyApp *) 0 ;
22382 bool result;
22383 PyObject * obj0 = 0 ;
22384 char *kwnames[] = {
22385 (char *) "self", NULL
22386 };
22387
22388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22390 if (SWIG_arg_fail(1)) SWIG_fail;
22391 {
22392 PyThreadState* __tstate = wxPyBeginAllowThreads();
22393 result = (bool)(arg1)->Pending();
22394
22395 wxPyEndAllowThreads(__tstate);
22396 if (PyErr_Occurred()) SWIG_fail;
22397 }
22398 {
22399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22400 }
22401 return resultobj;
22402 fail:
22403 return NULL;
22404 }
22405
22406
22407 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22408 PyObject *resultobj;
22409 wxPyApp *arg1 = (wxPyApp *) 0 ;
22410 bool result;
22411 PyObject * obj0 = 0 ;
22412 char *kwnames[] = {
22413 (char *) "self", NULL
22414 };
22415
22416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22418 if (SWIG_arg_fail(1)) SWIG_fail;
22419 {
22420 PyThreadState* __tstate = wxPyBeginAllowThreads();
22421 result = (bool)(arg1)->Dispatch();
22422
22423 wxPyEndAllowThreads(__tstate);
22424 if (PyErr_Occurred()) SWIG_fail;
22425 }
22426 {
22427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22428 }
22429 return resultobj;
22430 fail:
22431 return NULL;
22432 }
22433
22434
22435 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22436 PyObject *resultobj;
22437 wxPyApp *arg1 = (wxPyApp *) 0 ;
22438 bool result;
22439 PyObject * obj0 = 0 ;
22440 char *kwnames[] = {
22441 (char *) "self", NULL
22442 };
22443
22444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22446 if (SWIG_arg_fail(1)) SWIG_fail;
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 result = (bool)(arg1)->ProcessIdle();
22450
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 {
22455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22456 }
22457 return resultobj;
22458 fail:
22459 return NULL;
22460 }
22461
22462
22463 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22464 PyObject *resultobj;
22465 wxPyApp *arg1 = (wxPyApp *) 0 ;
22466 wxWindow *arg2 = (wxWindow *) 0 ;
22467 wxIdleEvent *arg3 = 0 ;
22468 bool result;
22469 PyObject * obj0 = 0 ;
22470 PyObject * obj1 = 0 ;
22471 PyObject * obj2 = 0 ;
22472 char *kwnames[] = {
22473 (char *) "self",(char *) "win",(char *) "event", NULL
22474 };
22475
22476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22478 if (SWIG_arg_fail(1)) SWIG_fail;
22479 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22480 if (SWIG_arg_fail(2)) SWIG_fail;
22481 {
22482 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22483 if (SWIG_arg_fail(3)) SWIG_fail;
22484 if (arg3 == NULL) {
22485 SWIG_null_ref("wxIdleEvent");
22486 }
22487 if (SWIG_arg_fail(3)) SWIG_fail;
22488 }
22489 {
22490 PyThreadState* __tstate = wxPyBeginAllowThreads();
22491 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22492
22493 wxPyEndAllowThreads(__tstate);
22494 if (PyErr_Occurred()) SWIG_fail;
22495 }
22496 {
22497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22498 }
22499 return resultobj;
22500 fail:
22501 return NULL;
22502 }
22503
22504
22505 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22506 PyObject *resultobj;
22507 wxPyApp *arg1 = (wxPyApp *) 0 ;
22508 bool result;
22509 PyObject * obj0 = 0 ;
22510 char *kwnames[] = {
22511 (char *) "self", NULL
22512 };
22513
22514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22516 if (SWIG_arg_fail(1)) SWIG_fail;
22517 {
22518 PyThreadState* __tstate = wxPyBeginAllowThreads();
22519 result = (bool)((wxPyApp const *)arg1)->IsActive();
22520
22521 wxPyEndAllowThreads(__tstate);
22522 if (PyErr_Occurred()) SWIG_fail;
22523 }
22524 {
22525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22526 }
22527 return resultobj;
22528 fail:
22529 return NULL;
22530 }
22531
22532
22533 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22534 PyObject *resultobj;
22535 wxPyApp *arg1 = (wxPyApp *) 0 ;
22536 wxWindow *arg2 = (wxWindow *) 0 ;
22537 PyObject * obj0 = 0 ;
22538 PyObject * obj1 = 0 ;
22539 char *kwnames[] = {
22540 (char *) "self",(char *) "win", NULL
22541 };
22542
22543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22545 if (SWIG_arg_fail(1)) SWIG_fail;
22546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22547 if (SWIG_arg_fail(2)) SWIG_fail;
22548 {
22549 PyThreadState* __tstate = wxPyBeginAllowThreads();
22550 (arg1)->SetTopWindow(arg2);
22551
22552 wxPyEndAllowThreads(__tstate);
22553 if (PyErr_Occurred()) SWIG_fail;
22554 }
22555 Py_INCREF(Py_None); resultobj = Py_None;
22556 return resultobj;
22557 fail:
22558 return NULL;
22559 }
22560
22561
22562 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22563 PyObject *resultobj;
22564 wxPyApp *arg1 = (wxPyApp *) 0 ;
22565 wxWindow *result;
22566 PyObject * obj0 = 0 ;
22567 char *kwnames[] = {
22568 (char *) "self", NULL
22569 };
22570
22571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22573 if (SWIG_arg_fail(1)) SWIG_fail;
22574 {
22575 PyThreadState* __tstate = wxPyBeginAllowThreads();
22576 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22577
22578 wxPyEndAllowThreads(__tstate);
22579 if (PyErr_Occurred()) SWIG_fail;
22580 }
22581 {
22582 resultobj = wxPyMake_wxObject(result, 0);
22583 }
22584 return resultobj;
22585 fail:
22586 return NULL;
22587 }
22588
22589
22590 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22591 PyObject *resultobj;
22592 wxPyApp *arg1 = (wxPyApp *) 0 ;
22593 bool arg2 ;
22594 PyObject * obj0 = 0 ;
22595 PyObject * obj1 = 0 ;
22596 char *kwnames[] = {
22597 (char *) "self",(char *) "flag", NULL
22598 };
22599
22600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22602 if (SWIG_arg_fail(1)) SWIG_fail;
22603 {
22604 arg2 = (bool)(SWIG_As_bool(obj1));
22605 if (SWIG_arg_fail(2)) SWIG_fail;
22606 }
22607 {
22608 PyThreadState* __tstate = wxPyBeginAllowThreads();
22609 (arg1)->SetExitOnFrameDelete(arg2);
22610
22611 wxPyEndAllowThreads(__tstate);
22612 if (PyErr_Occurred()) SWIG_fail;
22613 }
22614 Py_INCREF(Py_None); resultobj = Py_None;
22615 return resultobj;
22616 fail:
22617 return NULL;
22618 }
22619
22620
22621 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22622 PyObject *resultobj;
22623 wxPyApp *arg1 = (wxPyApp *) 0 ;
22624 bool result;
22625 PyObject * obj0 = 0 ;
22626 char *kwnames[] = {
22627 (char *) "self", NULL
22628 };
22629
22630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22632 if (SWIG_arg_fail(1)) SWIG_fail;
22633 {
22634 PyThreadState* __tstate = wxPyBeginAllowThreads();
22635 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22636
22637 wxPyEndAllowThreads(__tstate);
22638 if (PyErr_Occurred()) SWIG_fail;
22639 }
22640 {
22641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22642 }
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22650 PyObject *resultobj;
22651 wxPyApp *arg1 = (wxPyApp *) 0 ;
22652 bool arg2 ;
22653 PyObject * obj0 = 0 ;
22654 PyObject * obj1 = 0 ;
22655 char *kwnames[] = {
22656 (char *) "self",(char *) "flag", NULL
22657 };
22658
22659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22661 if (SWIG_arg_fail(1)) SWIG_fail;
22662 {
22663 arg2 = (bool)(SWIG_As_bool(obj1));
22664 if (SWIG_arg_fail(2)) SWIG_fail;
22665 }
22666 {
22667 PyThreadState* __tstate = wxPyBeginAllowThreads();
22668 (arg1)->SetUseBestVisual(arg2);
22669
22670 wxPyEndAllowThreads(__tstate);
22671 if (PyErr_Occurred()) SWIG_fail;
22672 }
22673 Py_INCREF(Py_None); resultobj = Py_None;
22674 return resultobj;
22675 fail:
22676 return NULL;
22677 }
22678
22679
22680 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22681 PyObject *resultobj;
22682 wxPyApp *arg1 = (wxPyApp *) 0 ;
22683 bool result;
22684 PyObject * obj0 = 0 ;
22685 char *kwnames[] = {
22686 (char *) "self", NULL
22687 };
22688
22689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22691 if (SWIG_arg_fail(1)) SWIG_fail;
22692 {
22693 PyThreadState* __tstate = wxPyBeginAllowThreads();
22694 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22695
22696 wxPyEndAllowThreads(__tstate);
22697 if (PyErr_Occurred()) SWIG_fail;
22698 }
22699 {
22700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22701 }
22702 return resultobj;
22703 fail:
22704 return NULL;
22705 }
22706
22707
22708 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22709 PyObject *resultobj;
22710 wxPyApp *arg1 = (wxPyApp *) 0 ;
22711 int arg2 ;
22712 PyObject * obj0 = 0 ;
22713 PyObject * obj1 = 0 ;
22714 char *kwnames[] = {
22715 (char *) "self",(char *) "mode", NULL
22716 };
22717
22718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22720 if (SWIG_arg_fail(1)) SWIG_fail;
22721 {
22722 arg2 = (int)(SWIG_As_int(obj1));
22723 if (SWIG_arg_fail(2)) SWIG_fail;
22724 }
22725 {
22726 PyThreadState* __tstate = wxPyBeginAllowThreads();
22727 (arg1)->SetPrintMode(arg2);
22728
22729 wxPyEndAllowThreads(__tstate);
22730 if (PyErr_Occurred()) SWIG_fail;
22731 }
22732 Py_INCREF(Py_None); resultobj = Py_None;
22733 return resultobj;
22734 fail:
22735 return NULL;
22736 }
22737
22738
22739 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22740 PyObject *resultobj;
22741 wxPyApp *arg1 = (wxPyApp *) 0 ;
22742 int result;
22743 PyObject * obj0 = 0 ;
22744 char *kwnames[] = {
22745 (char *) "self", NULL
22746 };
22747
22748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
22749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22750 if (SWIG_arg_fail(1)) SWIG_fail;
22751 {
22752 PyThreadState* __tstate = wxPyBeginAllowThreads();
22753 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
22754
22755 wxPyEndAllowThreads(__tstate);
22756 if (PyErr_Occurred()) SWIG_fail;
22757 }
22758 {
22759 resultobj = SWIG_From_int((int)(result));
22760 }
22761 return resultobj;
22762 fail:
22763 return NULL;
22764 }
22765
22766
22767 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22768 PyObject *resultobj;
22769 wxPyApp *arg1 = (wxPyApp *) 0 ;
22770 int arg2 ;
22771 PyObject * obj0 = 0 ;
22772 PyObject * obj1 = 0 ;
22773 char *kwnames[] = {
22774 (char *) "self",(char *) "mode", NULL
22775 };
22776
22777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
22778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22779 if (SWIG_arg_fail(1)) SWIG_fail;
22780 {
22781 arg2 = (int)(SWIG_As_int(obj1));
22782 if (SWIG_arg_fail(2)) SWIG_fail;
22783 }
22784 {
22785 PyThreadState* __tstate = wxPyBeginAllowThreads();
22786 (arg1)->SetAssertMode(arg2);
22787
22788 wxPyEndAllowThreads(__tstate);
22789 if (PyErr_Occurred()) SWIG_fail;
22790 }
22791 Py_INCREF(Py_None); resultobj = Py_None;
22792 return resultobj;
22793 fail:
22794 return NULL;
22795 }
22796
22797
22798 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22799 PyObject *resultobj;
22800 wxPyApp *arg1 = (wxPyApp *) 0 ;
22801 int result;
22802 PyObject * obj0 = 0 ;
22803 char *kwnames[] = {
22804 (char *) "self", NULL
22805 };
22806
22807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
22808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22809 if (SWIG_arg_fail(1)) SWIG_fail;
22810 {
22811 PyThreadState* __tstate = wxPyBeginAllowThreads();
22812 result = (int)(arg1)->GetAssertMode();
22813
22814 wxPyEndAllowThreads(__tstate);
22815 if (PyErr_Occurred()) SWIG_fail;
22816 }
22817 {
22818 resultobj = SWIG_From_int((int)(result));
22819 }
22820 return resultobj;
22821 fail:
22822 return NULL;
22823 }
22824
22825
22826 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22827 PyObject *resultobj;
22828 bool result;
22829 char *kwnames[] = {
22830 NULL
22831 };
22832
22833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
22834 {
22835 PyThreadState* __tstate = wxPyBeginAllowThreads();
22836 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
22837
22838 wxPyEndAllowThreads(__tstate);
22839 if (PyErr_Occurred()) SWIG_fail;
22840 }
22841 {
22842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22843 }
22844 return resultobj;
22845 fail:
22846 return NULL;
22847 }
22848
22849
22850 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22851 PyObject *resultobj;
22852 long result;
22853 char *kwnames[] = {
22854 NULL
22855 };
22856
22857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
22858 {
22859 PyThreadState* __tstate = wxPyBeginAllowThreads();
22860 result = (long)wxPyApp::GetMacAboutMenuItemId();
22861
22862 wxPyEndAllowThreads(__tstate);
22863 if (PyErr_Occurred()) SWIG_fail;
22864 }
22865 {
22866 resultobj = SWIG_From_long((long)(result));
22867 }
22868 return resultobj;
22869 fail:
22870 return NULL;
22871 }
22872
22873
22874 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22875 PyObject *resultobj;
22876 long result;
22877 char *kwnames[] = {
22878 NULL
22879 };
22880
22881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
22882 {
22883 PyThreadState* __tstate = wxPyBeginAllowThreads();
22884 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
22885
22886 wxPyEndAllowThreads(__tstate);
22887 if (PyErr_Occurred()) SWIG_fail;
22888 }
22889 {
22890 resultobj = SWIG_From_long((long)(result));
22891 }
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22899 PyObject *resultobj;
22900 long result;
22901 char *kwnames[] = {
22902 NULL
22903 };
22904
22905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
22906 {
22907 PyThreadState* __tstate = wxPyBeginAllowThreads();
22908 result = (long)wxPyApp::GetMacExitMenuItemId();
22909
22910 wxPyEndAllowThreads(__tstate);
22911 if (PyErr_Occurred()) SWIG_fail;
22912 }
22913 {
22914 resultobj = SWIG_From_long((long)(result));
22915 }
22916 return resultobj;
22917 fail:
22918 return NULL;
22919 }
22920
22921
22922 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
22923 PyObject *resultobj;
22924 wxString result;
22925 char *kwnames[] = {
22926 NULL
22927 };
22928
22929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
22930 {
22931 PyThreadState* __tstate = wxPyBeginAllowThreads();
22932 result = wxPyApp::GetMacHelpMenuTitleName();
22933
22934 wxPyEndAllowThreads(__tstate);
22935 if (PyErr_Occurred()) SWIG_fail;
22936 }
22937 {
22938 #if wxUSE_UNICODE
22939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22940 #else
22941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22942 #endif
22943 }
22944 return resultobj;
22945 fail:
22946 return NULL;
22947 }
22948
22949
22950 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22951 PyObject *resultobj;
22952 bool arg1 ;
22953 PyObject * obj0 = 0 ;
22954 char *kwnames[] = {
22955 (char *) "val", NULL
22956 };
22957
22958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
22959 {
22960 arg1 = (bool)(SWIG_As_bool(obj0));
22961 if (SWIG_arg_fail(1)) SWIG_fail;
22962 }
22963 {
22964 PyThreadState* __tstate = wxPyBeginAllowThreads();
22965 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
22966
22967 wxPyEndAllowThreads(__tstate);
22968 if (PyErr_Occurred()) SWIG_fail;
22969 }
22970 Py_INCREF(Py_None); resultobj = Py_None;
22971 return resultobj;
22972 fail:
22973 return NULL;
22974 }
22975
22976
22977 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22978 PyObject *resultobj;
22979 long arg1 ;
22980 PyObject * obj0 = 0 ;
22981 char *kwnames[] = {
22982 (char *) "val", NULL
22983 };
22984
22985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
22986 {
22987 arg1 = (long)(SWIG_As_long(obj0));
22988 if (SWIG_arg_fail(1)) SWIG_fail;
22989 }
22990 {
22991 PyThreadState* __tstate = wxPyBeginAllowThreads();
22992 wxPyApp::SetMacAboutMenuItemId(arg1);
22993
22994 wxPyEndAllowThreads(__tstate);
22995 if (PyErr_Occurred()) SWIG_fail;
22996 }
22997 Py_INCREF(Py_None); resultobj = Py_None;
22998 return resultobj;
22999 fail:
23000 return NULL;
23001 }
23002
23003
23004 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23005 PyObject *resultobj;
23006 long arg1 ;
23007 PyObject * obj0 = 0 ;
23008 char *kwnames[] = {
23009 (char *) "val", NULL
23010 };
23011
23012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23013 {
23014 arg1 = (long)(SWIG_As_long(obj0));
23015 if (SWIG_arg_fail(1)) SWIG_fail;
23016 }
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23020
23021 wxPyEndAllowThreads(__tstate);
23022 if (PyErr_Occurred()) SWIG_fail;
23023 }
23024 Py_INCREF(Py_None); resultobj = Py_None;
23025 return resultobj;
23026 fail:
23027 return NULL;
23028 }
23029
23030
23031 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23032 PyObject *resultobj;
23033 long arg1 ;
23034 PyObject * obj0 = 0 ;
23035 char *kwnames[] = {
23036 (char *) "val", NULL
23037 };
23038
23039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23040 {
23041 arg1 = (long)(SWIG_As_long(obj0));
23042 if (SWIG_arg_fail(1)) SWIG_fail;
23043 }
23044 {
23045 PyThreadState* __tstate = wxPyBeginAllowThreads();
23046 wxPyApp::SetMacExitMenuItemId(arg1);
23047
23048 wxPyEndAllowThreads(__tstate);
23049 if (PyErr_Occurred()) SWIG_fail;
23050 }
23051 Py_INCREF(Py_None); resultobj = Py_None;
23052 return resultobj;
23053 fail:
23054 return NULL;
23055 }
23056
23057
23058 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23059 PyObject *resultobj;
23060 wxString *arg1 = 0 ;
23061 bool temp1 = false ;
23062 PyObject * obj0 = 0 ;
23063 char *kwnames[] = {
23064 (char *) "val", NULL
23065 };
23066
23067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23068 {
23069 arg1 = wxString_in_helper(obj0);
23070 if (arg1 == NULL) SWIG_fail;
23071 temp1 = true;
23072 }
23073 {
23074 PyThreadState* __tstate = wxPyBeginAllowThreads();
23075 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23076
23077 wxPyEndAllowThreads(__tstate);
23078 if (PyErr_Occurred()) SWIG_fail;
23079 }
23080 Py_INCREF(Py_None); resultobj = Py_None;
23081 {
23082 if (temp1)
23083 delete arg1;
23084 }
23085 return resultobj;
23086 fail:
23087 {
23088 if (temp1)
23089 delete arg1;
23090 }
23091 return NULL;
23092 }
23093
23094
23095 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23096 PyObject *resultobj;
23097 wxPyApp *arg1 = (wxPyApp *) 0 ;
23098 PyObject * obj0 = 0 ;
23099 char *kwnames[] = {
23100 (char *) "self", NULL
23101 };
23102
23103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) 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 {
23107 PyThreadState* __tstate = wxPyBeginAllowThreads();
23108 (arg1)->_BootstrapApp();
23109
23110 wxPyEndAllowThreads(__tstate);
23111 if (PyErr_Occurred()) SWIG_fail;
23112 }
23113 Py_INCREF(Py_None); resultobj = Py_None;
23114 return resultobj;
23115 fail:
23116 return NULL;
23117 }
23118
23119
23120 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23121 PyObject *resultobj;
23122 int result;
23123 char *kwnames[] = {
23124 NULL
23125 };
23126
23127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23128 {
23129 PyThreadState* __tstate = wxPyBeginAllowThreads();
23130 result = (int)PyApp_GetComCtl32Version();
23131
23132 wxPyEndAllowThreads(__tstate);
23133 if (PyErr_Occurred()) SWIG_fail;
23134 }
23135 {
23136 resultobj = SWIG_From_int((int)(result));
23137 }
23138 return resultobj;
23139 fail:
23140 return NULL;
23141 }
23142
23143
23144 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23145 PyObject *obj;
23146 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23147 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23148 Py_INCREF(obj);
23149 return Py_BuildValue((char *)"");
23150 }
23151 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23152 PyObject *resultobj;
23153 char *kwnames[] = {
23154 NULL
23155 };
23156
23157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23158 {
23159 PyThreadState* __tstate = wxPyBeginAllowThreads();
23160 wxExit();
23161
23162 wxPyEndAllowThreads(__tstate);
23163 if (PyErr_Occurred()) SWIG_fail;
23164 }
23165 Py_INCREF(Py_None); resultobj = Py_None;
23166 return resultobj;
23167 fail:
23168 return NULL;
23169 }
23170
23171
23172 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23173 PyObject *resultobj;
23174 bool result;
23175 char *kwnames[] = {
23176 NULL
23177 };
23178
23179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23180 {
23181 PyThreadState* __tstate = wxPyBeginAllowThreads();
23182 result = (bool)wxYield();
23183
23184 wxPyEndAllowThreads(__tstate);
23185 if (PyErr_Occurred()) SWIG_fail;
23186 }
23187 {
23188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23189 }
23190 return resultobj;
23191 fail:
23192 return NULL;
23193 }
23194
23195
23196 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23197 PyObject *resultobj;
23198 bool result;
23199 char *kwnames[] = {
23200 NULL
23201 };
23202
23203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23204 {
23205 PyThreadState* __tstate = wxPyBeginAllowThreads();
23206 result = (bool)wxYieldIfNeeded();
23207
23208 wxPyEndAllowThreads(__tstate);
23209 if (PyErr_Occurred()) SWIG_fail;
23210 }
23211 {
23212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23213 }
23214 return resultobj;
23215 fail:
23216 return NULL;
23217 }
23218
23219
23220 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23221 PyObject *resultobj;
23222 wxWindow *arg1 = (wxWindow *) NULL ;
23223 bool arg2 = (bool) false ;
23224 bool result;
23225 PyObject * obj0 = 0 ;
23226 PyObject * obj1 = 0 ;
23227 char *kwnames[] = {
23228 (char *) "win",(char *) "onlyIfNeeded", NULL
23229 };
23230
23231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23232 if (obj0) {
23233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23234 if (SWIG_arg_fail(1)) SWIG_fail;
23235 }
23236 if (obj1) {
23237 {
23238 arg2 = (bool)(SWIG_As_bool(obj1));
23239 if (SWIG_arg_fail(2)) SWIG_fail;
23240 }
23241 }
23242 {
23243 PyThreadState* __tstate = wxPyBeginAllowThreads();
23244 result = (bool)wxSafeYield(arg1,arg2);
23245
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 {
23250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23251 }
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23259 PyObject *resultobj;
23260 char *kwnames[] = {
23261 NULL
23262 };
23263
23264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23265 {
23266 PyThreadState* __tstate = wxPyBeginAllowThreads();
23267 wxWakeUpIdle();
23268
23269 wxPyEndAllowThreads(__tstate);
23270 if (PyErr_Occurred()) SWIG_fail;
23271 }
23272 Py_INCREF(Py_None); resultobj = Py_None;
23273 return resultobj;
23274 fail:
23275 return NULL;
23276 }
23277
23278
23279 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23280 PyObject *resultobj;
23281 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23282 wxEvent *arg2 = 0 ;
23283 PyObject * obj0 = 0 ;
23284 PyObject * obj1 = 0 ;
23285 char *kwnames[] = {
23286 (char *) "dest",(char *) "event", NULL
23287 };
23288
23289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23291 if (SWIG_arg_fail(1)) SWIG_fail;
23292 {
23293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23294 if (SWIG_arg_fail(2)) SWIG_fail;
23295 if (arg2 == NULL) {
23296 SWIG_null_ref("wxEvent");
23297 }
23298 if (SWIG_arg_fail(2)) SWIG_fail;
23299 }
23300 {
23301 PyThreadState* __tstate = wxPyBeginAllowThreads();
23302 wxPostEvent(arg1,*arg2);
23303
23304 wxPyEndAllowThreads(__tstate);
23305 if (PyErr_Occurred()) SWIG_fail;
23306 }
23307 Py_INCREF(Py_None); resultobj = Py_None;
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23315 PyObject *resultobj;
23316 char *kwnames[] = {
23317 NULL
23318 };
23319
23320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 wxApp_CleanUp();
23324
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 Py_INCREF(Py_None); resultobj = Py_None;
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23336 PyObject *resultobj;
23337 wxPyApp *result;
23338 char *kwnames[] = {
23339 NULL
23340 };
23341
23342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23343 {
23344 PyThreadState* __tstate = wxPyBeginAllowThreads();
23345 result = (wxPyApp *)wxPyGetApp();
23346
23347 wxPyEndAllowThreads(__tstate);
23348 if (PyErr_Occurred()) SWIG_fail;
23349 }
23350 {
23351 resultobj = wxPyMake_wxObject(result, 0);
23352 }
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj;
23361 char *arg1 = (char *) 0 ;
23362 PyObject * obj0 = 0 ;
23363 char *kwnames[] = {
23364 (char *) "encoding", NULL
23365 };
23366
23367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23368 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23369 SWIG_arg_fail(1);SWIG_fail;
23370 }
23371 {
23372 PyThreadState* __tstate = wxPyBeginAllowThreads();
23373 wxSetDefaultPyEncoding((char const *)arg1);
23374
23375 wxPyEndAllowThreads(__tstate);
23376 if (PyErr_Occurred()) SWIG_fail;
23377 }
23378 Py_INCREF(Py_None); resultobj = Py_None;
23379 return resultobj;
23380 fail:
23381 return NULL;
23382 }
23383
23384
23385 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23386 PyObject *resultobj;
23387 char *result;
23388 char *kwnames[] = {
23389 NULL
23390 };
23391
23392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23393 {
23394 PyThreadState* __tstate = wxPyBeginAllowThreads();
23395 result = (char *)wxGetDefaultPyEncoding();
23396
23397 wxPyEndAllowThreads(__tstate);
23398 if (PyErr_Occurred()) SWIG_fail;
23399 }
23400 resultobj = SWIG_FromCharPtr(result);
23401 return resultobj;
23402 fail:
23403 return NULL;
23404 }
23405
23406
23407 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23408 PyObject *resultobj;
23409 wxEventLoop *result;
23410 char *kwnames[] = {
23411 NULL
23412 };
23413
23414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23415 {
23416 PyThreadState* __tstate = wxPyBeginAllowThreads();
23417 result = (wxEventLoop *)new wxEventLoop();
23418
23419 wxPyEndAllowThreads(__tstate);
23420 if (PyErr_Occurred()) SWIG_fail;
23421 }
23422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23423 return resultobj;
23424 fail:
23425 return NULL;
23426 }
23427
23428
23429 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23430 PyObject *resultobj;
23431 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23432 PyObject * obj0 = 0 ;
23433 char *kwnames[] = {
23434 (char *) "self", NULL
23435 };
23436
23437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23439 if (SWIG_arg_fail(1)) SWIG_fail;
23440 {
23441 PyThreadState* __tstate = wxPyBeginAllowThreads();
23442 delete arg1;
23443
23444 wxPyEndAllowThreads(__tstate);
23445 if (PyErr_Occurred()) SWIG_fail;
23446 }
23447 Py_INCREF(Py_None); resultobj = Py_None;
23448 return resultobj;
23449 fail:
23450 return NULL;
23451 }
23452
23453
23454 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23455 PyObject *resultobj;
23456 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23457 int result;
23458 PyObject * obj0 = 0 ;
23459 char *kwnames[] = {
23460 (char *) "self", NULL
23461 };
23462
23463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23465 if (SWIG_arg_fail(1)) SWIG_fail;
23466 {
23467 PyThreadState* __tstate = wxPyBeginAllowThreads();
23468 result = (int)(arg1)->Run();
23469
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 {
23474 resultobj = SWIG_From_int((int)(result));
23475 }
23476 return resultobj;
23477 fail:
23478 return NULL;
23479 }
23480
23481
23482 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23483 PyObject *resultobj;
23484 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23485 int arg2 = (int) 0 ;
23486 PyObject * obj0 = 0 ;
23487 PyObject * obj1 = 0 ;
23488 char *kwnames[] = {
23489 (char *) "self",(char *) "rc", NULL
23490 };
23491
23492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23494 if (SWIG_arg_fail(1)) SWIG_fail;
23495 if (obj1) {
23496 {
23497 arg2 = (int)(SWIG_As_int(obj1));
23498 if (SWIG_arg_fail(2)) SWIG_fail;
23499 }
23500 }
23501 {
23502 PyThreadState* __tstate = wxPyBeginAllowThreads();
23503 (arg1)->Exit(arg2);
23504
23505 wxPyEndAllowThreads(__tstate);
23506 if (PyErr_Occurred()) SWIG_fail;
23507 }
23508 Py_INCREF(Py_None); resultobj = Py_None;
23509 return resultobj;
23510 fail:
23511 return NULL;
23512 }
23513
23514
23515 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23516 PyObject *resultobj;
23517 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23518 bool result;
23519 PyObject * obj0 = 0 ;
23520 char *kwnames[] = {
23521 (char *) "self", NULL
23522 };
23523
23524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23526 if (SWIG_arg_fail(1)) SWIG_fail;
23527 {
23528 PyThreadState* __tstate = wxPyBeginAllowThreads();
23529 result = (bool)((wxEventLoop const *)arg1)->Pending();
23530
23531 wxPyEndAllowThreads(__tstate);
23532 if (PyErr_Occurred()) SWIG_fail;
23533 }
23534 {
23535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23536 }
23537 return resultobj;
23538 fail:
23539 return NULL;
23540 }
23541
23542
23543 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23544 PyObject *resultobj;
23545 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23546 bool result;
23547 PyObject * obj0 = 0 ;
23548 char *kwnames[] = {
23549 (char *) "self", NULL
23550 };
23551
23552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23554 if (SWIG_arg_fail(1)) SWIG_fail;
23555 {
23556 PyThreadState* __tstate = wxPyBeginAllowThreads();
23557 result = (bool)(arg1)->Dispatch();
23558
23559 wxPyEndAllowThreads(__tstate);
23560 if (PyErr_Occurred()) SWIG_fail;
23561 }
23562 {
23563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23564 }
23565 return resultobj;
23566 fail:
23567 return NULL;
23568 }
23569
23570
23571 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23572 PyObject *resultobj;
23573 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23574 bool result;
23575 PyObject * obj0 = 0 ;
23576 char *kwnames[] = {
23577 (char *) "self", NULL
23578 };
23579
23580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23582 if (SWIG_arg_fail(1)) SWIG_fail;
23583 {
23584 PyThreadState* __tstate = wxPyBeginAllowThreads();
23585 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23586
23587 wxPyEndAllowThreads(__tstate);
23588 if (PyErr_Occurred()) SWIG_fail;
23589 }
23590 {
23591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23592 }
23593 return resultobj;
23594 fail:
23595 return NULL;
23596 }
23597
23598
23599 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23600 PyObject *resultobj;
23601 wxEventLoop *result;
23602 char *kwnames[] = {
23603 NULL
23604 };
23605
23606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23607 {
23608 PyThreadState* __tstate = wxPyBeginAllowThreads();
23609 result = (wxEventLoop *)wxEventLoop::GetActive();
23610
23611 wxPyEndAllowThreads(__tstate);
23612 if (PyErr_Occurred()) SWIG_fail;
23613 }
23614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23615 return resultobj;
23616 fail:
23617 return NULL;
23618 }
23619
23620
23621 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23622 PyObject *resultobj;
23623 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23624 PyObject * obj0 = 0 ;
23625 char *kwnames[] = {
23626 (char *) "loop", NULL
23627 };
23628
23629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23631 if (SWIG_arg_fail(1)) SWIG_fail;
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 wxEventLoop::SetActive(arg1);
23635
23636 wxPyEndAllowThreads(__tstate);
23637 if (PyErr_Occurred()) SWIG_fail;
23638 }
23639 Py_INCREF(Py_None); resultobj = Py_None;
23640 return resultobj;
23641 fail:
23642 return NULL;
23643 }
23644
23645
23646 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23647 PyObject *obj;
23648 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23649 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23650 Py_INCREF(obj);
23651 return Py_BuildValue((char *)"");
23652 }
23653 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23654 PyObject *resultobj;
23655 int arg1 = (int) 0 ;
23656 int arg2 = (int) 0 ;
23657 int arg3 = (int) 0 ;
23658 wxAcceleratorEntry *result;
23659 PyObject * obj0 = 0 ;
23660 PyObject * obj1 = 0 ;
23661 PyObject * obj2 = 0 ;
23662 char *kwnames[] = {
23663 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23664 };
23665
23666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23667 if (obj0) {
23668 {
23669 arg1 = (int)(SWIG_As_int(obj0));
23670 if (SWIG_arg_fail(1)) SWIG_fail;
23671 }
23672 }
23673 if (obj1) {
23674 {
23675 arg2 = (int)(SWIG_As_int(obj1));
23676 if (SWIG_arg_fail(2)) SWIG_fail;
23677 }
23678 }
23679 if (obj2) {
23680 {
23681 arg3 = (int)(SWIG_As_int(obj2));
23682 if (SWIG_arg_fail(3)) SWIG_fail;
23683 }
23684 }
23685 {
23686 PyThreadState* __tstate = wxPyBeginAllowThreads();
23687 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23688
23689 wxPyEndAllowThreads(__tstate);
23690 if (PyErr_Occurred()) SWIG_fail;
23691 }
23692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23693 return resultobj;
23694 fail:
23695 return NULL;
23696 }
23697
23698
23699 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23700 PyObject *resultobj;
23701 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23702 PyObject * obj0 = 0 ;
23703 char *kwnames[] = {
23704 (char *) "self", NULL
23705 };
23706
23707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23709 if (SWIG_arg_fail(1)) SWIG_fail;
23710 {
23711 PyThreadState* __tstate = wxPyBeginAllowThreads();
23712 delete arg1;
23713
23714 wxPyEndAllowThreads(__tstate);
23715 if (PyErr_Occurred()) SWIG_fail;
23716 }
23717 Py_INCREF(Py_None); resultobj = Py_None;
23718 return resultobj;
23719 fail:
23720 return NULL;
23721 }
23722
23723
23724 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23725 PyObject *resultobj;
23726 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23727 int arg2 ;
23728 int arg3 ;
23729 int arg4 ;
23730 PyObject * obj0 = 0 ;
23731 PyObject * obj1 = 0 ;
23732 PyObject * obj2 = 0 ;
23733 PyObject * obj3 = 0 ;
23734 char *kwnames[] = {
23735 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23736 };
23737
23738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23740 if (SWIG_arg_fail(1)) SWIG_fail;
23741 {
23742 arg2 = (int)(SWIG_As_int(obj1));
23743 if (SWIG_arg_fail(2)) SWIG_fail;
23744 }
23745 {
23746 arg3 = (int)(SWIG_As_int(obj2));
23747 if (SWIG_arg_fail(3)) SWIG_fail;
23748 }
23749 {
23750 arg4 = (int)(SWIG_As_int(obj3));
23751 if (SWIG_arg_fail(4)) SWIG_fail;
23752 }
23753 {
23754 PyThreadState* __tstate = wxPyBeginAllowThreads();
23755 (arg1)->Set(arg2,arg3,arg4);
23756
23757 wxPyEndAllowThreads(__tstate);
23758 if (PyErr_Occurred()) SWIG_fail;
23759 }
23760 Py_INCREF(Py_None); resultobj = Py_None;
23761 return resultobj;
23762 fail:
23763 return NULL;
23764 }
23765
23766
23767 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
23768 PyObject *resultobj;
23769 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23770 int result;
23771 PyObject * obj0 = 0 ;
23772 char *kwnames[] = {
23773 (char *) "self", NULL
23774 };
23775
23776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
23777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23778 if (SWIG_arg_fail(1)) SWIG_fail;
23779 {
23780 PyThreadState* __tstate = wxPyBeginAllowThreads();
23781 result = (int)(arg1)->GetFlags();
23782
23783 wxPyEndAllowThreads(__tstate);
23784 if (PyErr_Occurred()) SWIG_fail;
23785 }
23786 {
23787 resultobj = SWIG_From_int((int)(result));
23788 }
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
23796 PyObject *resultobj;
23797 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23798 int result;
23799 PyObject * obj0 = 0 ;
23800 char *kwnames[] = {
23801 (char *) "self", NULL
23802 };
23803
23804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
23805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23806 if (SWIG_arg_fail(1)) SWIG_fail;
23807 {
23808 PyThreadState* __tstate = wxPyBeginAllowThreads();
23809 result = (int)(arg1)->GetKeyCode();
23810
23811 wxPyEndAllowThreads(__tstate);
23812 if (PyErr_Occurred()) SWIG_fail;
23813 }
23814 {
23815 resultobj = SWIG_From_int((int)(result));
23816 }
23817 return resultobj;
23818 fail:
23819 return NULL;
23820 }
23821
23822
23823 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
23824 PyObject *resultobj;
23825 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23826 int result;
23827 PyObject * obj0 = 0 ;
23828 char *kwnames[] = {
23829 (char *) "self", NULL
23830 };
23831
23832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
23833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23834 if (SWIG_arg_fail(1)) SWIG_fail;
23835 {
23836 PyThreadState* __tstate = wxPyBeginAllowThreads();
23837 result = (int)(arg1)->GetCommand();
23838
23839 wxPyEndAllowThreads(__tstate);
23840 if (PyErr_Occurred()) SWIG_fail;
23841 }
23842 {
23843 resultobj = SWIG_From_int((int)(result));
23844 }
23845 return resultobj;
23846 fail:
23847 return NULL;
23848 }
23849
23850
23851 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
23852 PyObject *obj;
23853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23854 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
23855 Py_INCREF(obj);
23856 return Py_BuildValue((char *)"");
23857 }
23858 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23859 PyObject *resultobj;
23860 int arg1 ;
23861 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
23862 wxAcceleratorTable *result;
23863 PyObject * obj0 = 0 ;
23864 char *kwnames[] = {
23865 (char *) "n", NULL
23866 };
23867
23868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
23869 {
23870 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
23871 if (arg2) arg1 = PyList_Size(obj0);
23872 else arg1 = 0;
23873 }
23874 {
23875 PyThreadState* __tstate = wxPyBeginAllowThreads();
23876 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
23877
23878 wxPyEndAllowThreads(__tstate);
23879 if (PyErr_Occurred()) SWIG_fail;
23880 }
23881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
23882 {
23883 delete [] arg2;
23884 }
23885 return resultobj;
23886 fail:
23887 {
23888 delete [] arg2;
23889 }
23890 return NULL;
23891 }
23892
23893
23894 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj;
23896 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23897 PyObject * obj0 = 0 ;
23898 char *kwnames[] = {
23899 (char *) "self", NULL
23900 };
23901
23902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
23903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23904 if (SWIG_arg_fail(1)) SWIG_fail;
23905 {
23906 PyThreadState* __tstate = wxPyBeginAllowThreads();
23907 delete arg1;
23908
23909 wxPyEndAllowThreads(__tstate);
23910 if (PyErr_Occurred()) SWIG_fail;
23911 }
23912 Py_INCREF(Py_None); resultobj = Py_None;
23913 return resultobj;
23914 fail:
23915 return NULL;
23916 }
23917
23918
23919 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
23920 PyObject *resultobj;
23921 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23922 bool result;
23923 PyObject * obj0 = 0 ;
23924 char *kwnames[] = {
23925 (char *) "self", NULL
23926 };
23927
23928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
23929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23930 if (SWIG_arg_fail(1)) SWIG_fail;
23931 {
23932 PyThreadState* __tstate = wxPyBeginAllowThreads();
23933 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
23934
23935 wxPyEndAllowThreads(__tstate);
23936 if (PyErr_Occurred()) SWIG_fail;
23937 }
23938 {
23939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23940 }
23941 return resultobj;
23942 fail:
23943 return NULL;
23944 }
23945
23946
23947 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
23948 PyObject *obj;
23949 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23950 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
23951 Py_INCREF(obj);
23952 return Py_BuildValue((char *)"");
23953 }
23954 static int _wrap_NullAcceleratorTable_set(PyObject *) {
23955 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
23956 return 1;
23957 }
23958
23959
23960 static PyObject *_wrap_NullAcceleratorTable_get(void) {
23961 PyObject *pyobj;
23962
23963 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
23964 return pyobj;
23965 }
23966
23967
23968 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
23969 PyObject *resultobj;
23970 wxString *arg1 = 0 ;
23971 wxAcceleratorEntry *result;
23972 bool temp1 = false ;
23973 PyObject * obj0 = 0 ;
23974 char *kwnames[] = {
23975 (char *) "label", NULL
23976 };
23977
23978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
23979 {
23980 arg1 = wxString_in_helper(obj0);
23981 if (arg1 == NULL) SWIG_fail;
23982 temp1 = true;
23983 }
23984 {
23985 PyThreadState* __tstate = wxPyBeginAllowThreads();
23986 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
23987
23988 wxPyEndAllowThreads(__tstate);
23989 if (PyErr_Occurred()) SWIG_fail;
23990 }
23991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
23992 {
23993 if (temp1)
23994 delete arg1;
23995 }
23996 return resultobj;
23997 fail:
23998 {
23999 if (temp1)
24000 delete arg1;
24001 }
24002 return NULL;
24003 }
24004
24005
24006 static int _wrap_PanelNameStr_set(PyObject *) {
24007 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24008 return 1;
24009 }
24010
24011
24012 static PyObject *_wrap_PanelNameStr_get(void) {
24013 PyObject *pyobj;
24014
24015 {
24016 #if wxUSE_UNICODE
24017 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24018 #else
24019 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24020 #endif
24021 }
24022 return pyobj;
24023 }
24024
24025
24026 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24027 PyObject *resultobj;
24028 wxVisualAttributes *result;
24029 char *kwnames[] = {
24030 NULL
24031 };
24032
24033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 result = (wxVisualAttributes *)new_wxVisualAttributes();
24037
24038 wxPyEndAllowThreads(__tstate);
24039 if (PyErr_Occurred()) SWIG_fail;
24040 }
24041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24042 return resultobj;
24043 fail:
24044 return NULL;
24045 }
24046
24047
24048 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24049 PyObject *resultobj;
24050 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24051 PyObject * obj0 = 0 ;
24052 char *kwnames[] = {
24053 (char *) "self", NULL
24054 };
24055
24056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24058 if (SWIG_arg_fail(1)) SWIG_fail;
24059 {
24060 PyThreadState* __tstate = wxPyBeginAllowThreads();
24061 delete_wxVisualAttributes(arg1);
24062
24063 wxPyEndAllowThreads(__tstate);
24064 if (PyErr_Occurred()) SWIG_fail;
24065 }
24066 Py_INCREF(Py_None); resultobj = Py_None;
24067 return resultobj;
24068 fail:
24069 return NULL;
24070 }
24071
24072
24073 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24074 PyObject *resultobj;
24075 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24076 wxFont *arg2 = (wxFont *) 0 ;
24077 PyObject * obj0 = 0 ;
24078 PyObject * obj1 = 0 ;
24079 char *kwnames[] = {
24080 (char *) "self",(char *) "font", NULL
24081 };
24082
24083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24085 if (SWIG_arg_fail(1)) SWIG_fail;
24086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24087 if (SWIG_arg_fail(2)) SWIG_fail;
24088 if (arg1) (arg1)->font = *arg2;
24089
24090 Py_INCREF(Py_None); resultobj = Py_None;
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24098 PyObject *resultobj;
24099 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24100 wxFont *result;
24101 PyObject * obj0 = 0 ;
24102 char *kwnames[] = {
24103 (char *) "self", NULL
24104 };
24105
24106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24108 if (SWIG_arg_fail(1)) SWIG_fail;
24109 result = (wxFont *)& ((arg1)->font);
24110
24111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24112 return resultobj;
24113 fail:
24114 return NULL;
24115 }
24116
24117
24118 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24119 PyObject *resultobj;
24120 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24121 wxColour *arg2 = (wxColour *) 0 ;
24122 PyObject * obj0 = 0 ;
24123 PyObject * obj1 = 0 ;
24124 char *kwnames[] = {
24125 (char *) "self",(char *) "colFg", NULL
24126 };
24127
24128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24130 if (SWIG_arg_fail(1)) SWIG_fail;
24131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24132 if (SWIG_arg_fail(2)) SWIG_fail;
24133 if (arg1) (arg1)->colFg = *arg2;
24134
24135 Py_INCREF(Py_None); resultobj = Py_None;
24136 return resultobj;
24137 fail:
24138 return NULL;
24139 }
24140
24141
24142 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24143 PyObject *resultobj;
24144 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24145 wxColour *result;
24146 PyObject * obj0 = 0 ;
24147 char *kwnames[] = {
24148 (char *) "self", NULL
24149 };
24150
24151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24153 if (SWIG_arg_fail(1)) SWIG_fail;
24154 result = (wxColour *)& ((arg1)->colFg);
24155
24156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24157 return resultobj;
24158 fail:
24159 return NULL;
24160 }
24161
24162
24163 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24164 PyObject *resultobj;
24165 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24166 wxColour *arg2 = (wxColour *) 0 ;
24167 PyObject * obj0 = 0 ;
24168 PyObject * obj1 = 0 ;
24169 char *kwnames[] = {
24170 (char *) "self",(char *) "colBg", NULL
24171 };
24172
24173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24175 if (SWIG_arg_fail(1)) SWIG_fail;
24176 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24177 if (SWIG_arg_fail(2)) SWIG_fail;
24178 if (arg1) (arg1)->colBg = *arg2;
24179
24180 Py_INCREF(Py_None); resultobj = Py_None;
24181 return resultobj;
24182 fail:
24183 return NULL;
24184 }
24185
24186
24187 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24188 PyObject *resultobj;
24189 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24190 wxColour *result;
24191 PyObject * obj0 = 0 ;
24192 char *kwnames[] = {
24193 (char *) "self", NULL
24194 };
24195
24196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24198 if (SWIG_arg_fail(1)) SWIG_fail;
24199 result = (wxColour *)& ((arg1)->colBg);
24200
24201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24202 return resultobj;
24203 fail:
24204 return NULL;
24205 }
24206
24207
24208 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24209 PyObject *obj;
24210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24211 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24212 Py_INCREF(obj);
24213 return Py_BuildValue((char *)"");
24214 }
24215 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24216 PyObject *resultobj;
24217 wxWindow *arg1 = (wxWindow *) 0 ;
24218 int arg2 = (int) (int)-1 ;
24219 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24220 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24221 wxSize const &arg4_defvalue = wxDefaultSize ;
24222 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24223 long arg5 = (long) 0 ;
24224 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24225 wxString *arg6 = (wxString *) &arg6_defvalue ;
24226 wxWindow *result;
24227 wxPoint temp3 ;
24228 wxSize temp4 ;
24229 bool temp6 = false ;
24230 PyObject * obj0 = 0 ;
24231 PyObject * obj1 = 0 ;
24232 PyObject * obj2 = 0 ;
24233 PyObject * obj3 = 0 ;
24234 PyObject * obj4 = 0 ;
24235 PyObject * obj5 = 0 ;
24236 char *kwnames[] = {
24237 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24238 };
24239
24240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24242 if (SWIG_arg_fail(1)) SWIG_fail;
24243 if (obj1) {
24244 {
24245 arg2 = (int const)(SWIG_As_int(obj1));
24246 if (SWIG_arg_fail(2)) SWIG_fail;
24247 }
24248 }
24249 if (obj2) {
24250 {
24251 arg3 = &temp3;
24252 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24253 }
24254 }
24255 if (obj3) {
24256 {
24257 arg4 = &temp4;
24258 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24259 }
24260 }
24261 if (obj4) {
24262 {
24263 arg5 = (long)(SWIG_As_long(obj4));
24264 if (SWIG_arg_fail(5)) SWIG_fail;
24265 }
24266 }
24267 if (obj5) {
24268 {
24269 arg6 = wxString_in_helper(obj5);
24270 if (arg6 == NULL) SWIG_fail;
24271 temp6 = true;
24272 }
24273 }
24274 {
24275 if (!wxPyCheckForApp()) SWIG_fail;
24276 PyThreadState* __tstate = wxPyBeginAllowThreads();
24277 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24278
24279 wxPyEndAllowThreads(__tstate);
24280 if (PyErr_Occurred()) SWIG_fail;
24281 }
24282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24283 {
24284 if (temp6)
24285 delete arg6;
24286 }
24287 return resultobj;
24288 fail:
24289 {
24290 if (temp6)
24291 delete arg6;
24292 }
24293 return NULL;
24294 }
24295
24296
24297 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24298 PyObject *resultobj;
24299 wxWindow *result;
24300 char *kwnames[] = {
24301 NULL
24302 };
24303
24304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24305 {
24306 if (!wxPyCheckForApp()) SWIG_fail;
24307 PyThreadState* __tstate = wxPyBeginAllowThreads();
24308 result = (wxWindow *)new wxWindow();
24309
24310 wxPyEndAllowThreads(__tstate);
24311 if (PyErr_Occurred()) SWIG_fail;
24312 }
24313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24314 return resultobj;
24315 fail:
24316 return NULL;
24317 }
24318
24319
24320 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24321 PyObject *resultobj;
24322 wxWindow *arg1 = (wxWindow *) 0 ;
24323 wxWindow *arg2 = (wxWindow *) 0 ;
24324 int arg3 = (int) (int)-1 ;
24325 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24326 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24327 wxSize const &arg5_defvalue = wxDefaultSize ;
24328 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24329 long arg6 = (long) 0 ;
24330 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24331 wxString *arg7 = (wxString *) &arg7_defvalue ;
24332 bool result;
24333 wxPoint temp4 ;
24334 wxSize temp5 ;
24335 bool temp7 = false ;
24336 PyObject * obj0 = 0 ;
24337 PyObject * obj1 = 0 ;
24338 PyObject * obj2 = 0 ;
24339 PyObject * obj3 = 0 ;
24340 PyObject * obj4 = 0 ;
24341 PyObject * obj5 = 0 ;
24342 PyObject * obj6 = 0 ;
24343 char *kwnames[] = {
24344 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24345 };
24346
24347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24349 if (SWIG_arg_fail(1)) SWIG_fail;
24350 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24351 if (SWIG_arg_fail(2)) SWIG_fail;
24352 if (obj2) {
24353 {
24354 arg3 = (int const)(SWIG_As_int(obj2));
24355 if (SWIG_arg_fail(3)) SWIG_fail;
24356 }
24357 }
24358 if (obj3) {
24359 {
24360 arg4 = &temp4;
24361 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24362 }
24363 }
24364 if (obj4) {
24365 {
24366 arg5 = &temp5;
24367 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24368 }
24369 }
24370 if (obj5) {
24371 {
24372 arg6 = (long)(SWIG_As_long(obj5));
24373 if (SWIG_arg_fail(6)) SWIG_fail;
24374 }
24375 }
24376 if (obj6) {
24377 {
24378 arg7 = wxString_in_helper(obj6);
24379 if (arg7 == NULL) SWIG_fail;
24380 temp7 = true;
24381 }
24382 }
24383 {
24384 PyThreadState* __tstate = wxPyBeginAllowThreads();
24385 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24386
24387 wxPyEndAllowThreads(__tstate);
24388 if (PyErr_Occurred()) SWIG_fail;
24389 }
24390 {
24391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24392 }
24393 {
24394 if (temp7)
24395 delete arg7;
24396 }
24397 return resultobj;
24398 fail:
24399 {
24400 if (temp7)
24401 delete arg7;
24402 }
24403 return NULL;
24404 }
24405
24406
24407 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24408 PyObject *resultobj;
24409 wxWindow *arg1 = (wxWindow *) 0 ;
24410 bool arg2 = (bool) false ;
24411 bool result;
24412 PyObject * obj0 = 0 ;
24413 PyObject * obj1 = 0 ;
24414 char *kwnames[] = {
24415 (char *) "self",(char *) "force", NULL
24416 };
24417
24418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24420 if (SWIG_arg_fail(1)) SWIG_fail;
24421 if (obj1) {
24422 {
24423 arg2 = (bool)(SWIG_As_bool(obj1));
24424 if (SWIG_arg_fail(2)) SWIG_fail;
24425 }
24426 }
24427 {
24428 PyThreadState* __tstate = wxPyBeginAllowThreads();
24429 result = (bool)(arg1)->Close(arg2);
24430
24431 wxPyEndAllowThreads(__tstate);
24432 if (PyErr_Occurred()) SWIG_fail;
24433 }
24434 {
24435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24436 }
24437 return resultobj;
24438 fail:
24439 return NULL;
24440 }
24441
24442
24443 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24444 PyObject *resultobj;
24445 wxWindow *arg1 = (wxWindow *) 0 ;
24446 bool result;
24447 PyObject * obj0 = 0 ;
24448 char *kwnames[] = {
24449 (char *) "self", NULL
24450 };
24451
24452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24454 if (SWIG_arg_fail(1)) SWIG_fail;
24455 {
24456 PyThreadState* __tstate = wxPyBeginAllowThreads();
24457 result = (bool)(arg1)->Destroy();
24458
24459 wxPyEndAllowThreads(__tstate);
24460 if (PyErr_Occurred()) SWIG_fail;
24461 }
24462 {
24463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24464 }
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24472 PyObject *resultobj;
24473 wxWindow *arg1 = (wxWindow *) 0 ;
24474 bool result;
24475 PyObject * obj0 = 0 ;
24476 char *kwnames[] = {
24477 (char *) "self", NULL
24478 };
24479
24480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24482 if (SWIG_arg_fail(1)) SWIG_fail;
24483 {
24484 PyThreadState* __tstate = wxPyBeginAllowThreads();
24485 result = (bool)(arg1)->DestroyChildren();
24486
24487 wxPyEndAllowThreads(__tstate);
24488 if (PyErr_Occurred()) SWIG_fail;
24489 }
24490 {
24491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24492 }
24493 return resultobj;
24494 fail:
24495 return NULL;
24496 }
24497
24498
24499 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24500 PyObject *resultobj;
24501 wxWindow *arg1 = (wxWindow *) 0 ;
24502 bool result;
24503 PyObject * obj0 = 0 ;
24504 char *kwnames[] = {
24505 (char *) "self", NULL
24506 };
24507
24508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24510 if (SWIG_arg_fail(1)) SWIG_fail;
24511 {
24512 PyThreadState* __tstate = wxPyBeginAllowThreads();
24513 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24514
24515 wxPyEndAllowThreads(__tstate);
24516 if (PyErr_Occurred()) SWIG_fail;
24517 }
24518 {
24519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24520 }
24521 return resultobj;
24522 fail:
24523 return NULL;
24524 }
24525
24526
24527 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24528 PyObject *resultobj;
24529 wxWindow *arg1 = (wxWindow *) 0 ;
24530 wxString *arg2 = 0 ;
24531 bool temp2 = false ;
24532 PyObject * obj0 = 0 ;
24533 PyObject * obj1 = 0 ;
24534 char *kwnames[] = {
24535 (char *) "self",(char *) "title", NULL
24536 };
24537
24538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24540 if (SWIG_arg_fail(1)) SWIG_fail;
24541 {
24542 arg2 = wxString_in_helper(obj1);
24543 if (arg2 == NULL) SWIG_fail;
24544 temp2 = true;
24545 }
24546 {
24547 PyThreadState* __tstate = wxPyBeginAllowThreads();
24548 (arg1)->SetTitle((wxString const &)*arg2);
24549
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 Py_INCREF(Py_None); resultobj = Py_None;
24554 {
24555 if (temp2)
24556 delete arg2;
24557 }
24558 return resultobj;
24559 fail:
24560 {
24561 if (temp2)
24562 delete arg2;
24563 }
24564 return NULL;
24565 }
24566
24567
24568 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24569 PyObject *resultobj;
24570 wxWindow *arg1 = (wxWindow *) 0 ;
24571 wxString result;
24572 PyObject * obj0 = 0 ;
24573 char *kwnames[] = {
24574 (char *) "self", NULL
24575 };
24576
24577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24579 if (SWIG_arg_fail(1)) SWIG_fail;
24580 {
24581 PyThreadState* __tstate = wxPyBeginAllowThreads();
24582 result = ((wxWindow const *)arg1)->GetTitle();
24583
24584 wxPyEndAllowThreads(__tstate);
24585 if (PyErr_Occurred()) SWIG_fail;
24586 }
24587 {
24588 #if wxUSE_UNICODE
24589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24590 #else
24591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24592 #endif
24593 }
24594 return resultobj;
24595 fail:
24596 return NULL;
24597 }
24598
24599
24600 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24601 PyObject *resultobj;
24602 wxWindow *arg1 = (wxWindow *) 0 ;
24603 wxString *arg2 = 0 ;
24604 bool temp2 = false ;
24605 PyObject * obj0 = 0 ;
24606 PyObject * obj1 = 0 ;
24607 char *kwnames[] = {
24608 (char *) "self",(char *) "label", NULL
24609 };
24610
24611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24613 if (SWIG_arg_fail(1)) SWIG_fail;
24614 {
24615 arg2 = wxString_in_helper(obj1);
24616 if (arg2 == NULL) SWIG_fail;
24617 temp2 = true;
24618 }
24619 {
24620 PyThreadState* __tstate = wxPyBeginAllowThreads();
24621 (arg1)->SetLabel((wxString const &)*arg2);
24622
24623 wxPyEndAllowThreads(__tstate);
24624 if (PyErr_Occurred()) SWIG_fail;
24625 }
24626 Py_INCREF(Py_None); resultobj = Py_None;
24627 {
24628 if (temp2)
24629 delete arg2;
24630 }
24631 return resultobj;
24632 fail:
24633 {
24634 if (temp2)
24635 delete arg2;
24636 }
24637 return NULL;
24638 }
24639
24640
24641 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24642 PyObject *resultobj;
24643 wxWindow *arg1 = (wxWindow *) 0 ;
24644 wxString result;
24645 PyObject * obj0 = 0 ;
24646 char *kwnames[] = {
24647 (char *) "self", NULL
24648 };
24649
24650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24652 if (SWIG_arg_fail(1)) SWIG_fail;
24653 {
24654 PyThreadState* __tstate = wxPyBeginAllowThreads();
24655 result = ((wxWindow const *)arg1)->GetLabel();
24656
24657 wxPyEndAllowThreads(__tstate);
24658 if (PyErr_Occurred()) SWIG_fail;
24659 }
24660 {
24661 #if wxUSE_UNICODE
24662 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24663 #else
24664 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24665 #endif
24666 }
24667 return resultobj;
24668 fail:
24669 return NULL;
24670 }
24671
24672
24673 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24674 PyObject *resultobj;
24675 wxWindow *arg1 = (wxWindow *) 0 ;
24676 wxString *arg2 = 0 ;
24677 bool temp2 = false ;
24678 PyObject * obj0 = 0 ;
24679 PyObject * obj1 = 0 ;
24680 char *kwnames[] = {
24681 (char *) "self",(char *) "name", NULL
24682 };
24683
24684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24686 if (SWIG_arg_fail(1)) SWIG_fail;
24687 {
24688 arg2 = wxString_in_helper(obj1);
24689 if (arg2 == NULL) SWIG_fail;
24690 temp2 = true;
24691 }
24692 {
24693 PyThreadState* __tstate = wxPyBeginAllowThreads();
24694 (arg1)->SetName((wxString const &)*arg2);
24695
24696 wxPyEndAllowThreads(__tstate);
24697 if (PyErr_Occurred()) SWIG_fail;
24698 }
24699 Py_INCREF(Py_None); resultobj = Py_None;
24700 {
24701 if (temp2)
24702 delete arg2;
24703 }
24704 return resultobj;
24705 fail:
24706 {
24707 if (temp2)
24708 delete arg2;
24709 }
24710 return NULL;
24711 }
24712
24713
24714 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj;
24716 wxWindow *arg1 = (wxWindow *) 0 ;
24717 wxString result;
24718 PyObject * obj0 = 0 ;
24719 char *kwnames[] = {
24720 (char *) "self", NULL
24721 };
24722
24723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24725 if (SWIG_arg_fail(1)) SWIG_fail;
24726 {
24727 PyThreadState* __tstate = wxPyBeginAllowThreads();
24728 result = ((wxWindow const *)arg1)->GetName();
24729
24730 wxPyEndAllowThreads(__tstate);
24731 if (PyErr_Occurred()) SWIG_fail;
24732 }
24733 {
24734 #if wxUSE_UNICODE
24735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24736 #else
24737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24738 #endif
24739 }
24740 return resultobj;
24741 fail:
24742 return NULL;
24743 }
24744
24745
24746 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24747 PyObject *resultobj;
24748 wxWindow *arg1 = (wxWindow *) 0 ;
24749 wxWindowVariant arg2 ;
24750 PyObject * obj0 = 0 ;
24751 PyObject * obj1 = 0 ;
24752 char *kwnames[] = {
24753 (char *) "self",(char *) "variant", NULL
24754 };
24755
24756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
24757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24758 if (SWIG_arg_fail(1)) SWIG_fail;
24759 {
24760 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
24761 if (SWIG_arg_fail(2)) SWIG_fail;
24762 }
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
24766
24767 wxPyEndAllowThreads(__tstate);
24768 if (PyErr_Occurred()) SWIG_fail;
24769 }
24770 Py_INCREF(Py_None); resultobj = Py_None;
24771 return resultobj;
24772 fail:
24773 return NULL;
24774 }
24775
24776
24777 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24778 PyObject *resultobj;
24779 wxWindow *arg1 = (wxWindow *) 0 ;
24780 wxWindowVariant result;
24781 PyObject * obj0 = 0 ;
24782 char *kwnames[] = {
24783 (char *) "self", NULL
24784 };
24785
24786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
24787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24788 if (SWIG_arg_fail(1)) SWIG_fail;
24789 {
24790 PyThreadState* __tstate = wxPyBeginAllowThreads();
24791 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
24792
24793 wxPyEndAllowThreads(__tstate);
24794 if (PyErr_Occurred()) SWIG_fail;
24795 }
24796 resultobj = SWIG_From_int((result));
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
24804 PyObject *resultobj;
24805 wxWindow *arg1 = (wxWindow *) 0 ;
24806 int arg2 ;
24807 PyObject * obj0 = 0 ;
24808 PyObject * obj1 = 0 ;
24809 char *kwnames[] = {
24810 (char *) "self",(char *) "winid", NULL
24811 };
24812
24813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
24814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24815 if (SWIG_arg_fail(1)) SWIG_fail;
24816 {
24817 arg2 = (int)(SWIG_As_int(obj1));
24818 if (SWIG_arg_fail(2)) SWIG_fail;
24819 }
24820 {
24821 PyThreadState* __tstate = wxPyBeginAllowThreads();
24822 (arg1)->SetId(arg2);
24823
24824 wxPyEndAllowThreads(__tstate);
24825 if (PyErr_Occurred()) SWIG_fail;
24826 }
24827 Py_INCREF(Py_None); resultobj = Py_None;
24828 return resultobj;
24829 fail:
24830 return NULL;
24831 }
24832
24833
24834 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
24835 PyObject *resultobj;
24836 wxWindow *arg1 = (wxWindow *) 0 ;
24837 int result;
24838 PyObject * obj0 = 0 ;
24839 char *kwnames[] = {
24840 (char *) "self", NULL
24841 };
24842
24843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
24844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24845 if (SWIG_arg_fail(1)) SWIG_fail;
24846 {
24847 PyThreadState* __tstate = wxPyBeginAllowThreads();
24848 result = (int)((wxWindow const *)arg1)->GetId();
24849
24850 wxPyEndAllowThreads(__tstate);
24851 if (PyErr_Occurred()) SWIG_fail;
24852 }
24853 {
24854 resultobj = SWIG_From_int((int)(result));
24855 }
24856 return resultobj;
24857 fail:
24858 return NULL;
24859 }
24860
24861
24862 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24863 PyObject *resultobj;
24864 int result;
24865 char *kwnames[] = {
24866 NULL
24867 };
24868
24869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
24870 {
24871 PyThreadState* __tstate = wxPyBeginAllowThreads();
24872 result = (int)wxWindow::NewControlId();
24873
24874 wxPyEndAllowThreads(__tstate);
24875 if (PyErr_Occurred()) SWIG_fail;
24876 }
24877 {
24878 resultobj = SWIG_From_int((int)(result));
24879 }
24880 return resultobj;
24881 fail:
24882 return NULL;
24883 }
24884
24885
24886 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24887 PyObject *resultobj;
24888 int arg1 ;
24889 int result;
24890 PyObject * obj0 = 0 ;
24891 char *kwnames[] = {
24892 (char *) "winid", NULL
24893 };
24894
24895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
24896 {
24897 arg1 = (int)(SWIG_As_int(obj0));
24898 if (SWIG_arg_fail(1)) SWIG_fail;
24899 }
24900 {
24901 PyThreadState* __tstate = wxPyBeginAllowThreads();
24902 result = (int)wxWindow::NextControlId(arg1);
24903
24904 wxPyEndAllowThreads(__tstate);
24905 if (PyErr_Occurred()) SWIG_fail;
24906 }
24907 {
24908 resultobj = SWIG_From_int((int)(result));
24909 }
24910 return resultobj;
24911 fail:
24912 return NULL;
24913 }
24914
24915
24916 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24917 PyObject *resultobj;
24918 int arg1 ;
24919 int result;
24920 PyObject * obj0 = 0 ;
24921 char *kwnames[] = {
24922 (char *) "winid", NULL
24923 };
24924
24925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
24926 {
24927 arg1 = (int)(SWIG_As_int(obj0));
24928 if (SWIG_arg_fail(1)) SWIG_fail;
24929 }
24930 {
24931 PyThreadState* __tstate = wxPyBeginAllowThreads();
24932 result = (int)wxWindow::PrevControlId(arg1);
24933
24934 wxPyEndAllowThreads(__tstate);
24935 if (PyErr_Occurred()) SWIG_fail;
24936 }
24937 {
24938 resultobj = SWIG_From_int((int)(result));
24939 }
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
24947 PyObject *resultobj;
24948 wxWindow *arg1 = (wxWindow *) 0 ;
24949 wxSize *arg2 = 0 ;
24950 wxSize temp2 ;
24951 PyObject * obj0 = 0 ;
24952 PyObject * obj1 = 0 ;
24953 char *kwnames[] = {
24954 (char *) "self",(char *) "size", NULL
24955 };
24956
24957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
24958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24959 if (SWIG_arg_fail(1)) SWIG_fail;
24960 {
24961 arg2 = &temp2;
24962 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
24963 }
24964 {
24965 PyThreadState* __tstate = wxPyBeginAllowThreads();
24966 (arg1)->SetSize((wxSize const &)*arg2);
24967
24968 wxPyEndAllowThreads(__tstate);
24969 if (PyErr_Occurred()) SWIG_fail;
24970 }
24971 Py_INCREF(Py_None); resultobj = Py_None;
24972 return resultobj;
24973 fail:
24974 return NULL;
24975 }
24976
24977
24978 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
24979 PyObject *resultobj;
24980 wxWindow *arg1 = (wxWindow *) 0 ;
24981 int arg2 ;
24982 int arg3 ;
24983 int arg4 ;
24984 int arg5 ;
24985 int arg6 = (int) wxSIZE_AUTO ;
24986 PyObject * obj0 = 0 ;
24987 PyObject * obj1 = 0 ;
24988 PyObject * obj2 = 0 ;
24989 PyObject * obj3 = 0 ;
24990 PyObject * obj4 = 0 ;
24991 PyObject * obj5 = 0 ;
24992 char *kwnames[] = {
24993 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
24994 };
24995
24996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24998 if (SWIG_arg_fail(1)) SWIG_fail;
24999 {
25000 arg2 = (int)(SWIG_As_int(obj1));
25001 if (SWIG_arg_fail(2)) SWIG_fail;
25002 }
25003 {
25004 arg3 = (int)(SWIG_As_int(obj2));
25005 if (SWIG_arg_fail(3)) SWIG_fail;
25006 }
25007 {
25008 arg4 = (int)(SWIG_As_int(obj3));
25009 if (SWIG_arg_fail(4)) SWIG_fail;
25010 }
25011 {
25012 arg5 = (int)(SWIG_As_int(obj4));
25013 if (SWIG_arg_fail(5)) SWIG_fail;
25014 }
25015 if (obj5) {
25016 {
25017 arg6 = (int)(SWIG_As_int(obj5));
25018 if (SWIG_arg_fail(6)) SWIG_fail;
25019 }
25020 }
25021 {
25022 PyThreadState* __tstate = wxPyBeginAllowThreads();
25023 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25024
25025 wxPyEndAllowThreads(__tstate);
25026 if (PyErr_Occurred()) SWIG_fail;
25027 }
25028 Py_INCREF(Py_None); resultobj = Py_None;
25029 return resultobj;
25030 fail:
25031 return NULL;
25032 }
25033
25034
25035 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25036 PyObject *resultobj;
25037 wxWindow *arg1 = (wxWindow *) 0 ;
25038 wxRect *arg2 = 0 ;
25039 int arg3 = (int) wxSIZE_AUTO ;
25040 wxRect temp2 ;
25041 PyObject * obj0 = 0 ;
25042 PyObject * obj1 = 0 ;
25043 PyObject * obj2 = 0 ;
25044 char *kwnames[] = {
25045 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25046 };
25047
25048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25050 if (SWIG_arg_fail(1)) SWIG_fail;
25051 {
25052 arg2 = &temp2;
25053 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25054 }
25055 if (obj2) {
25056 {
25057 arg3 = (int)(SWIG_As_int(obj2));
25058 if (SWIG_arg_fail(3)) SWIG_fail;
25059 }
25060 }
25061 {
25062 PyThreadState* __tstate = wxPyBeginAllowThreads();
25063 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25064
25065 wxPyEndAllowThreads(__tstate);
25066 if (PyErr_Occurred()) SWIG_fail;
25067 }
25068 Py_INCREF(Py_None); resultobj = Py_None;
25069 return resultobj;
25070 fail:
25071 return NULL;
25072 }
25073
25074
25075 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25076 PyObject *resultobj;
25077 wxWindow *arg1 = (wxWindow *) 0 ;
25078 int arg2 ;
25079 int arg3 ;
25080 PyObject * obj0 = 0 ;
25081 PyObject * obj1 = 0 ;
25082 PyObject * obj2 = 0 ;
25083 char *kwnames[] = {
25084 (char *) "self",(char *) "width",(char *) "height", NULL
25085 };
25086
25087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25089 if (SWIG_arg_fail(1)) SWIG_fail;
25090 {
25091 arg2 = (int)(SWIG_As_int(obj1));
25092 if (SWIG_arg_fail(2)) SWIG_fail;
25093 }
25094 {
25095 arg3 = (int)(SWIG_As_int(obj2));
25096 if (SWIG_arg_fail(3)) SWIG_fail;
25097 }
25098 {
25099 PyThreadState* __tstate = wxPyBeginAllowThreads();
25100 (arg1)->SetSize(arg2,arg3);
25101
25102 wxPyEndAllowThreads(__tstate);
25103 if (PyErr_Occurred()) SWIG_fail;
25104 }
25105 Py_INCREF(Py_None); resultobj = Py_None;
25106 return resultobj;
25107 fail:
25108 return NULL;
25109 }
25110
25111
25112 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25113 PyObject *resultobj;
25114 wxWindow *arg1 = (wxWindow *) 0 ;
25115 wxPoint *arg2 = 0 ;
25116 int arg3 = (int) wxSIZE_USE_EXISTING ;
25117 wxPoint temp2 ;
25118 PyObject * obj0 = 0 ;
25119 PyObject * obj1 = 0 ;
25120 PyObject * obj2 = 0 ;
25121 char *kwnames[] = {
25122 (char *) "self",(char *) "pt",(char *) "flags", NULL
25123 };
25124
25125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25127 if (SWIG_arg_fail(1)) SWIG_fail;
25128 {
25129 arg2 = &temp2;
25130 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25131 }
25132 if (obj2) {
25133 {
25134 arg3 = (int)(SWIG_As_int(obj2));
25135 if (SWIG_arg_fail(3)) SWIG_fail;
25136 }
25137 }
25138 {
25139 PyThreadState* __tstate = wxPyBeginAllowThreads();
25140 (arg1)->Move((wxPoint const &)*arg2,arg3);
25141
25142 wxPyEndAllowThreads(__tstate);
25143 if (PyErr_Occurred()) SWIG_fail;
25144 }
25145 Py_INCREF(Py_None); resultobj = Py_None;
25146 return resultobj;
25147 fail:
25148 return NULL;
25149 }
25150
25151
25152 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25153 PyObject *resultobj;
25154 wxWindow *arg1 = (wxWindow *) 0 ;
25155 int arg2 ;
25156 int arg3 ;
25157 int arg4 = (int) wxSIZE_USE_EXISTING ;
25158 PyObject * obj0 = 0 ;
25159 PyObject * obj1 = 0 ;
25160 PyObject * obj2 = 0 ;
25161 PyObject * obj3 = 0 ;
25162 char *kwnames[] = {
25163 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25164 };
25165
25166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25168 if (SWIG_arg_fail(1)) SWIG_fail;
25169 {
25170 arg2 = (int)(SWIG_As_int(obj1));
25171 if (SWIG_arg_fail(2)) SWIG_fail;
25172 }
25173 {
25174 arg3 = (int)(SWIG_As_int(obj2));
25175 if (SWIG_arg_fail(3)) SWIG_fail;
25176 }
25177 if (obj3) {
25178 {
25179 arg4 = (int)(SWIG_As_int(obj3));
25180 if (SWIG_arg_fail(4)) SWIG_fail;
25181 }
25182 }
25183 {
25184 PyThreadState* __tstate = wxPyBeginAllowThreads();
25185 (arg1)->Move(arg2,arg3,arg4);
25186
25187 wxPyEndAllowThreads(__tstate);
25188 if (PyErr_Occurred()) SWIG_fail;
25189 }
25190 Py_INCREF(Py_None); resultobj = Py_None;
25191 return resultobj;
25192 fail:
25193 return NULL;
25194 }
25195
25196
25197 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25198 PyObject *resultobj;
25199 wxWindow *arg1 = (wxWindow *) 0 ;
25200 wxSize const &arg2_defvalue = wxDefaultSize ;
25201 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25202 wxSize temp2 ;
25203 PyObject * obj0 = 0 ;
25204 PyObject * obj1 = 0 ;
25205 char *kwnames[] = {
25206 (char *) "self",(char *) "size", NULL
25207 };
25208
25209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25211 if (SWIG_arg_fail(1)) SWIG_fail;
25212 if (obj1) {
25213 {
25214 arg2 = &temp2;
25215 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25216 }
25217 }
25218 {
25219 PyThreadState* __tstate = wxPyBeginAllowThreads();
25220 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25221
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 Py_INCREF(Py_None); resultobj = Py_None;
25226 return resultobj;
25227 fail:
25228 return NULL;
25229 }
25230
25231
25232 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25233 PyObject *resultobj;
25234 wxWindow *arg1 = (wxWindow *) 0 ;
25235 PyObject * obj0 = 0 ;
25236 char *kwnames[] = {
25237 (char *) "self", NULL
25238 };
25239
25240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25242 if (SWIG_arg_fail(1)) SWIG_fail;
25243 {
25244 PyThreadState* __tstate = wxPyBeginAllowThreads();
25245 (arg1)->Raise();
25246
25247 wxPyEndAllowThreads(__tstate);
25248 if (PyErr_Occurred()) SWIG_fail;
25249 }
25250 Py_INCREF(Py_None); resultobj = Py_None;
25251 return resultobj;
25252 fail:
25253 return NULL;
25254 }
25255
25256
25257 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25258 PyObject *resultobj;
25259 wxWindow *arg1 = (wxWindow *) 0 ;
25260 PyObject * obj0 = 0 ;
25261 char *kwnames[] = {
25262 (char *) "self", NULL
25263 };
25264
25265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25267 if (SWIG_arg_fail(1)) SWIG_fail;
25268 {
25269 PyThreadState* __tstate = wxPyBeginAllowThreads();
25270 (arg1)->Lower();
25271
25272 wxPyEndAllowThreads(__tstate);
25273 if (PyErr_Occurred()) SWIG_fail;
25274 }
25275 Py_INCREF(Py_None); resultobj = Py_None;
25276 return resultobj;
25277 fail:
25278 return NULL;
25279 }
25280
25281
25282 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25283 PyObject *resultobj;
25284 wxWindow *arg1 = (wxWindow *) 0 ;
25285 wxSize *arg2 = 0 ;
25286 wxSize temp2 ;
25287 PyObject * obj0 = 0 ;
25288 PyObject * obj1 = 0 ;
25289 char *kwnames[] = {
25290 (char *) "self",(char *) "size", NULL
25291 };
25292
25293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25295 if (SWIG_arg_fail(1)) SWIG_fail;
25296 {
25297 arg2 = &temp2;
25298 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25299 }
25300 {
25301 PyThreadState* __tstate = wxPyBeginAllowThreads();
25302 (arg1)->SetClientSize((wxSize const &)*arg2);
25303
25304 wxPyEndAllowThreads(__tstate);
25305 if (PyErr_Occurred()) SWIG_fail;
25306 }
25307 Py_INCREF(Py_None); resultobj = Py_None;
25308 return resultobj;
25309 fail:
25310 return NULL;
25311 }
25312
25313
25314 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25315 PyObject *resultobj;
25316 wxWindow *arg1 = (wxWindow *) 0 ;
25317 int arg2 ;
25318 int arg3 ;
25319 PyObject * obj0 = 0 ;
25320 PyObject * obj1 = 0 ;
25321 PyObject * obj2 = 0 ;
25322 char *kwnames[] = {
25323 (char *) "self",(char *) "width",(char *) "height", NULL
25324 };
25325
25326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25328 if (SWIG_arg_fail(1)) SWIG_fail;
25329 {
25330 arg2 = (int)(SWIG_As_int(obj1));
25331 if (SWIG_arg_fail(2)) SWIG_fail;
25332 }
25333 {
25334 arg3 = (int)(SWIG_As_int(obj2));
25335 if (SWIG_arg_fail(3)) SWIG_fail;
25336 }
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 (arg1)->SetClientSize(arg2,arg3);
25340
25341 wxPyEndAllowThreads(__tstate);
25342 if (PyErr_Occurred()) SWIG_fail;
25343 }
25344 Py_INCREF(Py_None); resultobj = Py_None;
25345 return resultobj;
25346 fail:
25347 return NULL;
25348 }
25349
25350
25351 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25352 PyObject *resultobj;
25353 wxWindow *arg1 = (wxWindow *) 0 ;
25354 wxRect *arg2 = 0 ;
25355 wxRect temp2 ;
25356 PyObject * obj0 = 0 ;
25357 PyObject * obj1 = 0 ;
25358 char *kwnames[] = {
25359 (char *) "self",(char *) "rect", NULL
25360 };
25361
25362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25364 if (SWIG_arg_fail(1)) SWIG_fail;
25365 {
25366 arg2 = &temp2;
25367 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25368 }
25369 {
25370 PyThreadState* __tstate = wxPyBeginAllowThreads();
25371 (arg1)->SetClientSize((wxRect const &)*arg2);
25372
25373 wxPyEndAllowThreads(__tstate);
25374 if (PyErr_Occurred()) SWIG_fail;
25375 }
25376 Py_INCREF(Py_None); resultobj = Py_None;
25377 return resultobj;
25378 fail:
25379 return NULL;
25380 }
25381
25382
25383 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25384 PyObject *resultobj;
25385 wxWindow *arg1 = (wxWindow *) 0 ;
25386 wxPoint result;
25387 PyObject * obj0 = 0 ;
25388 char *kwnames[] = {
25389 (char *) "self", NULL
25390 };
25391
25392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25394 if (SWIG_arg_fail(1)) SWIG_fail;
25395 {
25396 PyThreadState* __tstate = wxPyBeginAllowThreads();
25397 result = (arg1)->GetPosition();
25398
25399 wxPyEndAllowThreads(__tstate);
25400 if (PyErr_Occurred()) SWIG_fail;
25401 }
25402 {
25403 wxPoint * resultptr;
25404 resultptr = new wxPoint((wxPoint &)(result));
25405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25406 }
25407 return resultobj;
25408 fail:
25409 return NULL;
25410 }
25411
25412
25413 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25414 PyObject *resultobj;
25415 wxWindow *arg1 = (wxWindow *) 0 ;
25416 int *arg2 = (int *) 0 ;
25417 int *arg3 = (int *) 0 ;
25418 int temp2 ;
25419 int res2 = 0 ;
25420 int temp3 ;
25421 int res3 = 0 ;
25422 PyObject * obj0 = 0 ;
25423 char *kwnames[] = {
25424 (char *) "self", NULL
25425 };
25426
25427 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25428 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25431 if (SWIG_arg_fail(1)) SWIG_fail;
25432 {
25433 PyThreadState* __tstate = wxPyBeginAllowThreads();
25434 (arg1)->GetPosition(arg2,arg3);
25435
25436 wxPyEndAllowThreads(__tstate);
25437 if (PyErr_Occurred()) SWIG_fail;
25438 }
25439 Py_INCREF(Py_None); resultobj = Py_None;
25440 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25441 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25442 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25443 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25444 return resultobj;
25445 fail:
25446 return NULL;
25447 }
25448
25449
25450 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25451 PyObject *resultobj;
25452 wxWindow *arg1 = (wxWindow *) 0 ;
25453 wxSize result;
25454 PyObject * obj0 = 0 ;
25455 char *kwnames[] = {
25456 (char *) "self", NULL
25457 };
25458
25459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25461 if (SWIG_arg_fail(1)) SWIG_fail;
25462 {
25463 PyThreadState* __tstate = wxPyBeginAllowThreads();
25464 result = ((wxWindow const *)arg1)->GetSize();
25465
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 {
25470 wxSize * resultptr;
25471 resultptr = new wxSize((wxSize &)(result));
25472 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25473 }
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25481 PyObject *resultobj;
25482 wxWindow *arg1 = (wxWindow *) 0 ;
25483 int *arg2 = (int *) 0 ;
25484 int *arg3 = (int *) 0 ;
25485 int temp2 ;
25486 int res2 = 0 ;
25487 int temp3 ;
25488 int res3 = 0 ;
25489 PyObject * obj0 = 0 ;
25490 char *kwnames[] = {
25491 (char *) "self", NULL
25492 };
25493
25494 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25495 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25498 if (SWIG_arg_fail(1)) SWIG_fail;
25499 {
25500 PyThreadState* __tstate = wxPyBeginAllowThreads();
25501 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25502
25503 wxPyEndAllowThreads(__tstate);
25504 if (PyErr_Occurred()) SWIG_fail;
25505 }
25506 Py_INCREF(Py_None); resultobj = Py_None;
25507 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25508 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25509 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25510 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25511 return resultobj;
25512 fail:
25513 return NULL;
25514 }
25515
25516
25517 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25518 PyObject *resultobj;
25519 wxWindow *arg1 = (wxWindow *) 0 ;
25520 wxRect result;
25521 PyObject * obj0 = 0 ;
25522 char *kwnames[] = {
25523 (char *) "self", NULL
25524 };
25525
25526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25528 if (SWIG_arg_fail(1)) SWIG_fail;
25529 {
25530 PyThreadState* __tstate = wxPyBeginAllowThreads();
25531 result = ((wxWindow const *)arg1)->GetRect();
25532
25533 wxPyEndAllowThreads(__tstate);
25534 if (PyErr_Occurred()) SWIG_fail;
25535 }
25536 {
25537 wxRect * resultptr;
25538 resultptr = new wxRect((wxRect &)(result));
25539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25540 }
25541 return resultobj;
25542 fail:
25543 return NULL;
25544 }
25545
25546
25547 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25548 PyObject *resultobj;
25549 wxWindow *arg1 = (wxWindow *) 0 ;
25550 wxSize result;
25551 PyObject * obj0 = 0 ;
25552 char *kwnames[] = {
25553 (char *) "self", NULL
25554 };
25555
25556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
25561 result = ((wxWindow const *)arg1)->GetClientSize();
25562
25563 wxPyEndAllowThreads(__tstate);
25564 if (PyErr_Occurred()) SWIG_fail;
25565 }
25566 {
25567 wxSize * resultptr;
25568 resultptr = new wxSize((wxSize &)(result));
25569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25570 }
25571 return resultobj;
25572 fail:
25573 return NULL;
25574 }
25575
25576
25577 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25578 PyObject *resultobj;
25579 wxWindow *arg1 = (wxWindow *) 0 ;
25580 int *arg2 = (int *) 0 ;
25581 int *arg3 = (int *) 0 ;
25582 int temp2 ;
25583 int res2 = 0 ;
25584 int temp3 ;
25585 int res3 = 0 ;
25586 PyObject * obj0 = 0 ;
25587 char *kwnames[] = {
25588 (char *) "self", NULL
25589 };
25590
25591 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25592 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25595 if (SWIG_arg_fail(1)) SWIG_fail;
25596 {
25597 PyThreadState* __tstate = wxPyBeginAllowThreads();
25598 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25599
25600 wxPyEndAllowThreads(__tstate);
25601 if (PyErr_Occurred()) SWIG_fail;
25602 }
25603 Py_INCREF(Py_None); resultobj = Py_None;
25604 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25605 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25606 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25607 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25608 return resultobj;
25609 fail:
25610 return NULL;
25611 }
25612
25613
25614 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25615 PyObject *resultobj;
25616 wxWindow *arg1 = (wxWindow *) 0 ;
25617 wxPoint result;
25618 PyObject * obj0 = 0 ;
25619 char *kwnames[] = {
25620 (char *) "self", NULL
25621 };
25622
25623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25625 if (SWIG_arg_fail(1)) SWIG_fail;
25626 {
25627 PyThreadState* __tstate = wxPyBeginAllowThreads();
25628 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25629
25630 wxPyEndAllowThreads(__tstate);
25631 if (PyErr_Occurred()) SWIG_fail;
25632 }
25633 {
25634 wxPoint * resultptr;
25635 resultptr = new wxPoint((wxPoint &)(result));
25636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25637 }
25638 return resultobj;
25639 fail:
25640 return NULL;
25641 }
25642
25643
25644 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25645 PyObject *resultobj;
25646 wxWindow *arg1 = (wxWindow *) 0 ;
25647 wxRect result;
25648 PyObject * obj0 = 0 ;
25649 char *kwnames[] = {
25650 (char *) "self", NULL
25651 };
25652
25653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25655 if (SWIG_arg_fail(1)) SWIG_fail;
25656 {
25657 PyThreadState* __tstate = wxPyBeginAllowThreads();
25658 result = ((wxWindow const *)arg1)->GetClientRect();
25659
25660 wxPyEndAllowThreads(__tstate);
25661 if (PyErr_Occurred()) SWIG_fail;
25662 }
25663 {
25664 wxRect * resultptr;
25665 resultptr = new wxRect((wxRect &)(result));
25666 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25667 }
25668 return resultobj;
25669 fail:
25670 return NULL;
25671 }
25672
25673
25674 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25675 PyObject *resultobj;
25676 wxWindow *arg1 = (wxWindow *) 0 ;
25677 wxSize result;
25678 PyObject * obj0 = 0 ;
25679 char *kwnames[] = {
25680 (char *) "self", NULL
25681 };
25682
25683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25685 if (SWIG_arg_fail(1)) SWIG_fail;
25686 {
25687 PyThreadState* __tstate = wxPyBeginAllowThreads();
25688 result = ((wxWindow const *)arg1)->GetBestSize();
25689
25690 wxPyEndAllowThreads(__tstate);
25691 if (PyErr_Occurred()) SWIG_fail;
25692 }
25693 {
25694 wxSize * resultptr;
25695 resultptr = new wxSize((wxSize &)(result));
25696 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25697 }
25698 return resultobj;
25699 fail:
25700 return NULL;
25701 }
25702
25703
25704 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25705 PyObject *resultobj;
25706 wxWindow *arg1 = (wxWindow *) 0 ;
25707 int *arg2 = (int *) 0 ;
25708 int *arg3 = (int *) 0 ;
25709 int temp2 ;
25710 int res2 = 0 ;
25711 int temp3 ;
25712 int res3 = 0 ;
25713 PyObject * obj0 = 0 ;
25714 char *kwnames[] = {
25715 (char *) "self", NULL
25716 };
25717
25718 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25719 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25722 if (SWIG_arg_fail(1)) SWIG_fail;
25723 {
25724 PyThreadState* __tstate = wxPyBeginAllowThreads();
25725 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25726
25727 wxPyEndAllowThreads(__tstate);
25728 if (PyErr_Occurred()) SWIG_fail;
25729 }
25730 Py_INCREF(Py_None); resultobj = Py_None;
25731 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25732 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25733 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25734 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25735 return resultobj;
25736 fail:
25737 return NULL;
25738 }
25739
25740
25741 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25742 PyObject *resultobj;
25743 wxWindow *arg1 = (wxWindow *) 0 ;
25744 PyObject * obj0 = 0 ;
25745 char *kwnames[] = {
25746 (char *) "self", NULL
25747 };
25748
25749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
25750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25751 if (SWIG_arg_fail(1)) SWIG_fail;
25752 {
25753 PyThreadState* __tstate = wxPyBeginAllowThreads();
25754 (arg1)->InvalidateBestSize();
25755
25756 wxPyEndAllowThreads(__tstate);
25757 if (PyErr_Occurred()) SWIG_fail;
25758 }
25759 Py_INCREF(Py_None); resultobj = Py_None;
25760 return resultobj;
25761 fail:
25762 return NULL;
25763 }
25764
25765
25766 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25767 PyObject *resultobj;
25768 wxWindow *arg1 = (wxWindow *) 0 ;
25769 wxSize result;
25770 PyObject * obj0 = 0 ;
25771 char *kwnames[] = {
25772 (char *) "self", NULL
25773 };
25774
25775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
25776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25777 if (SWIG_arg_fail(1)) SWIG_fail;
25778 {
25779 PyThreadState* __tstate = wxPyBeginAllowThreads();
25780 result = ((wxWindow const *)arg1)->GetBestFittingSize();
25781
25782 wxPyEndAllowThreads(__tstate);
25783 if (PyErr_Occurred()) SWIG_fail;
25784 }
25785 {
25786 wxSize * resultptr;
25787 resultptr = new wxSize((wxSize &)(result));
25788 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25789 }
25790 return resultobj;
25791 fail:
25792 return NULL;
25793 }
25794
25795
25796 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25797 PyObject *resultobj;
25798 wxWindow *arg1 = (wxWindow *) 0 ;
25799 wxSize result;
25800 PyObject * obj0 = 0 ;
25801 char *kwnames[] = {
25802 (char *) "self", NULL
25803 };
25804
25805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
25806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25807 if (SWIG_arg_fail(1)) SWIG_fail;
25808 {
25809 PyThreadState* __tstate = wxPyBeginAllowThreads();
25810 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
25811
25812 wxPyEndAllowThreads(__tstate);
25813 if (PyErr_Occurred()) SWIG_fail;
25814 }
25815 {
25816 wxSize * resultptr;
25817 resultptr = new wxSize((wxSize &)(result));
25818 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25819 }
25820 return resultobj;
25821 fail:
25822 return NULL;
25823 }
25824
25825
25826 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
25827 PyObject *resultobj;
25828 wxWindow *arg1 = (wxWindow *) 0 ;
25829 int arg2 = (int) wxBOTH ;
25830 PyObject * obj0 = 0 ;
25831 PyObject * obj1 = 0 ;
25832 char *kwnames[] = {
25833 (char *) "self",(char *) "direction", NULL
25834 };
25835
25836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
25837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25838 if (SWIG_arg_fail(1)) SWIG_fail;
25839 if (obj1) {
25840 {
25841 arg2 = (int)(SWIG_As_int(obj1));
25842 if (SWIG_arg_fail(2)) SWIG_fail;
25843 }
25844 }
25845 {
25846 PyThreadState* __tstate = wxPyBeginAllowThreads();
25847 (arg1)->Center(arg2);
25848
25849 wxPyEndAllowThreads(__tstate);
25850 if (PyErr_Occurred()) SWIG_fail;
25851 }
25852 Py_INCREF(Py_None); resultobj = Py_None;
25853 return resultobj;
25854 fail:
25855 return NULL;
25856 }
25857
25858
25859 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25860 PyObject *resultobj;
25861 wxWindow *arg1 = (wxWindow *) 0 ;
25862 int arg2 = (int) wxBOTH ;
25863 PyObject * obj0 = 0 ;
25864 PyObject * obj1 = 0 ;
25865 char *kwnames[] = {
25866 (char *) "self",(char *) "dir", NULL
25867 };
25868
25869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
25870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25871 if (SWIG_arg_fail(1)) SWIG_fail;
25872 if (obj1) {
25873 {
25874 arg2 = (int)(SWIG_As_int(obj1));
25875 if (SWIG_arg_fail(2)) SWIG_fail;
25876 }
25877 }
25878 {
25879 PyThreadState* __tstate = wxPyBeginAllowThreads();
25880 (arg1)->CenterOnScreen(arg2);
25881
25882 wxPyEndAllowThreads(__tstate);
25883 if (PyErr_Occurred()) SWIG_fail;
25884 }
25885 Py_INCREF(Py_None); resultobj = Py_None;
25886 return resultobj;
25887 fail:
25888 return NULL;
25889 }
25890
25891
25892 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
25893 PyObject *resultobj;
25894 wxWindow *arg1 = (wxWindow *) 0 ;
25895 int arg2 = (int) wxBOTH ;
25896 PyObject * obj0 = 0 ;
25897 PyObject * obj1 = 0 ;
25898 char *kwnames[] = {
25899 (char *) "self",(char *) "dir", NULL
25900 };
25901
25902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
25903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25904 if (SWIG_arg_fail(1)) SWIG_fail;
25905 if (obj1) {
25906 {
25907 arg2 = (int)(SWIG_As_int(obj1));
25908 if (SWIG_arg_fail(2)) SWIG_fail;
25909 }
25910 }
25911 {
25912 PyThreadState* __tstate = wxPyBeginAllowThreads();
25913 (arg1)->CenterOnParent(arg2);
25914
25915 wxPyEndAllowThreads(__tstate);
25916 if (PyErr_Occurred()) SWIG_fail;
25917 }
25918 Py_INCREF(Py_None); resultobj = Py_None;
25919 return resultobj;
25920 fail:
25921 return NULL;
25922 }
25923
25924
25925 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
25926 PyObject *resultobj;
25927 wxWindow *arg1 = (wxWindow *) 0 ;
25928 PyObject * obj0 = 0 ;
25929 char *kwnames[] = {
25930 (char *) "self", NULL
25931 };
25932
25933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
25934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25935 if (SWIG_arg_fail(1)) SWIG_fail;
25936 {
25937 PyThreadState* __tstate = wxPyBeginAllowThreads();
25938 (arg1)->Fit();
25939
25940 wxPyEndAllowThreads(__tstate);
25941 if (PyErr_Occurred()) SWIG_fail;
25942 }
25943 Py_INCREF(Py_None); resultobj = Py_None;
25944 return resultobj;
25945 fail:
25946 return NULL;
25947 }
25948
25949
25950 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
25951 PyObject *resultobj;
25952 wxWindow *arg1 = (wxWindow *) 0 ;
25953 PyObject * obj0 = 0 ;
25954 char *kwnames[] = {
25955 (char *) "self", NULL
25956 };
25957
25958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
25959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25960 if (SWIG_arg_fail(1)) SWIG_fail;
25961 {
25962 PyThreadState* __tstate = wxPyBeginAllowThreads();
25963 (arg1)->FitInside();
25964
25965 wxPyEndAllowThreads(__tstate);
25966 if (PyErr_Occurred()) SWIG_fail;
25967 }
25968 Py_INCREF(Py_None); resultobj = Py_None;
25969 return resultobj;
25970 fail:
25971 return NULL;
25972 }
25973
25974
25975 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
25976 PyObject *resultobj;
25977 wxWindow *arg1 = (wxWindow *) 0 ;
25978 int arg2 ;
25979 int arg3 ;
25980 int arg4 = (int) -1 ;
25981 int arg5 = (int) -1 ;
25982 int arg6 = (int) -1 ;
25983 int arg7 = (int) -1 ;
25984 PyObject * obj0 = 0 ;
25985 PyObject * obj1 = 0 ;
25986 PyObject * obj2 = 0 ;
25987 PyObject * obj3 = 0 ;
25988 PyObject * obj4 = 0 ;
25989 PyObject * obj5 = 0 ;
25990 PyObject * obj6 = 0 ;
25991 char *kwnames[] = {
25992 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
25993 };
25994
25995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25997 if (SWIG_arg_fail(1)) SWIG_fail;
25998 {
25999 arg2 = (int)(SWIG_As_int(obj1));
26000 if (SWIG_arg_fail(2)) SWIG_fail;
26001 }
26002 {
26003 arg3 = (int)(SWIG_As_int(obj2));
26004 if (SWIG_arg_fail(3)) SWIG_fail;
26005 }
26006 if (obj3) {
26007 {
26008 arg4 = (int)(SWIG_As_int(obj3));
26009 if (SWIG_arg_fail(4)) SWIG_fail;
26010 }
26011 }
26012 if (obj4) {
26013 {
26014 arg5 = (int)(SWIG_As_int(obj4));
26015 if (SWIG_arg_fail(5)) SWIG_fail;
26016 }
26017 }
26018 if (obj5) {
26019 {
26020 arg6 = (int)(SWIG_As_int(obj5));
26021 if (SWIG_arg_fail(6)) SWIG_fail;
26022 }
26023 }
26024 if (obj6) {
26025 {
26026 arg7 = (int)(SWIG_As_int(obj6));
26027 if (SWIG_arg_fail(7)) SWIG_fail;
26028 }
26029 }
26030 {
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26033
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 Py_INCREF(Py_None); resultobj = Py_None;
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26045 PyObject *resultobj;
26046 wxWindow *arg1 = (wxWindow *) 0 ;
26047 wxSize *arg2 = 0 ;
26048 wxSize const &arg3_defvalue = wxDefaultSize ;
26049 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26050 wxSize const &arg4_defvalue = wxDefaultSize ;
26051 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26052 wxSize temp2 ;
26053 wxSize temp3 ;
26054 wxSize temp4 ;
26055 PyObject * obj0 = 0 ;
26056 PyObject * obj1 = 0 ;
26057 PyObject * obj2 = 0 ;
26058 PyObject * obj3 = 0 ;
26059 char *kwnames[] = {
26060 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26061 };
26062
26063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26065 if (SWIG_arg_fail(1)) SWIG_fail;
26066 {
26067 arg2 = &temp2;
26068 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26069 }
26070 if (obj2) {
26071 {
26072 arg3 = &temp3;
26073 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26074 }
26075 }
26076 if (obj3) {
26077 {
26078 arg4 = &temp4;
26079 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26080 }
26081 }
26082 {
26083 PyThreadState* __tstate = wxPyBeginAllowThreads();
26084 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26085
26086 wxPyEndAllowThreads(__tstate);
26087 if (PyErr_Occurred()) SWIG_fail;
26088 }
26089 Py_INCREF(Py_None); resultobj = Py_None;
26090 return resultobj;
26091 fail:
26092 return NULL;
26093 }
26094
26095
26096 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26097 PyObject *resultobj;
26098 wxWindow *arg1 = (wxWindow *) 0 ;
26099 int arg2 ;
26100 int arg3 ;
26101 int arg4 = (int) -1 ;
26102 int arg5 = (int) -1 ;
26103 PyObject * obj0 = 0 ;
26104 PyObject * obj1 = 0 ;
26105 PyObject * obj2 = 0 ;
26106 PyObject * obj3 = 0 ;
26107 PyObject * obj4 = 0 ;
26108 char *kwnames[] = {
26109 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26110 };
26111
26112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26114 if (SWIG_arg_fail(1)) SWIG_fail;
26115 {
26116 arg2 = (int)(SWIG_As_int(obj1));
26117 if (SWIG_arg_fail(2)) SWIG_fail;
26118 }
26119 {
26120 arg3 = (int)(SWIG_As_int(obj2));
26121 if (SWIG_arg_fail(3)) SWIG_fail;
26122 }
26123 if (obj3) {
26124 {
26125 arg4 = (int)(SWIG_As_int(obj3));
26126 if (SWIG_arg_fail(4)) SWIG_fail;
26127 }
26128 }
26129 if (obj4) {
26130 {
26131 arg5 = (int)(SWIG_As_int(obj4));
26132 if (SWIG_arg_fail(5)) SWIG_fail;
26133 }
26134 }
26135 {
26136 PyThreadState* __tstate = wxPyBeginAllowThreads();
26137 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26138
26139 wxPyEndAllowThreads(__tstate);
26140 if (PyErr_Occurred()) SWIG_fail;
26141 }
26142 Py_INCREF(Py_None); resultobj = Py_None;
26143 return resultobj;
26144 fail:
26145 return NULL;
26146 }
26147
26148
26149 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26150 PyObject *resultobj;
26151 wxWindow *arg1 = (wxWindow *) 0 ;
26152 wxSize *arg2 = 0 ;
26153 wxSize const &arg3_defvalue = wxDefaultSize ;
26154 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26155 wxSize temp2 ;
26156 wxSize temp3 ;
26157 PyObject * obj0 = 0 ;
26158 PyObject * obj1 = 0 ;
26159 PyObject * obj2 = 0 ;
26160 char *kwnames[] = {
26161 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26162 };
26163
26164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26166 if (SWIG_arg_fail(1)) SWIG_fail;
26167 {
26168 arg2 = &temp2;
26169 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26170 }
26171 if (obj2) {
26172 {
26173 arg3 = &temp3;
26174 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26175 }
26176 }
26177 {
26178 PyThreadState* __tstate = wxPyBeginAllowThreads();
26179 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26180
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 Py_INCREF(Py_None); resultobj = Py_None;
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26192 PyObject *resultobj;
26193 wxWindow *arg1 = (wxWindow *) 0 ;
26194 wxSize result;
26195 PyObject * obj0 = 0 ;
26196 char *kwnames[] = {
26197 (char *) "self", NULL
26198 };
26199
26200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26202 if (SWIG_arg_fail(1)) SWIG_fail;
26203 {
26204 PyThreadState* __tstate = wxPyBeginAllowThreads();
26205 result = ((wxWindow const *)arg1)->GetMaxSize();
26206
26207 wxPyEndAllowThreads(__tstate);
26208 if (PyErr_Occurred()) SWIG_fail;
26209 }
26210 {
26211 wxSize * resultptr;
26212 resultptr = new wxSize((wxSize &)(result));
26213 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26214 }
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26222 PyObject *resultobj;
26223 wxWindow *arg1 = (wxWindow *) 0 ;
26224 wxSize result;
26225 PyObject * obj0 = 0 ;
26226 char *kwnames[] = {
26227 (char *) "self", NULL
26228 };
26229
26230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26232 if (SWIG_arg_fail(1)) SWIG_fail;
26233 {
26234 PyThreadState* __tstate = wxPyBeginAllowThreads();
26235 result = ((wxWindow const *)arg1)->GetMinSize();
26236
26237 wxPyEndAllowThreads(__tstate);
26238 if (PyErr_Occurred()) SWIG_fail;
26239 }
26240 {
26241 wxSize * resultptr;
26242 resultptr = new wxSize((wxSize &)(result));
26243 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26244 }
26245 return resultobj;
26246 fail:
26247 return NULL;
26248 }
26249
26250
26251 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26252 PyObject *resultobj;
26253 wxWindow *arg1 = (wxWindow *) 0 ;
26254 wxSize *arg2 = 0 ;
26255 wxSize temp2 ;
26256 PyObject * obj0 = 0 ;
26257 PyObject * obj1 = 0 ;
26258 char *kwnames[] = {
26259 (char *) "self",(char *) "minSize", NULL
26260 };
26261
26262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26264 if (SWIG_arg_fail(1)) SWIG_fail;
26265 {
26266 arg2 = &temp2;
26267 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26268 }
26269 {
26270 PyThreadState* __tstate = wxPyBeginAllowThreads();
26271 (arg1)->SetMinSize((wxSize const &)*arg2);
26272
26273 wxPyEndAllowThreads(__tstate);
26274 if (PyErr_Occurred()) SWIG_fail;
26275 }
26276 Py_INCREF(Py_None); resultobj = Py_None;
26277 return resultobj;
26278 fail:
26279 return NULL;
26280 }
26281
26282
26283 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26284 PyObject *resultobj;
26285 wxWindow *arg1 = (wxWindow *) 0 ;
26286 wxSize *arg2 = 0 ;
26287 wxSize temp2 ;
26288 PyObject * obj0 = 0 ;
26289 PyObject * obj1 = 0 ;
26290 char *kwnames[] = {
26291 (char *) "self",(char *) "maxSize", NULL
26292 };
26293
26294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26296 if (SWIG_arg_fail(1)) SWIG_fail;
26297 {
26298 arg2 = &temp2;
26299 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26300 }
26301 {
26302 PyThreadState* __tstate = wxPyBeginAllowThreads();
26303 (arg1)->SetMaxSize((wxSize const &)*arg2);
26304
26305 wxPyEndAllowThreads(__tstate);
26306 if (PyErr_Occurred()) SWIG_fail;
26307 }
26308 Py_INCREF(Py_None); resultobj = Py_None;
26309 return resultobj;
26310 fail:
26311 return NULL;
26312 }
26313
26314
26315 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26316 PyObject *resultobj;
26317 wxWindow *arg1 = (wxWindow *) 0 ;
26318 int result;
26319 PyObject * obj0 = 0 ;
26320 char *kwnames[] = {
26321 (char *) "self", NULL
26322 };
26323
26324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26326 if (SWIG_arg_fail(1)) SWIG_fail;
26327 {
26328 PyThreadState* __tstate = wxPyBeginAllowThreads();
26329 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26330
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 {
26335 resultobj = SWIG_From_int((int)(result));
26336 }
26337 return resultobj;
26338 fail:
26339 return NULL;
26340 }
26341
26342
26343 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26344 PyObject *resultobj;
26345 wxWindow *arg1 = (wxWindow *) 0 ;
26346 int result;
26347 PyObject * obj0 = 0 ;
26348 char *kwnames[] = {
26349 (char *) "self", NULL
26350 };
26351
26352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26354 if (SWIG_arg_fail(1)) SWIG_fail;
26355 {
26356 PyThreadState* __tstate = wxPyBeginAllowThreads();
26357 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26358
26359 wxPyEndAllowThreads(__tstate);
26360 if (PyErr_Occurred()) SWIG_fail;
26361 }
26362 {
26363 resultobj = SWIG_From_int((int)(result));
26364 }
26365 return resultobj;
26366 fail:
26367 return NULL;
26368 }
26369
26370
26371 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26372 PyObject *resultobj;
26373 wxWindow *arg1 = (wxWindow *) 0 ;
26374 int result;
26375 PyObject * obj0 = 0 ;
26376 char *kwnames[] = {
26377 (char *) "self", NULL
26378 };
26379
26380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26382 if (SWIG_arg_fail(1)) SWIG_fail;
26383 {
26384 PyThreadState* __tstate = wxPyBeginAllowThreads();
26385 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26386
26387 wxPyEndAllowThreads(__tstate);
26388 if (PyErr_Occurred()) SWIG_fail;
26389 }
26390 {
26391 resultobj = SWIG_From_int((int)(result));
26392 }
26393 return resultobj;
26394 fail:
26395 return NULL;
26396 }
26397
26398
26399 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26400 PyObject *resultobj;
26401 wxWindow *arg1 = (wxWindow *) 0 ;
26402 int result;
26403 PyObject * obj0 = 0 ;
26404 char *kwnames[] = {
26405 (char *) "self", NULL
26406 };
26407
26408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26410 if (SWIG_arg_fail(1)) SWIG_fail;
26411 {
26412 PyThreadState* __tstate = wxPyBeginAllowThreads();
26413 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26414
26415 wxPyEndAllowThreads(__tstate);
26416 if (PyErr_Occurred()) SWIG_fail;
26417 }
26418 {
26419 resultobj = SWIG_From_int((int)(result));
26420 }
26421 return resultobj;
26422 fail:
26423 return NULL;
26424 }
26425
26426
26427 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26428 PyObject *resultobj;
26429 wxWindow *arg1 = (wxWindow *) 0 ;
26430 wxSize *arg2 = 0 ;
26431 wxSize temp2 ;
26432 PyObject * obj0 = 0 ;
26433 PyObject * obj1 = 0 ;
26434 char *kwnames[] = {
26435 (char *) "self",(char *) "size", NULL
26436 };
26437
26438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26440 if (SWIG_arg_fail(1)) SWIG_fail;
26441 {
26442 arg2 = &temp2;
26443 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26444 }
26445 {
26446 PyThreadState* __tstate = wxPyBeginAllowThreads();
26447 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26448
26449 wxPyEndAllowThreads(__tstate);
26450 if (PyErr_Occurred()) SWIG_fail;
26451 }
26452 Py_INCREF(Py_None); resultobj = Py_None;
26453 return resultobj;
26454 fail:
26455 return NULL;
26456 }
26457
26458
26459 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26460 PyObject *resultobj;
26461 wxWindow *arg1 = (wxWindow *) 0 ;
26462 int arg2 ;
26463 int arg3 ;
26464 PyObject * obj0 = 0 ;
26465 PyObject * obj1 = 0 ;
26466 PyObject * obj2 = 0 ;
26467 char *kwnames[] = {
26468 (char *) "self",(char *) "w",(char *) "h", NULL
26469 };
26470
26471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26473 if (SWIG_arg_fail(1)) SWIG_fail;
26474 {
26475 arg2 = (int)(SWIG_As_int(obj1));
26476 if (SWIG_arg_fail(2)) SWIG_fail;
26477 }
26478 {
26479 arg3 = (int)(SWIG_As_int(obj2));
26480 if (SWIG_arg_fail(3)) SWIG_fail;
26481 }
26482 {
26483 PyThreadState* __tstate = wxPyBeginAllowThreads();
26484 (arg1)->SetVirtualSize(arg2,arg3);
26485
26486 wxPyEndAllowThreads(__tstate);
26487 if (PyErr_Occurred()) SWIG_fail;
26488 }
26489 Py_INCREF(Py_None); resultobj = Py_None;
26490 return resultobj;
26491 fail:
26492 return NULL;
26493 }
26494
26495
26496 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26497 PyObject *resultobj;
26498 wxWindow *arg1 = (wxWindow *) 0 ;
26499 wxSize result;
26500 PyObject * obj0 = 0 ;
26501 char *kwnames[] = {
26502 (char *) "self", NULL
26503 };
26504
26505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26507 if (SWIG_arg_fail(1)) SWIG_fail;
26508 {
26509 PyThreadState* __tstate = wxPyBeginAllowThreads();
26510 result = ((wxWindow const *)arg1)->GetVirtualSize();
26511
26512 wxPyEndAllowThreads(__tstate);
26513 if (PyErr_Occurred()) SWIG_fail;
26514 }
26515 {
26516 wxSize * resultptr;
26517 resultptr = new wxSize((wxSize &)(result));
26518 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26519 }
26520 return resultobj;
26521 fail:
26522 return NULL;
26523 }
26524
26525
26526 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26527 PyObject *resultobj;
26528 wxWindow *arg1 = (wxWindow *) 0 ;
26529 int *arg2 = (int *) 0 ;
26530 int *arg3 = (int *) 0 ;
26531 int temp2 ;
26532 int res2 = 0 ;
26533 int temp3 ;
26534 int res3 = 0 ;
26535 PyObject * obj0 = 0 ;
26536 char *kwnames[] = {
26537 (char *) "self", NULL
26538 };
26539
26540 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26541 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26544 if (SWIG_arg_fail(1)) SWIG_fail;
26545 {
26546 PyThreadState* __tstate = wxPyBeginAllowThreads();
26547 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26548
26549 wxPyEndAllowThreads(__tstate);
26550 if (PyErr_Occurred()) SWIG_fail;
26551 }
26552 Py_INCREF(Py_None); resultobj = Py_None;
26553 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26554 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26555 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26556 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26557 return resultobj;
26558 fail:
26559 return NULL;
26560 }
26561
26562
26563 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26564 PyObject *resultobj;
26565 wxWindow *arg1 = (wxWindow *) 0 ;
26566 wxSize result;
26567 PyObject * obj0 = 0 ;
26568 char *kwnames[] = {
26569 (char *) "self", NULL
26570 };
26571
26572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26574 if (SWIG_arg_fail(1)) SWIG_fail;
26575 {
26576 PyThreadState* __tstate = wxPyBeginAllowThreads();
26577 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26578
26579 wxPyEndAllowThreads(__tstate);
26580 if (PyErr_Occurred()) SWIG_fail;
26581 }
26582 {
26583 wxSize * resultptr;
26584 resultptr = new wxSize((wxSize &)(result));
26585 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26586 }
26587 return resultobj;
26588 fail:
26589 return NULL;
26590 }
26591
26592
26593 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26594 PyObject *resultobj;
26595 wxWindow *arg1 = (wxWindow *) 0 ;
26596 bool arg2 = (bool) true ;
26597 bool result;
26598 PyObject * obj0 = 0 ;
26599 PyObject * obj1 = 0 ;
26600 char *kwnames[] = {
26601 (char *) "self",(char *) "show", NULL
26602 };
26603
26604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26606 if (SWIG_arg_fail(1)) SWIG_fail;
26607 if (obj1) {
26608 {
26609 arg2 = (bool)(SWIG_As_bool(obj1));
26610 if (SWIG_arg_fail(2)) SWIG_fail;
26611 }
26612 }
26613 {
26614 PyThreadState* __tstate = wxPyBeginAllowThreads();
26615 result = (bool)(arg1)->Show(arg2);
26616
26617 wxPyEndAllowThreads(__tstate);
26618 if (PyErr_Occurred()) SWIG_fail;
26619 }
26620 {
26621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26622 }
26623 return resultobj;
26624 fail:
26625 return NULL;
26626 }
26627
26628
26629 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26630 PyObject *resultobj;
26631 wxWindow *arg1 = (wxWindow *) 0 ;
26632 bool result;
26633 PyObject * obj0 = 0 ;
26634 char *kwnames[] = {
26635 (char *) "self", NULL
26636 };
26637
26638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26640 if (SWIG_arg_fail(1)) SWIG_fail;
26641 {
26642 PyThreadState* __tstate = wxPyBeginAllowThreads();
26643 result = (bool)(arg1)->Hide();
26644
26645 wxPyEndAllowThreads(__tstate);
26646 if (PyErr_Occurred()) SWIG_fail;
26647 }
26648 {
26649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26650 }
26651 return resultobj;
26652 fail:
26653 return NULL;
26654 }
26655
26656
26657 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26658 PyObject *resultobj;
26659 wxWindow *arg1 = (wxWindow *) 0 ;
26660 bool arg2 = (bool) true ;
26661 bool result;
26662 PyObject * obj0 = 0 ;
26663 PyObject * obj1 = 0 ;
26664 char *kwnames[] = {
26665 (char *) "self",(char *) "enable", NULL
26666 };
26667
26668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26670 if (SWIG_arg_fail(1)) SWIG_fail;
26671 if (obj1) {
26672 {
26673 arg2 = (bool)(SWIG_As_bool(obj1));
26674 if (SWIG_arg_fail(2)) SWIG_fail;
26675 }
26676 }
26677 {
26678 PyThreadState* __tstate = wxPyBeginAllowThreads();
26679 result = (bool)(arg1)->Enable(arg2);
26680
26681 wxPyEndAllowThreads(__tstate);
26682 if (PyErr_Occurred()) SWIG_fail;
26683 }
26684 {
26685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26686 }
26687 return resultobj;
26688 fail:
26689 return NULL;
26690 }
26691
26692
26693 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26694 PyObject *resultobj;
26695 wxWindow *arg1 = (wxWindow *) 0 ;
26696 bool result;
26697 PyObject * obj0 = 0 ;
26698 char *kwnames[] = {
26699 (char *) "self", NULL
26700 };
26701
26702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26704 if (SWIG_arg_fail(1)) SWIG_fail;
26705 {
26706 PyThreadState* __tstate = wxPyBeginAllowThreads();
26707 result = (bool)(arg1)->Disable();
26708
26709 wxPyEndAllowThreads(__tstate);
26710 if (PyErr_Occurred()) SWIG_fail;
26711 }
26712 {
26713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26714 }
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26722 PyObject *resultobj;
26723 wxWindow *arg1 = (wxWindow *) 0 ;
26724 bool result;
26725 PyObject * obj0 = 0 ;
26726 char *kwnames[] = {
26727 (char *) "self", NULL
26728 };
26729
26730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26732 if (SWIG_arg_fail(1)) SWIG_fail;
26733 {
26734 PyThreadState* __tstate = wxPyBeginAllowThreads();
26735 result = (bool)((wxWindow const *)arg1)->IsShown();
26736
26737 wxPyEndAllowThreads(__tstate);
26738 if (PyErr_Occurred()) SWIG_fail;
26739 }
26740 {
26741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26742 }
26743 return resultobj;
26744 fail:
26745 return NULL;
26746 }
26747
26748
26749 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26750 PyObject *resultobj;
26751 wxWindow *arg1 = (wxWindow *) 0 ;
26752 bool result;
26753 PyObject * obj0 = 0 ;
26754 char *kwnames[] = {
26755 (char *) "self", NULL
26756 };
26757
26758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
26759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26760 if (SWIG_arg_fail(1)) SWIG_fail;
26761 {
26762 PyThreadState* __tstate = wxPyBeginAllowThreads();
26763 result = (bool)((wxWindow const *)arg1)->IsEnabled();
26764
26765 wxPyEndAllowThreads(__tstate);
26766 if (PyErr_Occurred()) SWIG_fail;
26767 }
26768 {
26769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26770 }
26771 return resultobj;
26772 fail:
26773 return NULL;
26774 }
26775
26776
26777 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26778 PyObject *resultobj;
26779 wxWindow *arg1 = (wxWindow *) 0 ;
26780 long arg2 ;
26781 PyObject * obj0 = 0 ;
26782 PyObject * obj1 = 0 ;
26783 char *kwnames[] = {
26784 (char *) "self",(char *) "style", NULL
26785 };
26786
26787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
26788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26789 if (SWIG_arg_fail(1)) SWIG_fail;
26790 {
26791 arg2 = (long)(SWIG_As_long(obj1));
26792 if (SWIG_arg_fail(2)) SWIG_fail;
26793 }
26794 {
26795 PyThreadState* __tstate = wxPyBeginAllowThreads();
26796 (arg1)->SetWindowStyleFlag(arg2);
26797
26798 wxPyEndAllowThreads(__tstate);
26799 if (PyErr_Occurred()) SWIG_fail;
26800 }
26801 Py_INCREF(Py_None); resultobj = Py_None;
26802 return resultobj;
26803 fail:
26804 return NULL;
26805 }
26806
26807
26808 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26809 PyObject *resultobj;
26810 wxWindow *arg1 = (wxWindow *) 0 ;
26811 long result;
26812 PyObject * obj0 = 0 ;
26813 char *kwnames[] = {
26814 (char *) "self", NULL
26815 };
26816
26817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
26818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26819 if (SWIG_arg_fail(1)) SWIG_fail;
26820 {
26821 PyThreadState* __tstate = wxPyBeginAllowThreads();
26822 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
26823
26824 wxPyEndAllowThreads(__tstate);
26825 if (PyErr_Occurred()) SWIG_fail;
26826 }
26827 {
26828 resultobj = SWIG_From_long((long)(result));
26829 }
26830 return resultobj;
26831 fail:
26832 return NULL;
26833 }
26834
26835
26836 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26837 PyObject *resultobj;
26838 wxWindow *arg1 = (wxWindow *) 0 ;
26839 int arg2 ;
26840 bool result;
26841 PyObject * obj0 = 0 ;
26842 PyObject * obj1 = 0 ;
26843 char *kwnames[] = {
26844 (char *) "self",(char *) "flag", NULL
26845 };
26846
26847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
26848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26849 if (SWIG_arg_fail(1)) SWIG_fail;
26850 {
26851 arg2 = (int)(SWIG_As_int(obj1));
26852 if (SWIG_arg_fail(2)) SWIG_fail;
26853 }
26854 {
26855 PyThreadState* __tstate = wxPyBeginAllowThreads();
26856 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
26857
26858 wxPyEndAllowThreads(__tstate);
26859 if (PyErr_Occurred()) SWIG_fail;
26860 }
26861 {
26862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26863 }
26864 return resultobj;
26865 fail:
26866 return NULL;
26867 }
26868
26869
26870 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
26871 PyObject *resultobj;
26872 wxWindow *arg1 = (wxWindow *) 0 ;
26873 bool result;
26874 PyObject * obj0 = 0 ;
26875 char *kwnames[] = {
26876 (char *) "self", NULL
26877 };
26878
26879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
26880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26881 if (SWIG_arg_fail(1)) SWIG_fail;
26882 {
26883 PyThreadState* __tstate = wxPyBeginAllowThreads();
26884 result = (bool)((wxWindow const *)arg1)->IsRetained();
26885
26886 wxPyEndAllowThreads(__tstate);
26887 if (PyErr_Occurred()) SWIG_fail;
26888 }
26889 {
26890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26891 }
26892 return resultobj;
26893 fail:
26894 return NULL;
26895 }
26896
26897
26898 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26899 PyObject *resultobj;
26900 wxWindow *arg1 = (wxWindow *) 0 ;
26901 long arg2 ;
26902 PyObject * obj0 = 0 ;
26903 PyObject * obj1 = 0 ;
26904 char *kwnames[] = {
26905 (char *) "self",(char *) "exStyle", NULL
26906 };
26907
26908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
26909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26910 if (SWIG_arg_fail(1)) SWIG_fail;
26911 {
26912 arg2 = (long)(SWIG_As_long(obj1));
26913 if (SWIG_arg_fail(2)) SWIG_fail;
26914 }
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 (arg1)->SetExtraStyle(arg2);
26918
26919 wxPyEndAllowThreads(__tstate);
26920 if (PyErr_Occurred()) SWIG_fail;
26921 }
26922 Py_INCREF(Py_None); resultobj = Py_None;
26923 return resultobj;
26924 fail:
26925 return NULL;
26926 }
26927
26928
26929 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26930 PyObject *resultobj;
26931 wxWindow *arg1 = (wxWindow *) 0 ;
26932 long result;
26933 PyObject * obj0 = 0 ;
26934 char *kwnames[] = {
26935 (char *) "self", NULL
26936 };
26937
26938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
26939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26940 if (SWIG_arg_fail(1)) SWIG_fail;
26941 {
26942 PyThreadState* __tstate = wxPyBeginAllowThreads();
26943 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
26944
26945 wxPyEndAllowThreads(__tstate);
26946 if (PyErr_Occurred()) SWIG_fail;
26947 }
26948 {
26949 resultobj = SWIG_From_long((long)(result));
26950 }
26951 return resultobj;
26952 fail:
26953 return NULL;
26954 }
26955
26956
26957 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
26958 PyObject *resultobj;
26959 wxWindow *arg1 = (wxWindow *) 0 ;
26960 bool arg2 = (bool) true ;
26961 PyObject * obj0 = 0 ;
26962 PyObject * obj1 = 0 ;
26963 char *kwnames[] = {
26964 (char *) "self",(char *) "modal", NULL
26965 };
26966
26967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
26968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26969 if (SWIG_arg_fail(1)) SWIG_fail;
26970 if (obj1) {
26971 {
26972 arg2 = (bool)(SWIG_As_bool(obj1));
26973 if (SWIG_arg_fail(2)) SWIG_fail;
26974 }
26975 }
26976 {
26977 PyThreadState* __tstate = wxPyBeginAllowThreads();
26978 (arg1)->MakeModal(arg2);
26979
26980 wxPyEndAllowThreads(__tstate);
26981 if (PyErr_Occurred()) SWIG_fail;
26982 }
26983 Py_INCREF(Py_None); resultobj = Py_None;
26984 return resultobj;
26985 fail:
26986 return NULL;
26987 }
26988
26989
26990 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26991 PyObject *resultobj;
26992 wxWindow *arg1 = (wxWindow *) 0 ;
26993 bool arg2 ;
26994 PyObject * obj0 = 0 ;
26995 PyObject * obj1 = 0 ;
26996 char *kwnames[] = {
26997 (char *) "self",(char *) "enableTheme", NULL
26998 };
26999
27000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27002 if (SWIG_arg_fail(1)) SWIG_fail;
27003 {
27004 arg2 = (bool)(SWIG_As_bool(obj1));
27005 if (SWIG_arg_fail(2)) SWIG_fail;
27006 }
27007 {
27008 PyThreadState* __tstate = wxPyBeginAllowThreads();
27009 (arg1)->SetThemeEnabled(arg2);
27010
27011 wxPyEndAllowThreads(__tstate);
27012 if (PyErr_Occurred()) SWIG_fail;
27013 }
27014 Py_INCREF(Py_None); resultobj = Py_None;
27015 return resultobj;
27016 fail:
27017 return NULL;
27018 }
27019
27020
27021 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27022 PyObject *resultobj;
27023 wxWindow *arg1 = (wxWindow *) 0 ;
27024 bool result;
27025 PyObject * obj0 = 0 ;
27026 char *kwnames[] = {
27027 (char *) "self", NULL
27028 };
27029
27030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27032 if (SWIG_arg_fail(1)) SWIG_fail;
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27036
27037 wxPyEndAllowThreads(__tstate);
27038 if (PyErr_Occurred()) SWIG_fail;
27039 }
27040 {
27041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27042 }
27043 return resultobj;
27044 fail:
27045 return NULL;
27046 }
27047
27048
27049 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27050 PyObject *resultobj;
27051 wxWindow *arg1 = (wxWindow *) 0 ;
27052 PyObject * obj0 = 0 ;
27053 char *kwnames[] = {
27054 (char *) "self", NULL
27055 };
27056
27057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27059 if (SWIG_arg_fail(1)) SWIG_fail;
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 (arg1)->SetFocus();
27063
27064 wxPyEndAllowThreads(__tstate);
27065 if (PyErr_Occurred()) SWIG_fail;
27066 }
27067 Py_INCREF(Py_None); resultobj = Py_None;
27068 return resultobj;
27069 fail:
27070 return NULL;
27071 }
27072
27073
27074 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27075 PyObject *resultobj;
27076 wxWindow *arg1 = (wxWindow *) 0 ;
27077 PyObject * obj0 = 0 ;
27078 char *kwnames[] = {
27079 (char *) "self", NULL
27080 };
27081
27082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27084 if (SWIG_arg_fail(1)) SWIG_fail;
27085 {
27086 PyThreadState* __tstate = wxPyBeginAllowThreads();
27087 (arg1)->SetFocusFromKbd();
27088
27089 wxPyEndAllowThreads(__tstate);
27090 if (PyErr_Occurred()) SWIG_fail;
27091 }
27092 Py_INCREF(Py_None); resultobj = Py_None;
27093 return resultobj;
27094 fail:
27095 return NULL;
27096 }
27097
27098
27099 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27100 PyObject *resultobj;
27101 wxWindow *result;
27102 char *kwnames[] = {
27103 NULL
27104 };
27105
27106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27107 {
27108 if (!wxPyCheckForApp()) SWIG_fail;
27109 PyThreadState* __tstate = wxPyBeginAllowThreads();
27110 result = (wxWindow *)wxWindow::FindFocus();
27111
27112 wxPyEndAllowThreads(__tstate);
27113 if (PyErr_Occurred()) SWIG_fail;
27114 }
27115 {
27116 resultobj = wxPyMake_wxObject(result, 0);
27117 }
27118 return resultobj;
27119 fail:
27120 return NULL;
27121 }
27122
27123
27124 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27125 PyObject *resultobj;
27126 wxWindow *arg1 = (wxWindow *) 0 ;
27127 bool result;
27128 PyObject * obj0 = 0 ;
27129 char *kwnames[] = {
27130 (char *) "self", NULL
27131 };
27132
27133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27135 if (SWIG_arg_fail(1)) SWIG_fail;
27136 {
27137 PyThreadState* __tstate = wxPyBeginAllowThreads();
27138 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27139
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 {
27144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27145 }
27146 return resultobj;
27147 fail:
27148 return NULL;
27149 }
27150
27151
27152 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27153 PyObject *resultobj;
27154 wxWindow *arg1 = (wxWindow *) 0 ;
27155 bool result;
27156 PyObject * obj0 = 0 ;
27157 char *kwnames[] = {
27158 (char *) "self", NULL
27159 };
27160
27161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27163 if (SWIG_arg_fail(1)) SWIG_fail;
27164 {
27165 PyThreadState* __tstate = wxPyBeginAllowThreads();
27166 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27167
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 {
27172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj;
27182 wxWindow *arg1 = (wxWindow *) 0 ;
27183 wxWindow *result;
27184 PyObject * obj0 = 0 ;
27185 char *kwnames[] = {
27186 (char *) "self", NULL
27187 };
27188
27189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27191 if (SWIG_arg_fail(1)) SWIG_fail;
27192 {
27193 PyThreadState* __tstate = wxPyBeginAllowThreads();
27194 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27195
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 {
27200 resultobj = wxPyMake_wxObject(result, 0);
27201 }
27202 return resultobj;
27203 fail:
27204 return NULL;
27205 }
27206
27207
27208 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27209 PyObject *resultobj;
27210 wxWindow *arg1 = (wxWindow *) 0 ;
27211 wxWindow *arg2 = (wxWindow *) 0 ;
27212 wxWindow *result;
27213 PyObject * obj0 = 0 ;
27214 PyObject * obj1 = 0 ;
27215 char *kwnames[] = {
27216 (char *) "self",(char *) "child", NULL
27217 };
27218
27219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27221 if (SWIG_arg_fail(1)) SWIG_fail;
27222 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27223 if (SWIG_arg_fail(2)) SWIG_fail;
27224 {
27225 PyThreadState* __tstate = wxPyBeginAllowThreads();
27226 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27227
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 {
27232 resultobj = wxPyMake_wxObject(result, 0);
27233 }
27234 return resultobj;
27235 fail:
27236 return NULL;
27237 }
27238
27239
27240 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27241 PyObject *resultobj;
27242 wxWindow *arg1 = (wxWindow *) 0 ;
27243 wxWindow *arg2 = (wxWindow *) 0 ;
27244 PyObject * obj0 = 0 ;
27245 PyObject * obj1 = 0 ;
27246 char *kwnames[] = {
27247 (char *) "self",(char *) "win", NULL
27248 };
27249
27250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27252 if (SWIG_arg_fail(1)) SWIG_fail;
27253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27254 if (SWIG_arg_fail(2)) SWIG_fail;
27255 {
27256 PyThreadState* __tstate = wxPyBeginAllowThreads();
27257 (arg1)->SetTmpDefaultItem(arg2);
27258
27259 wxPyEndAllowThreads(__tstate);
27260 if (PyErr_Occurred()) SWIG_fail;
27261 }
27262 Py_INCREF(Py_None); resultobj = Py_None;
27263 return resultobj;
27264 fail:
27265 return NULL;
27266 }
27267
27268
27269 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27270 PyObject *resultobj;
27271 wxWindow *arg1 = (wxWindow *) 0 ;
27272 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27273 bool result;
27274 PyObject * obj0 = 0 ;
27275 PyObject * obj1 = 0 ;
27276 char *kwnames[] = {
27277 (char *) "self",(char *) "flags", NULL
27278 };
27279
27280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27282 if (SWIG_arg_fail(1)) SWIG_fail;
27283 if (obj1) {
27284 {
27285 arg2 = (int)(SWIG_As_int(obj1));
27286 if (SWIG_arg_fail(2)) SWIG_fail;
27287 }
27288 }
27289 {
27290 PyThreadState* __tstate = wxPyBeginAllowThreads();
27291 result = (bool)(arg1)->Navigate(arg2);
27292
27293 wxPyEndAllowThreads(__tstate);
27294 if (PyErr_Occurred()) SWIG_fail;
27295 }
27296 {
27297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27298 }
27299 return resultobj;
27300 fail:
27301 return NULL;
27302 }
27303
27304
27305 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27306 PyObject *resultobj;
27307 wxWindow *arg1 = (wxWindow *) 0 ;
27308 wxWindow *arg2 = (wxWindow *) 0 ;
27309 PyObject * obj0 = 0 ;
27310 PyObject * obj1 = 0 ;
27311 char *kwnames[] = {
27312 (char *) "self",(char *) "win", NULL
27313 };
27314
27315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27317 if (SWIG_arg_fail(1)) SWIG_fail;
27318 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27319 if (SWIG_arg_fail(2)) SWIG_fail;
27320 {
27321 PyThreadState* __tstate = wxPyBeginAllowThreads();
27322 (arg1)->MoveAfterInTabOrder(arg2);
27323
27324 wxPyEndAllowThreads(__tstate);
27325 if (PyErr_Occurred()) SWIG_fail;
27326 }
27327 Py_INCREF(Py_None); resultobj = Py_None;
27328 return resultobj;
27329 fail:
27330 return NULL;
27331 }
27332
27333
27334 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27335 PyObject *resultobj;
27336 wxWindow *arg1 = (wxWindow *) 0 ;
27337 wxWindow *arg2 = (wxWindow *) 0 ;
27338 PyObject * obj0 = 0 ;
27339 PyObject * obj1 = 0 ;
27340 char *kwnames[] = {
27341 (char *) "self",(char *) "win", NULL
27342 };
27343
27344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27346 if (SWIG_arg_fail(1)) SWIG_fail;
27347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27348 if (SWIG_arg_fail(2)) SWIG_fail;
27349 {
27350 PyThreadState* __tstate = wxPyBeginAllowThreads();
27351 (arg1)->MoveBeforeInTabOrder(arg2);
27352
27353 wxPyEndAllowThreads(__tstate);
27354 if (PyErr_Occurred()) SWIG_fail;
27355 }
27356 Py_INCREF(Py_None); resultobj = Py_None;
27357 return resultobj;
27358 fail:
27359 return NULL;
27360 }
27361
27362
27363 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27364 PyObject *resultobj;
27365 wxWindow *arg1 = (wxWindow *) 0 ;
27366 PyObject *result;
27367 PyObject * obj0 = 0 ;
27368 char *kwnames[] = {
27369 (char *) "self", NULL
27370 };
27371
27372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27374 if (SWIG_arg_fail(1)) SWIG_fail;
27375 {
27376 PyThreadState* __tstate = wxPyBeginAllowThreads();
27377 result = (PyObject *)wxWindow_GetChildren(arg1);
27378
27379 wxPyEndAllowThreads(__tstate);
27380 if (PyErr_Occurred()) SWIG_fail;
27381 }
27382 resultobj = result;
27383 return resultobj;
27384 fail:
27385 return NULL;
27386 }
27387
27388
27389 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27390 PyObject *resultobj;
27391 wxWindow *arg1 = (wxWindow *) 0 ;
27392 wxWindow *result;
27393 PyObject * obj0 = 0 ;
27394 char *kwnames[] = {
27395 (char *) "self", NULL
27396 };
27397
27398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27400 if (SWIG_arg_fail(1)) SWIG_fail;
27401 {
27402 PyThreadState* __tstate = wxPyBeginAllowThreads();
27403 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27404
27405 wxPyEndAllowThreads(__tstate);
27406 if (PyErr_Occurred()) SWIG_fail;
27407 }
27408 {
27409 resultobj = wxPyMake_wxObject(result, 0);
27410 }
27411 return resultobj;
27412 fail:
27413 return NULL;
27414 }
27415
27416
27417 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27418 PyObject *resultobj;
27419 wxWindow *arg1 = (wxWindow *) 0 ;
27420 wxWindow *result;
27421 PyObject * obj0 = 0 ;
27422 char *kwnames[] = {
27423 (char *) "self", NULL
27424 };
27425
27426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27428 if (SWIG_arg_fail(1)) SWIG_fail;
27429 {
27430 PyThreadState* __tstate = wxPyBeginAllowThreads();
27431 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27432
27433 wxPyEndAllowThreads(__tstate);
27434 if (PyErr_Occurred()) SWIG_fail;
27435 }
27436 {
27437 resultobj = wxPyMake_wxObject(result, 0);
27438 }
27439 return resultobj;
27440 fail:
27441 return NULL;
27442 }
27443
27444
27445 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27446 PyObject *resultobj;
27447 wxWindow *arg1 = (wxWindow *) 0 ;
27448 bool result;
27449 PyObject * obj0 = 0 ;
27450 char *kwnames[] = {
27451 (char *) "self", NULL
27452 };
27453
27454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27456 if (SWIG_arg_fail(1)) SWIG_fail;
27457 {
27458 PyThreadState* __tstate = wxPyBeginAllowThreads();
27459 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27460
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 {
27465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27466 }
27467 return resultobj;
27468 fail:
27469 return NULL;
27470 }
27471
27472
27473 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27474 PyObject *resultobj;
27475 wxWindow *arg1 = (wxWindow *) 0 ;
27476 wxWindow *arg2 = (wxWindow *) 0 ;
27477 bool result;
27478 PyObject * obj0 = 0 ;
27479 PyObject * obj1 = 0 ;
27480 char *kwnames[] = {
27481 (char *) "self",(char *) "newParent", NULL
27482 };
27483
27484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27486 if (SWIG_arg_fail(1)) SWIG_fail;
27487 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27488 if (SWIG_arg_fail(2)) SWIG_fail;
27489 {
27490 PyThreadState* __tstate = wxPyBeginAllowThreads();
27491 result = (bool)(arg1)->Reparent(arg2);
27492
27493 wxPyEndAllowThreads(__tstate);
27494 if (PyErr_Occurred()) SWIG_fail;
27495 }
27496 {
27497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27498 }
27499 return resultobj;
27500 fail:
27501 return NULL;
27502 }
27503
27504
27505 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27506 PyObject *resultobj;
27507 wxWindow *arg1 = (wxWindow *) 0 ;
27508 wxWindow *arg2 = (wxWindow *) 0 ;
27509 PyObject * obj0 = 0 ;
27510 PyObject * obj1 = 0 ;
27511 char *kwnames[] = {
27512 (char *) "self",(char *) "child", NULL
27513 };
27514
27515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27517 if (SWIG_arg_fail(1)) SWIG_fail;
27518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27519 if (SWIG_arg_fail(2)) SWIG_fail;
27520 {
27521 PyThreadState* __tstate = wxPyBeginAllowThreads();
27522 (arg1)->AddChild(arg2);
27523
27524 wxPyEndAllowThreads(__tstate);
27525 if (PyErr_Occurred()) SWIG_fail;
27526 }
27527 Py_INCREF(Py_None); resultobj = Py_None;
27528 return resultobj;
27529 fail:
27530 return NULL;
27531 }
27532
27533
27534 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27535 PyObject *resultobj;
27536 wxWindow *arg1 = (wxWindow *) 0 ;
27537 wxWindow *arg2 = (wxWindow *) 0 ;
27538 PyObject * obj0 = 0 ;
27539 PyObject * obj1 = 0 ;
27540 char *kwnames[] = {
27541 (char *) "self",(char *) "child", NULL
27542 };
27543
27544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27546 if (SWIG_arg_fail(1)) SWIG_fail;
27547 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27548 if (SWIG_arg_fail(2)) SWIG_fail;
27549 {
27550 PyThreadState* __tstate = wxPyBeginAllowThreads();
27551 (arg1)->RemoveChild(arg2);
27552
27553 wxPyEndAllowThreads(__tstate);
27554 if (PyErr_Occurred()) SWIG_fail;
27555 }
27556 Py_INCREF(Py_None); resultobj = Py_None;
27557 return resultobj;
27558 fail:
27559 return NULL;
27560 }
27561
27562
27563 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27564 PyObject *resultobj;
27565 wxWindow *arg1 = (wxWindow *) 0 ;
27566 long arg2 ;
27567 wxWindow *result;
27568 PyObject * obj0 = 0 ;
27569 PyObject * obj1 = 0 ;
27570 char *kwnames[] = {
27571 (char *) "self",(char *) "winid", NULL
27572 };
27573
27574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27576 if (SWIG_arg_fail(1)) SWIG_fail;
27577 {
27578 arg2 = (long)(SWIG_As_long(obj1));
27579 if (SWIG_arg_fail(2)) SWIG_fail;
27580 }
27581 {
27582 PyThreadState* __tstate = wxPyBeginAllowThreads();
27583 result = (wxWindow *)(arg1)->FindWindow(arg2);
27584
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 {
27589 resultobj = wxPyMake_wxObject(result, 0);
27590 }
27591 return resultobj;
27592 fail:
27593 return NULL;
27594 }
27595
27596
27597 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27598 PyObject *resultobj;
27599 wxWindow *arg1 = (wxWindow *) 0 ;
27600 wxString *arg2 = 0 ;
27601 wxWindow *result;
27602 bool temp2 = false ;
27603 PyObject * obj0 = 0 ;
27604 PyObject * obj1 = 0 ;
27605 char *kwnames[] = {
27606 (char *) "self",(char *) "name", NULL
27607 };
27608
27609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27611 if (SWIG_arg_fail(1)) SWIG_fail;
27612 {
27613 arg2 = wxString_in_helper(obj1);
27614 if (arg2 == NULL) SWIG_fail;
27615 temp2 = true;
27616 }
27617 {
27618 PyThreadState* __tstate = wxPyBeginAllowThreads();
27619 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27620
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 {
27625 resultobj = wxPyMake_wxObject(result, 0);
27626 }
27627 {
27628 if (temp2)
27629 delete arg2;
27630 }
27631 return resultobj;
27632 fail:
27633 {
27634 if (temp2)
27635 delete arg2;
27636 }
27637 return NULL;
27638 }
27639
27640
27641 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27642 PyObject *resultobj;
27643 wxWindow *arg1 = (wxWindow *) 0 ;
27644 wxEvtHandler *result;
27645 PyObject * obj0 = 0 ;
27646 char *kwnames[] = {
27647 (char *) "self", NULL
27648 };
27649
27650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27652 if (SWIG_arg_fail(1)) SWIG_fail;
27653 {
27654 PyThreadState* __tstate = wxPyBeginAllowThreads();
27655 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27656
27657 wxPyEndAllowThreads(__tstate);
27658 if (PyErr_Occurred()) SWIG_fail;
27659 }
27660 {
27661 resultobj = wxPyMake_wxObject(result, 0);
27662 }
27663 return resultobj;
27664 fail:
27665 return NULL;
27666 }
27667
27668
27669 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27670 PyObject *resultobj;
27671 wxWindow *arg1 = (wxWindow *) 0 ;
27672 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27673 PyObject * obj0 = 0 ;
27674 PyObject * obj1 = 0 ;
27675 char *kwnames[] = {
27676 (char *) "self",(char *) "handler", NULL
27677 };
27678
27679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27681 if (SWIG_arg_fail(1)) SWIG_fail;
27682 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27683 if (SWIG_arg_fail(2)) SWIG_fail;
27684 {
27685 PyThreadState* __tstate = wxPyBeginAllowThreads();
27686 (arg1)->SetEventHandler(arg2);
27687
27688 wxPyEndAllowThreads(__tstate);
27689 if (PyErr_Occurred()) SWIG_fail;
27690 }
27691 Py_INCREF(Py_None); resultobj = Py_None;
27692 return resultobj;
27693 fail:
27694 return NULL;
27695 }
27696
27697
27698 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27699 PyObject *resultobj;
27700 wxWindow *arg1 = (wxWindow *) 0 ;
27701 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27702 PyObject * obj0 = 0 ;
27703 PyObject * obj1 = 0 ;
27704 char *kwnames[] = {
27705 (char *) "self",(char *) "handler", NULL
27706 };
27707
27708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27710 if (SWIG_arg_fail(1)) SWIG_fail;
27711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27712 if (SWIG_arg_fail(2)) SWIG_fail;
27713 {
27714 PyThreadState* __tstate = wxPyBeginAllowThreads();
27715 (arg1)->PushEventHandler(arg2);
27716
27717 wxPyEndAllowThreads(__tstate);
27718 if (PyErr_Occurred()) SWIG_fail;
27719 }
27720 Py_INCREF(Py_None); resultobj = Py_None;
27721 return resultobj;
27722 fail:
27723 return NULL;
27724 }
27725
27726
27727 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27728 PyObject *resultobj;
27729 wxWindow *arg1 = (wxWindow *) 0 ;
27730 bool arg2 = (bool) false ;
27731 wxEvtHandler *result;
27732 PyObject * obj0 = 0 ;
27733 PyObject * obj1 = 0 ;
27734 char *kwnames[] = {
27735 (char *) "self",(char *) "deleteHandler", NULL
27736 };
27737
27738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
27739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27740 if (SWIG_arg_fail(1)) SWIG_fail;
27741 if (obj1) {
27742 {
27743 arg2 = (bool)(SWIG_As_bool(obj1));
27744 if (SWIG_arg_fail(2)) SWIG_fail;
27745 }
27746 }
27747 {
27748 PyThreadState* __tstate = wxPyBeginAllowThreads();
27749 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
27750
27751 wxPyEndAllowThreads(__tstate);
27752 if (PyErr_Occurred()) SWIG_fail;
27753 }
27754 {
27755 resultobj = wxPyMake_wxObject(result, 0);
27756 }
27757 return resultobj;
27758 fail:
27759 return NULL;
27760 }
27761
27762
27763 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27764 PyObject *resultobj;
27765 wxWindow *arg1 = (wxWindow *) 0 ;
27766 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27767 bool result;
27768 PyObject * obj0 = 0 ;
27769 PyObject * obj1 = 0 ;
27770 char *kwnames[] = {
27771 (char *) "self",(char *) "handler", NULL
27772 };
27773
27774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
27775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27776 if (SWIG_arg_fail(1)) SWIG_fail;
27777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27778 if (SWIG_arg_fail(2)) SWIG_fail;
27779 {
27780 PyThreadState* __tstate = wxPyBeginAllowThreads();
27781 result = (bool)(arg1)->RemoveEventHandler(arg2);
27782
27783 wxPyEndAllowThreads(__tstate);
27784 if (PyErr_Occurred()) SWIG_fail;
27785 }
27786 {
27787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27788 }
27789 return resultobj;
27790 fail:
27791 return NULL;
27792 }
27793
27794
27795 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27796 PyObject *resultobj;
27797 wxWindow *arg1 = (wxWindow *) 0 ;
27798 wxValidator *arg2 = 0 ;
27799 PyObject * obj0 = 0 ;
27800 PyObject * obj1 = 0 ;
27801 char *kwnames[] = {
27802 (char *) "self",(char *) "validator", NULL
27803 };
27804
27805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
27806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27807 if (SWIG_arg_fail(1)) SWIG_fail;
27808 {
27809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
27810 if (SWIG_arg_fail(2)) SWIG_fail;
27811 if (arg2 == NULL) {
27812 SWIG_null_ref("wxValidator");
27813 }
27814 if (SWIG_arg_fail(2)) SWIG_fail;
27815 }
27816 {
27817 PyThreadState* __tstate = wxPyBeginAllowThreads();
27818 (arg1)->SetValidator((wxValidator const &)*arg2);
27819
27820 wxPyEndAllowThreads(__tstate);
27821 if (PyErr_Occurred()) SWIG_fail;
27822 }
27823 Py_INCREF(Py_None); resultobj = Py_None;
27824 return resultobj;
27825 fail:
27826 return NULL;
27827 }
27828
27829
27830 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27831 PyObject *resultobj;
27832 wxWindow *arg1 = (wxWindow *) 0 ;
27833 wxValidator *result;
27834 PyObject * obj0 = 0 ;
27835 char *kwnames[] = {
27836 (char *) "self", NULL
27837 };
27838
27839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
27840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27841 if (SWIG_arg_fail(1)) SWIG_fail;
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 result = (wxValidator *)(arg1)->GetValidator();
27845
27846 wxPyEndAllowThreads(__tstate);
27847 if (PyErr_Occurred()) SWIG_fail;
27848 }
27849 {
27850 resultobj = wxPyMake_wxObject(result, 0);
27851 }
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
27859 PyObject *resultobj;
27860 wxWindow *arg1 = (wxWindow *) 0 ;
27861 bool result;
27862 PyObject * obj0 = 0 ;
27863 char *kwnames[] = {
27864 (char *) "self", NULL
27865 };
27866
27867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
27868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27869 if (SWIG_arg_fail(1)) SWIG_fail;
27870 {
27871 PyThreadState* __tstate = wxPyBeginAllowThreads();
27872 result = (bool)(arg1)->Validate();
27873
27874 wxPyEndAllowThreads(__tstate);
27875 if (PyErr_Occurred()) SWIG_fail;
27876 }
27877 {
27878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27879 }
27880 return resultobj;
27881 fail:
27882 return NULL;
27883 }
27884
27885
27886 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27887 PyObject *resultobj;
27888 wxWindow *arg1 = (wxWindow *) 0 ;
27889 bool result;
27890 PyObject * obj0 = 0 ;
27891 char *kwnames[] = {
27892 (char *) "self", NULL
27893 };
27894
27895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
27896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27897 if (SWIG_arg_fail(1)) SWIG_fail;
27898 {
27899 PyThreadState* __tstate = wxPyBeginAllowThreads();
27900 result = (bool)(arg1)->TransferDataToWindow();
27901
27902 wxPyEndAllowThreads(__tstate);
27903 if (PyErr_Occurred()) SWIG_fail;
27904 }
27905 {
27906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27907 }
27908 return resultobj;
27909 fail:
27910 return NULL;
27911 }
27912
27913
27914 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27915 PyObject *resultobj;
27916 wxWindow *arg1 = (wxWindow *) 0 ;
27917 bool result;
27918 PyObject * obj0 = 0 ;
27919 char *kwnames[] = {
27920 (char *) "self", NULL
27921 };
27922
27923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
27924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27925 if (SWIG_arg_fail(1)) SWIG_fail;
27926 {
27927 PyThreadState* __tstate = wxPyBeginAllowThreads();
27928 result = (bool)(arg1)->TransferDataFromWindow();
27929
27930 wxPyEndAllowThreads(__tstate);
27931 if (PyErr_Occurred()) SWIG_fail;
27932 }
27933 {
27934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27935 }
27936 return resultobj;
27937 fail:
27938 return NULL;
27939 }
27940
27941
27942 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
27943 PyObject *resultobj;
27944 wxWindow *arg1 = (wxWindow *) 0 ;
27945 PyObject * obj0 = 0 ;
27946 char *kwnames[] = {
27947 (char *) "self", NULL
27948 };
27949
27950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
27951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27952 if (SWIG_arg_fail(1)) SWIG_fail;
27953 {
27954 PyThreadState* __tstate = wxPyBeginAllowThreads();
27955 (arg1)->InitDialog();
27956
27957 wxPyEndAllowThreads(__tstate);
27958 if (PyErr_Occurred()) SWIG_fail;
27959 }
27960 Py_INCREF(Py_None); resultobj = Py_None;
27961 return resultobj;
27962 fail:
27963 return NULL;
27964 }
27965
27966
27967 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
27968 PyObject *resultobj;
27969 wxWindow *arg1 = (wxWindow *) 0 ;
27970 wxAcceleratorTable *arg2 = 0 ;
27971 PyObject * obj0 = 0 ;
27972 PyObject * obj1 = 0 ;
27973 char *kwnames[] = {
27974 (char *) "self",(char *) "accel", NULL
27975 };
27976
27977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
27978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27979 if (SWIG_arg_fail(1)) SWIG_fail;
27980 {
27981 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
27982 if (SWIG_arg_fail(2)) SWIG_fail;
27983 if (arg2 == NULL) {
27984 SWIG_null_ref("wxAcceleratorTable");
27985 }
27986 if (SWIG_arg_fail(2)) SWIG_fail;
27987 }
27988 {
27989 PyThreadState* __tstate = wxPyBeginAllowThreads();
27990 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
27991
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 Py_INCREF(Py_None); resultobj = Py_None;
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28003 PyObject *resultobj;
28004 wxWindow *arg1 = (wxWindow *) 0 ;
28005 wxAcceleratorTable *result;
28006 PyObject * obj0 = 0 ;
28007 char *kwnames[] = {
28008 (char *) "self", NULL
28009 };
28010
28011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28013 if (SWIG_arg_fail(1)) SWIG_fail;
28014 {
28015 PyThreadState* __tstate = wxPyBeginAllowThreads();
28016 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28017
28018 wxPyEndAllowThreads(__tstate);
28019 if (PyErr_Occurred()) SWIG_fail;
28020 }
28021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28022 return resultobj;
28023 fail:
28024 return NULL;
28025 }
28026
28027
28028 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28029 PyObject *resultobj;
28030 wxWindow *arg1 = (wxWindow *) 0 ;
28031 int arg2 ;
28032 int arg3 ;
28033 int arg4 ;
28034 bool result;
28035 PyObject * obj0 = 0 ;
28036 PyObject * obj1 = 0 ;
28037 PyObject * obj2 = 0 ;
28038 PyObject * obj3 = 0 ;
28039 char *kwnames[] = {
28040 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28041 };
28042
28043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28045 if (SWIG_arg_fail(1)) SWIG_fail;
28046 {
28047 arg2 = (int)(SWIG_As_int(obj1));
28048 if (SWIG_arg_fail(2)) SWIG_fail;
28049 }
28050 {
28051 arg3 = (int)(SWIG_As_int(obj2));
28052 if (SWIG_arg_fail(3)) SWIG_fail;
28053 }
28054 {
28055 arg4 = (int)(SWIG_As_int(obj3));
28056 if (SWIG_arg_fail(4)) SWIG_fail;
28057 }
28058 {
28059 PyThreadState* __tstate = wxPyBeginAllowThreads();
28060 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28061
28062 wxPyEndAllowThreads(__tstate);
28063 if (PyErr_Occurred()) SWIG_fail;
28064 }
28065 {
28066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28067 }
28068 return resultobj;
28069 fail:
28070 return NULL;
28071 }
28072
28073
28074 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28075 PyObject *resultobj;
28076 wxWindow *arg1 = (wxWindow *) 0 ;
28077 int arg2 ;
28078 bool result;
28079 PyObject * obj0 = 0 ;
28080 PyObject * obj1 = 0 ;
28081 char *kwnames[] = {
28082 (char *) "self",(char *) "hotkeyId", NULL
28083 };
28084
28085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28087 if (SWIG_arg_fail(1)) SWIG_fail;
28088 {
28089 arg2 = (int)(SWIG_As_int(obj1));
28090 if (SWIG_arg_fail(2)) SWIG_fail;
28091 }
28092 {
28093 PyThreadState* __tstate = wxPyBeginAllowThreads();
28094 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28095
28096 wxPyEndAllowThreads(__tstate);
28097 if (PyErr_Occurred()) SWIG_fail;
28098 }
28099 {
28100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28101 }
28102 return resultobj;
28103 fail:
28104 return NULL;
28105 }
28106
28107
28108 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28109 PyObject *resultobj;
28110 wxWindow *arg1 = (wxWindow *) 0 ;
28111 wxPoint *arg2 = 0 ;
28112 wxPoint result;
28113 wxPoint temp2 ;
28114 PyObject * obj0 = 0 ;
28115 PyObject * obj1 = 0 ;
28116 char *kwnames[] = {
28117 (char *) "self",(char *) "pt", NULL
28118 };
28119
28120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28122 if (SWIG_arg_fail(1)) SWIG_fail;
28123 {
28124 arg2 = &temp2;
28125 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28126 }
28127 {
28128 PyThreadState* __tstate = wxPyBeginAllowThreads();
28129 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28130
28131 wxPyEndAllowThreads(__tstate);
28132 if (PyErr_Occurred()) SWIG_fail;
28133 }
28134 {
28135 wxPoint * resultptr;
28136 resultptr = new wxPoint((wxPoint &)(result));
28137 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28138 }
28139 return resultobj;
28140 fail:
28141 return NULL;
28142 }
28143
28144
28145 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28146 PyObject *resultobj;
28147 wxWindow *arg1 = (wxWindow *) 0 ;
28148 wxSize *arg2 = 0 ;
28149 wxSize result;
28150 wxSize temp2 ;
28151 PyObject * obj0 = 0 ;
28152 PyObject * obj1 = 0 ;
28153 char *kwnames[] = {
28154 (char *) "self",(char *) "sz", NULL
28155 };
28156
28157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28159 if (SWIG_arg_fail(1)) SWIG_fail;
28160 {
28161 arg2 = &temp2;
28162 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28163 }
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28167
28168 wxPyEndAllowThreads(__tstate);
28169 if (PyErr_Occurred()) SWIG_fail;
28170 }
28171 {
28172 wxSize * resultptr;
28173 resultptr = new wxSize((wxSize &)(result));
28174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28175 }
28176 return resultobj;
28177 fail:
28178 return NULL;
28179 }
28180
28181
28182 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28183 PyObject *resultobj;
28184 wxWindow *arg1 = (wxWindow *) 0 ;
28185 wxPoint *arg2 = 0 ;
28186 wxPoint result;
28187 wxPoint temp2 ;
28188 PyObject * obj0 = 0 ;
28189 PyObject * obj1 = 0 ;
28190 char *kwnames[] = {
28191 (char *) "self",(char *) "pt", NULL
28192 };
28193
28194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28196 if (SWIG_arg_fail(1)) SWIG_fail;
28197 {
28198 arg2 = &temp2;
28199 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28200 }
28201 {
28202 PyThreadState* __tstate = wxPyBeginAllowThreads();
28203 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28204
28205 wxPyEndAllowThreads(__tstate);
28206 if (PyErr_Occurred()) SWIG_fail;
28207 }
28208 {
28209 wxPoint * resultptr;
28210 resultptr = new wxPoint((wxPoint &)(result));
28211 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28212 }
28213 return resultobj;
28214 fail:
28215 return NULL;
28216 }
28217
28218
28219 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28220 PyObject *resultobj;
28221 wxWindow *arg1 = (wxWindow *) 0 ;
28222 wxSize *arg2 = 0 ;
28223 wxSize result;
28224 wxSize temp2 ;
28225 PyObject * obj0 = 0 ;
28226 PyObject * obj1 = 0 ;
28227 char *kwnames[] = {
28228 (char *) "self",(char *) "sz", NULL
28229 };
28230
28231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28233 if (SWIG_arg_fail(1)) SWIG_fail;
28234 {
28235 arg2 = &temp2;
28236 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28237 }
28238 {
28239 PyThreadState* __tstate = wxPyBeginAllowThreads();
28240 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28241
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 {
28246 wxSize * resultptr;
28247 resultptr = new wxSize((wxSize &)(result));
28248 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28249 }
28250 return resultobj;
28251 fail:
28252 return NULL;
28253 }
28254
28255
28256 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28257 PyObject *resultobj;
28258 wxWindow *arg1 = (wxWindow *) 0 ;
28259 wxPoint *arg2 = 0 ;
28260 wxPoint result;
28261 wxPoint temp2 ;
28262 PyObject * obj0 = 0 ;
28263 PyObject * obj1 = 0 ;
28264 char *kwnames[] = {
28265 (char *) "self",(char *) "pt", NULL
28266 };
28267
28268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",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 {
28272 arg2 = &temp2;
28273 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28274 }
28275 {
28276 PyThreadState* __tstate = wxPyBeginAllowThreads();
28277 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28278
28279 wxPyEndAllowThreads(__tstate);
28280 if (PyErr_Occurred()) SWIG_fail;
28281 }
28282 {
28283 wxPoint * resultptr;
28284 resultptr = new wxPoint((wxPoint &)(result));
28285 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28286 }
28287 return resultobj;
28288 fail:
28289 return NULL;
28290 }
28291
28292
28293 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28294 PyObject *resultobj;
28295 wxWindow *arg1 = (wxWindow *) 0 ;
28296 wxSize *arg2 = 0 ;
28297 wxSize result;
28298 wxSize temp2 ;
28299 PyObject * obj0 = 0 ;
28300 PyObject * obj1 = 0 ;
28301 char *kwnames[] = {
28302 (char *) "self",(char *) "sz", NULL
28303 };
28304
28305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28307 if (SWIG_arg_fail(1)) SWIG_fail;
28308 {
28309 arg2 = &temp2;
28310 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28311 }
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28315
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 {
28320 wxSize * resultptr;
28321 resultptr = new wxSize((wxSize &)(result));
28322 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28323 }
28324 return resultobj;
28325 fail:
28326 return NULL;
28327 }
28328
28329
28330 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28331 PyObject *resultobj;
28332 wxWindow *arg1 = (wxWindow *) 0 ;
28333 int arg2 ;
28334 int arg3 ;
28335 PyObject * obj0 = 0 ;
28336 PyObject * obj1 = 0 ;
28337 PyObject * obj2 = 0 ;
28338 char *kwnames[] = {
28339 (char *) "self",(char *) "x",(char *) "y", NULL
28340 };
28341
28342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28344 if (SWIG_arg_fail(1)) SWIG_fail;
28345 {
28346 arg2 = (int)(SWIG_As_int(obj1));
28347 if (SWIG_arg_fail(2)) SWIG_fail;
28348 }
28349 {
28350 arg3 = (int)(SWIG_As_int(obj2));
28351 if (SWIG_arg_fail(3)) SWIG_fail;
28352 }
28353 {
28354 PyThreadState* __tstate = wxPyBeginAllowThreads();
28355 (arg1)->WarpPointer(arg2,arg3);
28356
28357 wxPyEndAllowThreads(__tstate);
28358 if (PyErr_Occurred()) SWIG_fail;
28359 }
28360 Py_INCREF(Py_None); resultobj = Py_None;
28361 return resultobj;
28362 fail:
28363 return NULL;
28364 }
28365
28366
28367 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28368 PyObject *resultobj;
28369 wxWindow *arg1 = (wxWindow *) 0 ;
28370 PyObject * obj0 = 0 ;
28371 char *kwnames[] = {
28372 (char *) "self", NULL
28373 };
28374
28375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28377 if (SWIG_arg_fail(1)) SWIG_fail;
28378 {
28379 PyThreadState* __tstate = wxPyBeginAllowThreads();
28380 (arg1)->CaptureMouse();
28381
28382 wxPyEndAllowThreads(__tstate);
28383 if (PyErr_Occurred()) SWIG_fail;
28384 }
28385 Py_INCREF(Py_None); resultobj = Py_None;
28386 return resultobj;
28387 fail:
28388 return NULL;
28389 }
28390
28391
28392 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28393 PyObject *resultobj;
28394 wxWindow *arg1 = (wxWindow *) 0 ;
28395 PyObject * obj0 = 0 ;
28396 char *kwnames[] = {
28397 (char *) "self", NULL
28398 };
28399
28400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28402 if (SWIG_arg_fail(1)) SWIG_fail;
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 (arg1)->ReleaseMouse();
28406
28407 wxPyEndAllowThreads(__tstate);
28408 if (PyErr_Occurred()) SWIG_fail;
28409 }
28410 Py_INCREF(Py_None); resultobj = Py_None;
28411 return resultobj;
28412 fail:
28413 return NULL;
28414 }
28415
28416
28417 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28418 PyObject *resultobj;
28419 wxWindow *result;
28420 char *kwnames[] = {
28421 NULL
28422 };
28423
28424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28425 {
28426 if (!wxPyCheckForApp()) SWIG_fail;
28427 PyThreadState* __tstate = wxPyBeginAllowThreads();
28428 result = (wxWindow *)wxWindow::GetCapture();
28429
28430 wxPyEndAllowThreads(__tstate);
28431 if (PyErr_Occurred()) SWIG_fail;
28432 }
28433 {
28434 resultobj = wxPyMake_wxObject(result, 0);
28435 }
28436 return resultobj;
28437 fail:
28438 return NULL;
28439 }
28440
28441
28442 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28443 PyObject *resultobj;
28444 wxWindow *arg1 = (wxWindow *) 0 ;
28445 bool result;
28446 PyObject * obj0 = 0 ;
28447 char *kwnames[] = {
28448 (char *) "self", NULL
28449 };
28450
28451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28453 if (SWIG_arg_fail(1)) SWIG_fail;
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 result = (bool)((wxWindow const *)arg1)->HasCapture();
28457
28458 wxPyEndAllowThreads(__tstate);
28459 if (PyErr_Occurred()) SWIG_fail;
28460 }
28461 {
28462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28463 }
28464 return resultobj;
28465 fail:
28466 return NULL;
28467 }
28468
28469
28470 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28471 PyObject *resultobj;
28472 wxWindow *arg1 = (wxWindow *) 0 ;
28473 bool arg2 = (bool) true ;
28474 wxRect *arg3 = (wxRect *) NULL ;
28475 PyObject * obj0 = 0 ;
28476 PyObject * obj1 = 0 ;
28477 PyObject * obj2 = 0 ;
28478 char *kwnames[] = {
28479 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28480 };
28481
28482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28484 if (SWIG_arg_fail(1)) SWIG_fail;
28485 if (obj1) {
28486 {
28487 arg2 = (bool)(SWIG_As_bool(obj1));
28488 if (SWIG_arg_fail(2)) SWIG_fail;
28489 }
28490 }
28491 if (obj2) {
28492 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28493 if (SWIG_arg_fail(3)) SWIG_fail;
28494 }
28495 {
28496 PyThreadState* __tstate = wxPyBeginAllowThreads();
28497 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28498
28499 wxPyEndAllowThreads(__tstate);
28500 if (PyErr_Occurred()) SWIG_fail;
28501 }
28502 Py_INCREF(Py_None); resultobj = Py_None;
28503 return resultobj;
28504 fail:
28505 return NULL;
28506 }
28507
28508
28509 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28510 PyObject *resultobj;
28511 wxWindow *arg1 = (wxWindow *) 0 ;
28512 wxRect *arg2 = 0 ;
28513 wxRect temp2 ;
28514 PyObject * obj0 = 0 ;
28515 PyObject * obj1 = 0 ;
28516 char *kwnames[] = {
28517 (char *) "self",(char *) "rect", NULL
28518 };
28519
28520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RefreshRect",kwnames,&obj0,&obj1)) goto fail;
28521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28522 if (SWIG_arg_fail(1)) SWIG_fail;
28523 {
28524 arg2 = &temp2;
28525 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28526 }
28527 {
28528 PyThreadState* __tstate = wxPyBeginAllowThreads();
28529 (arg1)->RefreshRect((wxRect const &)*arg2);
28530
28531 wxPyEndAllowThreads(__tstate);
28532 if (PyErr_Occurred()) SWIG_fail;
28533 }
28534 Py_INCREF(Py_None); resultobj = Py_None;
28535 return resultobj;
28536 fail:
28537 return NULL;
28538 }
28539
28540
28541 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28542 PyObject *resultobj;
28543 wxWindow *arg1 = (wxWindow *) 0 ;
28544 PyObject * obj0 = 0 ;
28545 char *kwnames[] = {
28546 (char *) "self", NULL
28547 };
28548
28549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28551 if (SWIG_arg_fail(1)) SWIG_fail;
28552 {
28553 PyThreadState* __tstate = wxPyBeginAllowThreads();
28554 (arg1)->Update();
28555
28556 wxPyEndAllowThreads(__tstate);
28557 if (PyErr_Occurred()) SWIG_fail;
28558 }
28559 Py_INCREF(Py_None); resultobj = Py_None;
28560 return resultobj;
28561 fail:
28562 return NULL;
28563 }
28564
28565
28566 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28567 PyObject *resultobj;
28568 wxWindow *arg1 = (wxWindow *) 0 ;
28569 PyObject * obj0 = 0 ;
28570 char *kwnames[] = {
28571 (char *) "self", NULL
28572 };
28573
28574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28576 if (SWIG_arg_fail(1)) SWIG_fail;
28577 {
28578 PyThreadState* __tstate = wxPyBeginAllowThreads();
28579 (arg1)->ClearBackground();
28580
28581 wxPyEndAllowThreads(__tstate);
28582 if (PyErr_Occurred()) SWIG_fail;
28583 }
28584 Py_INCREF(Py_None); resultobj = Py_None;
28585 return resultobj;
28586 fail:
28587 return NULL;
28588 }
28589
28590
28591 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28592 PyObject *resultobj;
28593 wxWindow *arg1 = (wxWindow *) 0 ;
28594 PyObject * obj0 = 0 ;
28595 char *kwnames[] = {
28596 (char *) "self", NULL
28597 };
28598
28599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28601 if (SWIG_arg_fail(1)) SWIG_fail;
28602 {
28603 PyThreadState* __tstate = wxPyBeginAllowThreads();
28604 (arg1)->Freeze();
28605
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 Py_INCREF(Py_None); resultobj = Py_None;
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28617 PyObject *resultobj;
28618 wxWindow *arg1 = (wxWindow *) 0 ;
28619 PyObject * obj0 = 0 ;
28620 char *kwnames[] = {
28621 (char *) "self", NULL
28622 };
28623
28624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28626 if (SWIG_arg_fail(1)) SWIG_fail;
28627 {
28628 PyThreadState* __tstate = wxPyBeginAllowThreads();
28629 (arg1)->Thaw();
28630
28631 wxPyEndAllowThreads(__tstate);
28632 if (PyErr_Occurred()) SWIG_fail;
28633 }
28634 Py_INCREF(Py_None); resultobj = Py_None;
28635 return resultobj;
28636 fail:
28637 return NULL;
28638 }
28639
28640
28641 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28642 PyObject *resultobj;
28643 wxWindow *arg1 = (wxWindow *) 0 ;
28644 wxDC *arg2 = 0 ;
28645 PyObject * obj0 = 0 ;
28646 PyObject * obj1 = 0 ;
28647 char *kwnames[] = {
28648 (char *) "self",(char *) "dc", NULL
28649 };
28650
28651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28653 if (SWIG_arg_fail(1)) SWIG_fail;
28654 {
28655 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28656 if (SWIG_arg_fail(2)) SWIG_fail;
28657 if (arg2 == NULL) {
28658 SWIG_null_ref("wxDC");
28659 }
28660 if (SWIG_arg_fail(2)) SWIG_fail;
28661 }
28662 {
28663 PyThreadState* __tstate = wxPyBeginAllowThreads();
28664 (arg1)->PrepareDC(*arg2);
28665
28666 wxPyEndAllowThreads(__tstate);
28667 if (PyErr_Occurred()) SWIG_fail;
28668 }
28669 Py_INCREF(Py_None); resultobj = Py_None;
28670 return resultobj;
28671 fail:
28672 return NULL;
28673 }
28674
28675
28676 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28677 PyObject *resultobj;
28678 wxWindow *arg1 = (wxWindow *) 0 ;
28679 wxRegion *result;
28680 PyObject * obj0 = 0 ;
28681 char *kwnames[] = {
28682 (char *) "self", NULL
28683 };
28684
28685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28687 if (SWIG_arg_fail(1)) SWIG_fail;
28688 {
28689 PyThreadState* __tstate = wxPyBeginAllowThreads();
28690 {
28691 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28692 result = (wxRegion *) &_result_ref;
28693 }
28694
28695 wxPyEndAllowThreads(__tstate);
28696 if (PyErr_Occurred()) SWIG_fail;
28697 }
28698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28699 return resultobj;
28700 fail:
28701 return NULL;
28702 }
28703
28704
28705 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28706 PyObject *resultobj;
28707 wxWindow *arg1 = (wxWindow *) 0 ;
28708 wxRect result;
28709 PyObject * obj0 = 0 ;
28710 char *kwnames[] = {
28711 (char *) "self", NULL
28712 };
28713
28714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28716 if (SWIG_arg_fail(1)) SWIG_fail;
28717 {
28718 PyThreadState* __tstate = wxPyBeginAllowThreads();
28719 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28720
28721 wxPyEndAllowThreads(__tstate);
28722 if (PyErr_Occurred()) SWIG_fail;
28723 }
28724 {
28725 wxRect * resultptr;
28726 resultptr = new wxRect((wxRect &)(result));
28727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28728 }
28729 return resultobj;
28730 fail:
28731 return NULL;
28732 }
28733
28734
28735 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
28736 PyObject *resultobj;
28737 wxWindow *arg1 = (wxWindow *) 0 ;
28738 int arg2 ;
28739 int arg3 ;
28740 int arg4 = (int) 1 ;
28741 int arg5 = (int) 1 ;
28742 bool result;
28743 PyObject * obj0 = 0 ;
28744 PyObject * obj1 = 0 ;
28745 PyObject * obj2 = 0 ;
28746 PyObject * obj3 = 0 ;
28747 PyObject * obj4 = 0 ;
28748 char *kwnames[] = {
28749 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
28750 };
28751
28752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
28753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28754 if (SWIG_arg_fail(1)) SWIG_fail;
28755 {
28756 arg2 = (int)(SWIG_As_int(obj1));
28757 if (SWIG_arg_fail(2)) SWIG_fail;
28758 }
28759 {
28760 arg3 = (int)(SWIG_As_int(obj2));
28761 if (SWIG_arg_fail(3)) SWIG_fail;
28762 }
28763 if (obj3) {
28764 {
28765 arg4 = (int)(SWIG_As_int(obj3));
28766 if (SWIG_arg_fail(4)) SWIG_fail;
28767 }
28768 }
28769 if (obj4) {
28770 {
28771 arg5 = (int)(SWIG_As_int(obj4));
28772 if (SWIG_arg_fail(5)) SWIG_fail;
28773 }
28774 }
28775 {
28776 PyThreadState* __tstate = wxPyBeginAllowThreads();
28777 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
28778
28779 wxPyEndAllowThreads(__tstate);
28780 if (PyErr_Occurred()) SWIG_fail;
28781 }
28782 {
28783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28784 }
28785 return resultobj;
28786 fail:
28787 return NULL;
28788 }
28789
28790
28791 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
28792 PyObject *resultobj;
28793 wxWindow *arg1 = (wxWindow *) 0 ;
28794 wxPoint *arg2 = 0 ;
28795 bool result;
28796 wxPoint temp2 ;
28797 PyObject * obj0 = 0 ;
28798 PyObject * obj1 = 0 ;
28799 char *kwnames[] = {
28800 (char *) "self",(char *) "pt", NULL
28801 };
28802
28803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
28804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28805 if (SWIG_arg_fail(1)) SWIG_fail;
28806 {
28807 arg2 = &temp2;
28808 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28809 }
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
28813
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 {
28818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28819 }
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
28827 PyObject *resultobj;
28828 wxWindow *arg1 = (wxWindow *) 0 ;
28829 wxRect *arg2 = 0 ;
28830 bool result;
28831 wxRect temp2 ;
28832 PyObject * obj0 = 0 ;
28833 PyObject * obj1 = 0 ;
28834 char *kwnames[] = {
28835 (char *) "self",(char *) "rect", NULL
28836 };
28837
28838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
28839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28840 if (SWIG_arg_fail(1)) SWIG_fail;
28841 {
28842 arg2 = &temp2;
28843 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28844 }
28845 {
28846 PyThreadState* __tstate = wxPyBeginAllowThreads();
28847 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
28848
28849 wxPyEndAllowThreads(__tstate);
28850 if (PyErr_Occurred()) SWIG_fail;
28851 }
28852 {
28853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28854 }
28855 return resultobj;
28856 fail:
28857 return NULL;
28858 }
28859
28860
28861 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28862 PyObject *resultobj;
28863 wxWindow *arg1 = (wxWindow *) 0 ;
28864 wxVisualAttributes result;
28865 PyObject * obj0 = 0 ;
28866 char *kwnames[] = {
28867 (char *) "self", NULL
28868 };
28869
28870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
28871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28872 if (SWIG_arg_fail(1)) SWIG_fail;
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
28876
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 {
28881 wxVisualAttributes * resultptr;
28882 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28884 }
28885 return resultobj;
28886 fail:
28887 return NULL;
28888 }
28889
28890
28891 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28892 PyObject *resultobj;
28893 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
28894 wxVisualAttributes result;
28895 PyObject * obj0 = 0 ;
28896 char *kwnames[] = {
28897 (char *) "variant", NULL
28898 };
28899
28900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
28901 if (obj0) {
28902 {
28903 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
28904 if (SWIG_arg_fail(1)) SWIG_fail;
28905 }
28906 }
28907 {
28908 if (!wxPyCheckForApp()) SWIG_fail;
28909 PyThreadState* __tstate = wxPyBeginAllowThreads();
28910 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
28911
28912 wxPyEndAllowThreads(__tstate);
28913 if (PyErr_Occurred()) SWIG_fail;
28914 }
28915 {
28916 wxVisualAttributes * resultptr;
28917 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28919 }
28920 return resultobj;
28921 fail:
28922 return NULL;
28923 }
28924
28925
28926 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28927 PyObject *resultobj;
28928 wxWindow *arg1 = (wxWindow *) 0 ;
28929 wxColour *arg2 = 0 ;
28930 bool result;
28931 wxColour temp2 ;
28932 PyObject * obj0 = 0 ;
28933 PyObject * obj1 = 0 ;
28934 char *kwnames[] = {
28935 (char *) "self",(char *) "colour", NULL
28936 };
28937
28938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28940 if (SWIG_arg_fail(1)) SWIG_fail;
28941 {
28942 arg2 = &temp2;
28943 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28944 }
28945 {
28946 PyThreadState* __tstate = wxPyBeginAllowThreads();
28947 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
28948
28949 wxPyEndAllowThreads(__tstate);
28950 if (PyErr_Occurred()) SWIG_fail;
28951 }
28952 {
28953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28954 }
28955 return resultobj;
28956 fail:
28957 return NULL;
28958 }
28959
28960
28961 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28962 PyObject *resultobj;
28963 wxWindow *arg1 = (wxWindow *) 0 ;
28964 wxColour *arg2 = 0 ;
28965 wxColour temp2 ;
28966 PyObject * obj0 = 0 ;
28967 PyObject * obj1 = 0 ;
28968 char *kwnames[] = {
28969 (char *) "self",(char *) "colour", NULL
28970 };
28971
28972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28974 if (SWIG_arg_fail(1)) SWIG_fail;
28975 {
28976 arg2 = &temp2;
28977 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28978 }
28979 {
28980 PyThreadState* __tstate = wxPyBeginAllowThreads();
28981 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
28982
28983 wxPyEndAllowThreads(__tstate);
28984 if (PyErr_Occurred()) SWIG_fail;
28985 }
28986 Py_INCREF(Py_None); resultobj = Py_None;
28987 return resultobj;
28988 fail:
28989 return NULL;
28990 }
28991
28992
28993 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28994 PyObject *resultobj;
28995 wxWindow *arg1 = (wxWindow *) 0 ;
28996 wxColour *arg2 = 0 ;
28997 bool result;
28998 wxColour temp2 ;
28999 PyObject * obj0 = 0 ;
29000 PyObject * obj1 = 0 ;
29001 char *kwnames[] = {
29002 (char *) "self",(char *) "colour", NULL
29003 };
29004
29005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29007 if (SWIG_arg_fail(1)) SWIG_fail;
29008 {
29009 arg2 = &temp2;
29010 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29011 }
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29015
29016 wxPyEndAllowThreads(__tstate);
29017 if (PyErr_Occurred()) SWIG_fail;
29018 }
29019 {
29020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29021 }
29022 return resultobj;
29023 fail:
29024 return NULL;
29025 }
29026
29027
29028 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29029 PyObject *resultobj;
29030 wxWindow *arg1 = (wxWindow *) 0 ;
29031 wxColour *arg2 = 0 ;
29032 wxColour temp2 ;
29033 PyObject * obj0 = 0 ;
29034 PyObject * obj1 = 0 ;
29035 char *kwnames[] = {
29036 (char *) "self",(char *) "colour", NULL
29037 };
29038
29039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29041 if (SWIG_arg_fail(1)) SWIG_fail;
29042 {
29043 arg2 = &temp2;
29044 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29045 }
29046 {
29047 PyThreadState* __tstate = wxPyBeginAllowThreads();
29048 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29049
29050 wxPyEndAllowThreads(__tstate);
29051 if (PyErr_Occurred()) SWIG_fail;
29052 }
29053 Py_INCREF(Py_None); resultobj = Py_None;
29054 return resultobj;
29055 fail:
29056 return NULL;
29057 }
29058
29059
29060 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29061 PyObject *resultobj;
29062 wxWindow *arg1 = (wxWindow *) 0 ;
29063 wxColour result;
29064 PyObject * obj0 = 0 ;
29065 char *kwnames[] = {
29066 (char *) "self", NULL
29067 };
29068
29069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29071 if (SWIG_arg_fail(1)) SWIG_fail;
29072 {
29073 PyThreadState* __tstate = wxPyBeginAllowThreads();
29074 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29075
29076 wxPyEndAllowThreads(__tstate);
29077 if (PyErr_Occurred()) SWIG_fail;
29078 }
29079 {
29080 wxColour * resultptr;
29081 resultptr = new wxColour((wxColour &)(result));
29082 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29083 }
29084 return resultobj;
29085 fail:
29086 return NULL;
29087 }
29088
29089
29090 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29091 PyObject *resultobj;
29092 wxWindow *arg1 = (wxWindow *) 0 ;
29093 wxColour result;
29094 PyObject * obj0 = 0 ;
29095 char *kwnames[] = {
29096 (char *) "self", NULL
29097 };
29098
29099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29101 if (SWIG_arg_fail(1)) SWIG_fail;
29102 {
29103 PyThreadState* __tstate = wxPyBeginAllowThreads();
29104 result = ((wxWindow const *)arg1)->GetForegroundColour();
29105
29106 wxPyEndAllowThreads(__tstate);
29107 if (PyErr_Occurred()) SWIG_fail;
29108 }
29109 {
29110 wxColour * resultptr;
29111 resultptr = new wxColour((wxColour &)(result));
29112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29113 }
29114 return resultobj;
29115 fail:
29116 return NULL;
29117 }
29118
29119
29120 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29121 PyObject *resultobj;
29122 wxWindow *arg1 = (wxWindow *) 0 ;
29123 wxBackgroundStyle arg2 ;
29124 bool result;
29125 PyObject * obj0 = 0 ;
29126 PyObject * obj1 = 0 ;
29127 char *kwnames[] = {
29128 (char *) "self",(char *) "style", NULL
29129 };
29130
29131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29133 if (SWIG_arg_fail(1)) SWIG_fail;
29134 {
29135 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29136 if (SWIG_arg_fail(2)) SWIG_fail;
29137 }
29138 {
29139 PyThreadState* __tstate = wxPyBeginAllowThreads();
29140 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29141
29142 wxPyEndAllowThreads(__tstate);
29143 if (PyErr_Occurred()) SWIG_fail;
29144 }
29145 {
29146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29147 }
29148 return resultobj;
29149 fail:
29150 return NULL;
29151 }
29152
29153
29154 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29155 PyObject *resultobj;
29156 wxWindow *arg1 = (wxWindow *) 0 ;
29157 wxBackgroundStyle result;
29158 PyObject * obj0 = 0 ;
29159 char *kwnames[] = {
29160 (char *) "self", NULL
29161 };
29162
29163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29165 if (SWIG_arg_fail(1)) SWIG_fail;
29166 {
29167 PyThreadState* __tstate = wxPyBeginAllowThreads();
29168 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29169
29170 wxPyEndAllowThreads(__tstate);
29171 if (PyErr_Occurred()) SWIG_fail;
29172 }
29173 resultobj = SWIG_From_int((result));
29174 return resultobj;
29175 fail:
29176 return NULL;
29177 }
29178
29179
29180 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29181 PyObject *resultobj;
29182 wxWindow *arg1 = (wxWindow *) 0 ;
29183 bool result;
29184 PyObject * obj0 = 0 ;
29185 char *kwnames[] = {
29186 (char *) "self", NULL
29187 };
29188
29189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29191 if (SWIG_arg_fail(1)) SWIG_fail;
29192 {
29193 PyThreadState* __tstate = wxPyBeginAllowThreads();
29194 result = (bool)(arg1)->HasTransparentBackground();
29195
29196 wxPyEndAllowThreads(__tstate);
29197 if (PyErr_Occurred()) SWIG_fail;
29198 }
29199 {
29200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29201 }
29202 return resultobj;
29203 fail:
29204 return NULL;
29205 }
29206
29207
29208 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29209 PyObject *resultobj;
29210 wxWindow *arg1 = (wxWindow *) 0 ;
29211 wxCursor *arg2 = 0 ;
29212 bool result;
29213 PyObject * obj0 = 0 ;
29214 PyObject * obj1 = 0 ;
29215 char *kwnames[] = {
29216 (char *) "self",(char *) "cursor", NULL
29217 };
29218
29219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",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_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29224 if (SWIG_arg_fail(2)) SWIG_fail;
29225 if (arg2 == NULL) {
29226 SWIG_null_ref("wxCursor");
29227 }
29228 if (SWIG_arg_fail(2)) SWIG_fail;
29229 }
29230 {
29231 PyThreadState* __tstate = wxPyBeginAllowThreads();
29232 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29233
29234 wxPyEndAllowThreads(__tstate);
29235 if (PyErr_Occurred()) SWIG_fail;
29236 }
29237 {
29238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29239 }
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29247 PyObject *resultobj;
29248 wxWindow *arg1 = (wxWindow *) 0 ;
29249 wxCursor result;
29250 PyObject * obj0 = 0 ;
29251 char *kwnames[] = {
29252 (char *) "self", NULL
29253 };
29254
29255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29257 if (SWIG_arg_fail(1)) SWIG_fail;
29258 {
29259 PyThreadState* __tstate = wxPyBeginAllowThreads();
29260 result = (arg1)->GetCursor();
29261
29262 wxPyEndAllowThreads(__tstate);
29263 if (PyErr_Occurred()) SWIG_fail;
29264 }
29265 {
29266 wxCursor * resultptr;
29267 resultptr = new wxCursor((wxCursor &)(result));
29268 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29269 }
29270 return resultobj;
29271 fail:
29272 return NULL;
29273 }
29274
29275
29276 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29277 PyObject *resultobj;
29278 wxWindow *arg1 = (wxWindow *) 0 ;
29279 wxFont *arg2 = 0 ;
29280 bool result;
29281 PyObject * obj0 = 0 ;
29282 PyObject * obj1 = 0 ;
29283 char *kwnames[] = {
29284 (char *) "self",(char *) "font", NULL
29285 };
29286
29287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29289 if (SWIG_arg_fail(1)) SWIG_fail;
29290 {
29291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29292 if (SWIG_arg_fail(2)) SWIG_fail;
29293 if (arg2 == NULL) {
29294 SWIG_null_ref("wxFont");
29295 }
29296 if (SWIG_arg_fail(2)) SWIG_fail;
29297 }
29298 {
29299 PyThreadState* __tstate = wxPyBeginAllowThreads();
29300 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29301
29302 wxPyEndAllowThreads(__tstate);
29303 if (PyErr_Occurred()) SWIG_fail;
29304 }
29305 {
29306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29307 }
29308 return resultobj;
29309 fail:
29310 return NULL;
29311 }
29312
29313
29314 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29315 PyObject *resultobj;
29316 wxWindow *arg1 = (wxWindow *) 0 ;
29317 wxFont *arg2 = 0 ;
29318 PyObject * obj0 = 0 ;
29319 PyObject * obj1 = 0 ;
29320 char *kwnames[] = {
29321 (char *) "self",(char *) "font", NULL
29322 };
29323
29324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29326 if (SWIG_arg_fail(1)) SWIG_fail;
29327 {
29328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29329 if (SWIG_arg_fail(2)) SWIG_fail;
29330 if (arg2 == NULL) {
29331 SWIG_null_ref("wxFont");
29332 }
29333 if (SWIG_arg_fail(2)) SWIG_fail;
29334 }
29335 {
29336 PyThreadState* __tstate = wxPyBeginAllowThreads();
29337 (arg1)->SetOwnFont((wxFont const &)*arg2);
29338
29339 wxPyEndAllowThreads(__tstate);
29340 if (PyErr_Occurred()) SWIG_fail;
29341 }
29342 Py_INCREF(Py_None); resultobj = Py_None;
29343 return resultobj;
29344 fail:
29345 return NULL;
29346 }
29347
29348
29349 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29350 PyObject *resultobj;
29351 wxWindow *arg1 = (wxWindow *) 0 ;
29352 wxFont result;
29353 PyObject * obj0 = 0 ;
29354 char *kwnames[] = {
29355 (char *) "self", NULL
29356 };
29357
29358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29360 if (SWIG_arg_fail(1)) SWIG_fail;
29361 {
29362 PyThreadState* __tstate = wxPyBeginAllowThreads();
29363 result = (arg1)->GetFont();
29364
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 {
29369 wxFont * resultptr;
29370 resultptr = new wxFont((wxFont &)(result));
29371 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29372 }
29373 return resultobj;
29374 fail:
29375 return NULL;
29376 }
29377
29378
29379 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29380 PyObject *resultobj;
29381 wxWindow *arg1 = (wxWindow *) 0 ;
29382 wxCaret *arg2 = (wxCaret *) 0 ;
29383 PyObject * obj0 = 0 ;
29384 PyObject * obj1 = 0 ;
29385 char *kwnames[] = {
29386 (char *) "self",(char *) "caret", NULL
29387 };
29388
29389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29391 if (SWIG_arg_fail(1)) SWIG_fail;
29392 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29393 if (SWIG_arg_fail(2)) SWIG_fail;
29394 {
29395 PyThreadState* __tstate = wxPyBeginAllowThreads();
29396 (arg1)->SetCaret(arg2);
29397
29398 wxPyEndAllowThreads(__tstate);
29399 if (PyErr_Occurred()) SWIG_fail;
29400 }
29401 Py_INCREF(Py_None); resultobj = Py_None;
29402 return resultobj;
29403 fail:
29404 return NULL;
29405 }
29406
29407
29408 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29409 PyObject *resultobj;
29410 wxWindow *arg1 = (wxWindow *) 0 ;
29411 wxCaret *result;
29412 PyObject * obj0 = 0 ;
29413 char *kwnames[] = {
29414 (char *) "self", NULL
29415 };
29416
29417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29419 if (SWIG_arg_fail(1)) SWIG_fail;
29420 {
29421 PyThreadState* __tstate = wxPyBeginAllowThreads();
29422 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29423
29424 wxPyEndAllowThreads(__tstate);
29425 if (PyErr_Occurred()) SWIG_fail;
29426 }
29427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29428 return resultobj;
29429 fail:
29430 return NULL;
29431 }
29432
29433
29434 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29435 PyObject *resultobj;
29436 wxWindow *arg1 = (wxWindow *) 0 ;
29437 int result;
29438 PyObject * obj0 = 0 ;
29439 char *kwnames[] = {
29440 (char *) "self", NULL
29441 };
29442
29443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29445 if (SWIG_arg_fail(1)) SWIG_fail;
29446 {
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29449
29450 wxPyEndAllowThreads(__tstate);
29451 if (PyErr_Occurred()) SWIG_fail;
29452 }
29453 {
29454 resultobj = SWIG_From_int((int)(result));
29455 }
29456 return resultobj;
29457 fail:
29458 return NULL;
29459 }
29460
29461
29462 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29463 PyObject *resultobj;
29464 wxWindow *arg1 = (wxWindow *) 0 ;
29465 int result;
29466 PyObject * obj0 = 0 ;
29467 char *kwnames[] = {
29468 (char *) "self", NULL
29469 };
29470
29471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29473 if (SWIG_arg_fail(1)) SWIG_fail;
29474 {
29475 PyThreadState* __tstate = wxPyBeginAllowThreads();
29476 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29477
29478 wxPyEndAllowThreads(__tstate);
29479 if (PyErr_Occurred()) SWIG_fail;
29480 }
29481 {
29482 resultobj = SWIG_From_int((int)(result));
29483 }
29484 return resultobj;
29485 fail:
29486 return NULL;
29487 }
29488
29489
29490 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29491 PyObject *resultobj;
29492 wxWindow *arg1 = (wxWindow *) 0 ;
29493 wxString *arg2 = 0 ;
29494 int *arg3 = (int *) 0 ;
29495 int *arg4 = (int *) 0 ;
29496 bool temp2 = false ;
29497 int temp3 ;
29498 int res3 = 0 ;
29499 int temp4 ;
29500 int res4 = 0 ;
29501 PyObject * obj0 = 0 ;
29502 PyObject * obj1 = 0 ;
29503 char *kwnames[] = {
29504 (char *) "self",(char *) "string", NULL
29505 };
29506
29507 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29508 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29511 if (SWIG_arg_fail(1)) SWIG_fail;
29512 {
29513 arg2 = wxString_in_helper(obj1);
29514 if (arg2 == NULL) SWIG_fail;
29515 temp2 = true;
29516 }
29517 {
29518 PyThreadState* __tstate = wxPyBeginAllowThreads();
29519 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29520
29521 wxPyEndAllowThreads(__tstate);
29522 if (PyErr_Occurred()) SWIG_fail;
29523 }
29524 Py_INCREF(Py_None); resultobj = Py_None;
29525 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29526 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29527 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29528 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29529 {
29530 if (temp2)
29531 delete arg2;
29532 }
29533 return resultobj;
29534 fail:
29535 {
29536 if (temp2)
29537 delete arg2;
29538 }
29539 return NULL;
29540 }
29541
29542
29543 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29544 PyObject *resultobj;
29545 wxWindow *arg1 = (wxWindow *) 0 ;
29546 wxString *arg2 = 0 ;
29547 int *arg3 = (int *) 0 ;
29548 int *arg4 = (int *) 0 ;
29549 int *arg5 = (int *) 0 ;
29550 int *arg6 = (int *) 0 ;
29551 wxFont *arg7 = (wxFont *) NULL ;
29552 bool temp2 = false ;
29553 int temp3 ;
29554 int res3 = 0 ;
29555 int temp4 ;
29556 int res4 = 0 ;
29557 int temp5 ;
29558 int res5 = 0 ;
29559 int temp6 ;
29560 int res6 = 0 ;
29561 PyObject * obj0 = 0 ;
29562 PyObject * obj1 = 0 ;
29563 PyObject * obj2 = 0 ;
29564 char *kwnames[] = {
29565 (char *) "self",(char *) "string",(char *) "font", NULL
29566 };
29567
29568 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29569 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29570 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29571 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29574 if (SWIG_arg_fail(1)) SWIG_fail;
29575 {
29576 arg2 = wxString_in_helper(obj1);
29577 if (arg2 == NULL) SWIG_fail;
29578 temp2 = true;
29579 }
29580 if (obj2) {
29581 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29582 if (SWIG_arg_fail(7)) SWIG_fail;
29583 }
29584 {
29585 PyThreadState* __tstate = wxPyBeginAllowThreads();
29586 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29587
29588 wxPyEndAllowThreads(__tstate);
29589 if (PyErr_Occurred()) SWIG_fail;
29590 }
29591 Py_INCREF(Py_None); resultobj = Py_None;
29592 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29593 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29594 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29595 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29596 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29597 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29598 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29599 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29600 {
29601 if (temp2)
29602 delete arg2;
29603 }
29604 return resultobj;
29605 fail:
29606 {
29607 if (temp2)
29608 delete arg2;
29609 }
29610 return NULL;
29611 }
29612
29613
29614 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29615 PyObject *resultobj;
29616 wxWindow *arg1 = (wxWindow *) 0 ;
29617 int *arg2 = (int *) 0 ;
29618 int *arg3 = (int *) 0 ;
29619 int temp2 ;
29620 int res2 = 0 ;
29621 int temp3 ;
29622 int res3 = 0 ;
29623 PyObject * obj0 = 0 ;
29624 PyObject * obj1 = 0 ;
29625 PyObject * obj2 = 0 ;
29626 char *kwnames[] = {
29627 (char *) "self",(char *) "x",(char *) "y", NULL
29628 };
29629
29630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29632 if (SWIG_arg_fail(1)) SWIG_fail;
29633 {
29634 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29635 temp2 = SWIG_As_int(obj1);
29636 if (SWIG_arg_fail(2)) SWIG_fail;
29637 arg2 = &temp2;
29638 res2 = SWIG_NEWOBJ;
29639 }
29640 }
29641 {
29642 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29643 temp3 = SWIG_As_int(obj2);
29644 if (SWIG_arg_fail(3)) SWIG_fail;
29645 arg3 = &temp3;
29646 res3 = SWIG_NEWOBJ;
29647 }
29648 }
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29652
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 Py_INCREF(Py_None); resultobj = Py_None;
29657 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29658 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29659 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29660 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29661 return resultobj;
29662 fail:
29663 return NULL;
29664 }
29665
29666
29667 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29668 PyObject *resultobj;
29669 wxWindow *arg1 = (wxWindow *) 0 ;
29670 int *arg2 = (int *) 0 ;
29671 int *arg3 = (int *) 0 ;
29672 int temp2 ;
29673 int res2 = 0 ;
29674 int temp3 ;
29675 int res3 = 0 ;
29676 PyObject * obj0 = 0 ;
29677 PyObject * obj1 = 0 ;
29678 PyObject * obj2 = 0 ;
29679 char *kwnames[] = {
29680 (char *) "self",(char *) "x",(char *) "y", NULL
29681 };
29682
29683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29685 if (SWIG_arg_fail(1)) SWIG_fail;
29686 {
29687 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29688 temp2 = SWIG_As_int(obj1);
29689 if (SWIG_arg_fail(2)) SWIG_fail;
29690 arg2 = &temp2;
29691 res2 = SWIG_NEWOBJ;
29692 }
29693 }
29694 {
29695 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29696 temp3 = SWIG_As_int(obj2);
29697 if (SWIG_arg_fail(3)) SWIG_fail;
29698 arg3 = &temp3;
29699 res3 = SWIG_NEWOBJ;
29700 }
29701 }
29702 {
29703 PyThreadState* __tstate = wxPyBeginAllowThreads();
29704 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29705
29706 wxPyEndAllowThreads(__tstate);
29707 if (PyErr_Occurred()) SWIG_fail;
29708 }
29709 Py_INCREF(Py_None); resultobj = Py_None;
29710 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29711 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29712 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29713 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29714 return resultobj;
29715 fail:
29716 return NULL;
29717 }
29718
29719
29720 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29721 PyObject *resultobj;
29722 wxWindow *arg1 = (wxWindow *) 0 ;
29723 wxPoint *arg2 = 0 ;
29724 wxPoint result;
29725 wxPoint temp2 ;
29726 PyObject * obj0 = 0 ;
29727 PyObject * obj1 = 0 ;
29728 char *kwnames[] = {
29729 (char *) "self",(char *) "pt", NULL
29730 };
29731
29732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
29733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29734 if (SWIG_arg_fail(1)) SWIG_fail;
29735 {
29736 arg2 = &temp2;
29737 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29738 }
29739 {
29740 PyThreadState* __tstate = wxPyBeginAllowThreads();
29741 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
29742
29743 wxPyEndAllowThreads(__tstate);
29744 if (PyErr_Occurred()) SWIG_fail;
29745 }
29746 {
29747 wxPoint * resultptr;
29748 resultptr = new wxPoint((wxPoint &)(result));
29749 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29750 }
29751 return resultobj;
29752 fail:
29753 return NULL;
29754 }
29755
29756
29757 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
29758 PyObject *resultobj;
29759 wxWindow *arg1 = (wxWindow *) 0 ;
29760 wxPoint *arg2 = 0 ;
29761 wxPoint result;
29762 wxPoint temp2 ;
29763 PyObject * obj0 = 0 ;
29764 PyObject * obj1 = 0 ;
29765 char *kwnames[] = {
29766 (char *) "self",(char *) "pt", NULL
29767 };
29768
29769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
29770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29771 if (SWIG_arg_fail(1)) SWIG_fail;
29772 {
29773 arg2 = &temp2;
29774 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29775 }
29776 {
29777 PyThreadState* __tstate = wxPyBeginAllowThreads();
29778 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
29779
29780 wxPyEndAllowThreads(__tstate);
29781 if (PyErr_Occurred()) SWIG_fail;
29782 }
29783 {
29784 wxPoint * resultptr;
29785 resultptr = new wxPoint((wxPoint &)(result));
29786 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29787 }
29788 return resultobj;
29789 fail:
29790 return NULL;
29791 }
29792
29793
29794 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
29795 PyObject *resultobj;
29796 wxWindow *arg1 = (wxWindow *) 0 ;
29797 int arg2 ;
29798 int arg3 ;
29799 wxHitTest result;
29800 PyObject * obj0 = 0 ;
29801 PyObject * obj1 = 0 ;
29802 PyObject * obj2 = 0 ;
29803 char *kwnames[] = {
29804 (char *) "self",(char *) "x",(char *) "y", NULL
29805 };
29806
29807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29809 if (SWIG_arg_fail(1)) SWIG_fail;
29810 {
29811 arg2 = (int)(SWIG_As_int(obj1));
29812 if (SWIG_arg_fail(2)) SWIG_fail;
29813 }
29814 {
29815 arg3 = (int)(SWIG_As_int(obj2));
29816 if (SWIG_arg_fail(3)) SWIG_fail;
29817 }
29818 {
29819 PyThreadState* __tstate = wxPyBeginAllowThreads();
29820 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
29821
29822 wxPyEndAllowThreads(__tstate);
29823 if (PyErr_Occurred()) SWIG_fail;
29824 }
29825 resultobj = SWIG_From_int((result));
29826 return resultobj;
29827 fail:
29828 return NULL;
29829 }
29830
29831
29832 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
29833 PyObject *resultobj;
29834 wxWindow *arg1 = (wxWindow *) 0 ;
29835 wxPoint *arg2 = 0 ;
29836 wxHitTest result;
29837 wxPoint temp2 ;
29838 PyObject * obj0 = 0 ;
29839 PyObject * obj1 = 0 ;
29840 char *kwnames[] = {
29841 (char *) "self",(char *) "pt", NULL
29842 };
29843
29844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
29845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29846 if (SWIG_arg_fail(1)) SWIG_fail;
29847 {
29848 arg2 = &temp2;
29849 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29850 }
29851 {
29852 PyThreadState* __tstate = wxPyBeginAllowThreads();
29853 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
29854
29855 wxPyEndAllowThreads(__tstate);
29856 if (PyErr_Occurred()) SWIG_fail;
29857 }
29858 resultobj = SWIG_From_int((result));
29859 return resultobj;
29860 fail:
29861 return NULL;
29862 }
29863
29864
29865 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
29866 PyObject *resultobj;
29867 wxWindow *arg1 = (wxWindow *) 0 ;
29868 long arg2 ;
29869 wxBorder result;
29870 PyObject * obj0 = 0 ;
29871 PyObject * obj1 = 0 ;
29872
29873 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
29874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29875 if (SWIG_arg_fail(1)) SWIG_fail;
29876 {
29877 arg2 = (long)(SWIG_As_long(obj1));
29878 if (SWIG_arg_fail(2)) SWIG_fail;
29879 }
29880 {
29881 PyThreadState* __tstate = wxPyBeginAllowThreads();
29882 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
29883
29884 wxPyEndAllowThreads(__tstate);
29885 if (PyErr_Occurred()) SWIG_fail;
29886 }
29887 resultobj = SWIG_From_int((result));
29888 return resultobj;
29889 fail:
29890 return NULL;
29891 }
29892
29893
29894 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
29895 PyObject *resultobj;
29896 wxWindow *arg1 = (wxWindow *) 0 ;
29897 wxBorder result;
29898 PyObject * obj0 = 0 ;
29899
29900 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
29901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29902 if (SWIG_arg_fail(1)) SWIG_fail;
29903 {
29904 PyThreadState* __tstate = wxPyBeginAllowThreads();
29905 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
29906
29907 wxPyEndAllowThreads(__tstate);
29908 if (PyErr_Occurred()) SWIG_fail;
29909 }
29910 resultobj = SWIG_From_int((result));
29911 return resultobj;
29912 fail:
29913 return NULL;
29914 }
29915
29916
29917 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
29918 int argc;
29919 PyObject *argv[3];
29920 int ii;
29921
29922 argc = PyObject_Length(args);
29923 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29924 argv[ii] = PyTuple_GetItem(args,ii);
29925 }
29926 if (argc == 1) {
29927 int _v;
29928 {
29929 void *ptr;
29930 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29931 _v = 0;
29932 PyErr_Clear();
29933 } else {
29934 _v = 1;
29935 }
29936 }
29937 if (_v) {
29938 return _wrap_Window_GetBorder__SWIG_1(self,args);
29939 }
29940 }
29941 if (argc == 2) {
29942 int _v;
29943 {
29944 void *ptr;
29945 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29946 _v = 0;
29947 PyErr_Clear();
29948 } else {
29949 _v = 1;
29950 }
29951 }
29952 if (_v) {
29953 _v = SWIG_Check_long(argv[1]);
29954 if (_v) {
29955 return _wrap_Window_GetBorder__SWIG_0(self,args);
29956 }
29957 }
29958 }
29959
29960 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
29961 return NULL;
29962 }
29963
29964
29965 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
29966 PyObject *resultobj;
29967 wxWindow *arg1 = (wxWindow *) 0 ;
29968 long arg2 = (long) wxUPDATE_UI_NONE ;
29969 PyObject * obj0 = 0 ;
29970 PyObject * obj1 = 0 ;
29971 char *kwnames[] = {
29972 (char *) "self",(char *) "flags", NULL
29973 };
29974
29975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
29976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29977 if (SWIG_arg_fail(1)) SWIG_fail;
29978 if (obj1) {
29979 {
29980 arg2 = (long)(SWIG_As_long(obj1));
29981 if (SWIG_arg_fail(2)) SWIG_fail;
29982 }
29983 }
29984 {
29985 PyThreadState* __tstate = wxPyBeginAllowThreads();
29986 (arg1)->UpdateWindowUI(arg2);
29987
29988 wxPyEndAllowThreads(__tstate);
29989 if (PyErr_Occurred()) SWIG_fail;
29990 }
29991 Py_INCREF(Py_None); resultobj = Py_None;
29992 return resultobj;
29993 fail:
29994 return NULL;
29995 }
29996
29997
29998 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
29999 PyObject *resultobj;
30000 wxWindow *arg1 = (wxWindow *) 0 ;
30001 wxMenu *arg2 = (wxMenu *) 0 ;
30002 int arg3 = (int) -1 ;
30003 int arg4 = (int) -1 ;
30004 bool result;
30005 PyObject * obj0 = 0 ;
30006 PyObject * obj1 = 0 ;
30007 PyObject * obj2 = 0 ;
30008 PyObject * obj3 = 0 ;
30009 char *kwnames[] = {
30010 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30011 };
30012
30013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30017 if (SWIG_arg_fail(2)) SWIG_fail;
30018 if (obj2) {
30019 {
30020 arg3 = (int)(SWIG_As_int(obj2));
30021 if (SWIG_arg_fail(3)) SWIG_fail;
30022 }
30023 }
30024 if (obj3) {
30025 {
30026 arg4 = (int)(SWIG_As_int(obj3));
30027 if (SWIG_arg_fail(4)) SWIG_fail;
30028 }
30029 }
30030 {
30031 PyThreadState* __tstate = wxPyBeginAllowThreads();
30032 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30033
30034 wxPyEndAllowThreads(__tstate);
30035 if (PyErr_Occurred()) SWIG_fail;
30036 }
30037 {
30038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30039 }
30040 return resultobj;
30041 fail:
30042 return NULL;
30043 }
30044
30045
30046 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30047 PyObject *resultobj;
30048 wxWindow *arg1 = (wxWindow *) 0 ;
30049 wxMenu *arg2 = (wxMenu *) 0 ;
30050 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30051 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30052 bool result;
30053 wxPoint temp3 ;
30054 PyObject * obj0 = 0 ;
30055 PyObject * obj1 = 0 ;
30056 PyObject * obj2 = 0 ;
30057 char *kwnames[] = {
30058 (char *) "self",(char *) "menu",(char *) "pos", NULL
30059 };
30060
30061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30063 if (SWIG_arg_fail(1)) SWIG_fail;
30064 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30065 if (SWIG_arg_fail(2)) SWIG_fail;
30066 if (obj2) {
30067 {
30068 arg3 = &temp3;
30069 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30070 }
30071 }
30072 {
30073 PyThreadState* __tstate = wxPyBeginAllowThreads();
30074 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30075
30076 wxPyEndAllowThreads(__tstate);
30077 if (PyErr_Occurred()) SWIG_fail;
30078 }
30079 {
30080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30081 }
30082 return resultobj;
30083 fail:
30084 return NULL;
30085 }
30086
30087
30088 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30089 PyObject *resultobj;
30090 wxWindow *arg1 = (wxWindow *) 0 ;
30091 long result;
30092 PyObject * obj0 = 0 ;
30093 char *kwnames[] = {
30094 (char *) "self", NULL
30095 };
30096
30097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30099 if (SWIG_arg_fail(1)) SWIG_fail;
30100 {
30101 PyThreadState* __tstate = wxPyBeginAllowThreads();
30102 result = (long)wxWindow_GetHandle(arg1);
30103
30104 wxPyEndAllowThreads(__tstate);
30105 if (PyErr_Occurred()) SWIG_fail;
30106 }
30107 {
30108 resultobj = SWIG_From_long((long)(result));
30109 }
30110 return resultobj;
30111 fail:
30112 return NULL;
30113 }
30114
30115
30116 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30117 PyObject *resultobj;
30118 wxWindow *arg1 = (wxWindow *) 0 ;
30119 long arg2 ;
30120 PyObject * obj0 = 0 ;
30121 PyObject * obj1 = 0 ;
30122 char *kwnames[] = {
30123 (char *) "self",(char *) "handle", NULL
30124 };
30125
30126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30128 if (SWIG_arg_fail(1)) SWIG_fail;
30129 {
30130 arg2 = (long)(SWIG_As_long(obj1));
30131 if (SWIG_arg_fail(2)) SWIG_fail;
30132 }
30133 {
30134 PyThreadState* __tstate = wxPyBeginAllowThreads();
30135 wxWindow_AssociateHandle(arg1,arg2);
30136
30137 wxPyEndAllowThreads(__tstate);
30138 if (PyErr_Occurred()) SWIG_fail;
30139 }
30140 Py_INCREF(Py_None); resultobj = Py_None;
30141 return resultobj;
30142 fail:
30143 return NULL;
30144 }
30145
30146
30147 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30148 PyObject *resultobj;
30149 wxWindow *arg1 = (wxWindow *) 0 ;
30150 PyObject * obj0 = 0 ;
30151 char *kwnames[] = {
30152 (char *) "self", NULL
30153 };
30154
30155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30157 if (SWIG_arg_fail(1)) SWIG_fail;
30158 {
30159 PyThreadState* __tstate = wxPyBeginAllowThreads();
30160 (arg1)->DissociateHandle();
30161
30162 wxPyEndAllowThreads(__tstate);
30163 if (PyErr_Occurred()) SWIG_fail;
30164 }
30165 Py_INCREF(Py_None); resultobj = Py_None;
30166 return resultobj;
30167 fail:
30168 return NULL;
30169 }
30170
30171
30172 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30173 PyObject *resultobj;
30174 wxWindow *arg1 = (wxWindow *) 0 ;
30175 int arg2 ;
30176 bool result;
30177 PyObject * obj0 = 0 ;
30178 PyObject * obj1 = 0 ;
30179 char *kwnames[] = {
30180 (char *) "self",(char *) "orient", NULL
30181 };
30182
30183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30185 if (SWIG_arg_fail(1)) SWIG_fail;
30186 {
30187 arg2 = (int)(SWIG_As_int(obj1));
30188 if (SWIG_arg_fail(2)) SWIG_fail;
30189 }
30190 {
30191 PyThreadState* __tstate = wxPyBeginAllowThreads();
30192 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30193
30194 wxPyEndAllowThreads(__tstate);
30195 if (PyErr_Occurred()) SWIG_fail;
30196 }
30197 {
30198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30199 }
30200 return resultobj;
30201 fail:
30202 return NULL;
30203 }
30204
30205
30206 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30207 PyObject *resultobj;
30208 wxWindow *arg1 = (wxWindow *) 0 ;
30209 int arg2 ;
30210 int arg3 ;
30211 int arg4 ;
30212 int arg5 ;
30213 bool arg6 = (bool) true ;
30214 PyObject * obj0 = 0 ;
30215 PyObject * obj1 = 0 ;
30216 PyObject * obj2 = 0 ;
30217 PyObject * obj3 = 0 ;
30218 PyObject * obj4 = 0 ;
30219 PyObject * obj5 = 0 ;
30220 char *kwnames[] = {
30221 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30222 };
30223
30224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30226 if (SWIG_arg_fail(1)) SWIG_fail;
30227 {
30228 arg2 = (int)(SWIG_As_int(obj1));
30229 if (SWIG_arg_fail(2)) SWIG_fail;
30230 }
30231 {
30232 arg3 = (int)(SWIG_As_int(obj2));
30233 if (SWIG_arg_fail(3)) SWIG_fail;
30234 }
30235 {
30236 arg4 = (int)(SWIG_As_int(obj3));
30237 if (SWIG_arg_fail(4)) SWIG_fail;
30238 }
30239 {
30240 arg5 = (int)(SWIG_As_int(obj4));
30241 if (SWIG_arg_fail(5)) SWIG_fail;
30242 }
30243 if (obj5) {
30244 {
30245 arg6 = (bool)(SWIG_As_bool(obj5));
30246 if (SWIG_arg_fail(6)) SWIG_fail;
30247 }
30248 }
30249 {
30250 PyThreadState* __tstate = wxPyBeginAllowThreads();
30251 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30252
30253 wxPyEndAllowThreads(__tstate);
30254 if (PyErr_Occurred()) SWIG_fail;
30255 }
30256 Py_INCREF(Py_None); resultobj = Py_None;
30257 return resultobj;
30258 fail:
30259 return NULL;
30260 }
30261
30262
30263 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30264 PyObject *resultobj;
30265 wxWindow *arg1 = (wxWindow *) 0 ;
30266 int arg2 ;
30267 int arg3 ;
30268 bool arg4 = (bool) true ;
30269 PyObject * obj0 = 0 ;
30270 PyObject * obj1 = 0 ;
30271 PyObject * obj2 = 0 ;
30272 PyObject * obj3 = 0 ;
30273 char *kwnames[] = {
30274 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30275 };
30276
30277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30279 if (SWIG_arg_fail(1)) SWIG_fail;
30280 {
30281 arg2 = (int)(SWIG_As_int(obj1));
30282 if (SWIG_arg_fail(2)) SWIG_fail;
30283 }
30284 {
30285 arg3 = (int)(SWIG_As_int(obj2));
30286 if (SWIG_arg_fail(3)) SWIG_fail;
30287 }
30288 if (obj3) {
30289 {
30290 arg4 = (bool)(SWIG_As_bool(obj3));
30291 if (SWIG_arg_fail(4)) SWIG_fail;
30292 }
30293 }
30294 {
30295 PyThreadState* __tstate = wxPyBeginAllowThreads();
30296 (arg1)->SetScrollPos(arg2,arg3,arg4);
30297
30298 wxPyEndAllowThreads(__tstate);
30299 if (PyErr_Occurred()) SWIG_fail;
30300 }
30301 Py_INCREF(Py_None); resultobj = Py_None;
30302 return resultobj;
30303 fail:
30304 return NULL;
30305 }
30306
30307
30308 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30309 PyObject *resultobj;
30310 wxWindow *arg1 = (wxWindow *) 0 ;
30311 int arg2 ;
30312 int result;
30313 PyObject * obj0 = 0 ;
30314 PyObject * obj1 = 0 ;
30315 char *kwnames[] = {
30316 (char *) "self",(char *) "orientation", NULL
30317 };
30318
30319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30321 if (SWIG_arg_fail(1)) SWIG_fail;
30322 {
30323 arg2 = (int)(SWIG_As_int(obj1));
30324 if (SWIG_arg_fail(2)) SWIG_fail;
30325 }
30326 {
30327 PyThreadState* __tstate = wxPyBeginAllowThreads();
30328 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30329
30330 wxPyEndAllowThreads(__tstate);
30331 if (PyErr_Occurred()) SWIG_fail;
30332 }
30333 {
30334 resultobj = SWIG_From_int((int)(result));
30335 }
30336 return resultobj;
30337 fail:
30338 return NULL;
30339 }
30340
30341
30342 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30343 PyObject *resultobj;
30344 wxWindow *arg1 = (wxWindow *) 0 ;
30345 int arg2 ;
30346 int result;
30347 PyObject * obj0 = 0 ;
30348 PyObject * obj1 = 0 ;
30349 char *kwnames[] = {
30350 (char *) "self",(char *) "orientation", NULL
30351 };
30352
30353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30355 if (SWIG_arg_fail(1)) SWIG_fail;
30356 {
30357 arg2 = (int)(SWIG_As_int(obj1));
30358 if (SWIG_arg_fail(2)) SWIG_fail;
30359 }
30360 {
30361 PyThreadState* __tstate = wxPyBeginAllowThreads();
30362 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30363
30364 wxPyEndAllowThreads(__tstate);
30365 if (PyErr_Occurred()) SWIG_fail;
30366 }
30367 {
30368 resultobj = SWIG_From_int((int)(result));
30369 }
30370 return resultobj;
30371 fail:
30372 return NULL;
30373 }
30374
30375
30376 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30377 PyObject *resultobj;
30378 wxWindow *arg1 = (wxWindow *) 0 ;
30379 int arg2 ;
30380 int result;
30381 PyObject * obj0 = 0 ;
30382 PyObject * obj1 = 0 ;
30383 char *kwnames[] = {
30384 (char *) "self",(char *) "orientation", NULL
30385 };
30386
30387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30389 if (SWIG_arg_fail(1)) SWIG_fail;
30390 {
30391 arg2 = (int)(SWIG_As_int(obj1));
30392 if (SWIG_arg_fail(2)) SWIG_fail;
30393 }
30394 {
30395 PyThreadState* __tstate = wxPyBeginAllowThreads();
30396 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30397
30398 wxPyEndAllowThreads(__tstate);
30399 if (PyErr_Occurred()) SWIG_fail;
30400 }
30401 {
30402 resultobj = SWIG_From_int((int)(result));
30403 }
30404 return resultobj;
30405 fail:
30406 return NULL;
30407 }
30408
30409
30410 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30411 PyObject *resultobj;
30412 wxWindow *arg1 = (wxWindow *) 0 ;
30413 int arg2 ;
30414 int arg3 ;
30415 wxRect *arg4 = (wxRect *) NULL ;
30416 PyObject * obj0 = 0 ;
30417 PyObject * obj1 = 0 ;
30418 PyObject * obj2 = 0 ;
30419 PyObject * obj3 = 0 ;
30420 char *kwnames[] = {
30421 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30422 };
30423
30424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30426 if (SWIG_arg_fail(1)) SWIG_fail;
30427 {
30428 arg2 = (int)(SWIG_As_int(obj1));
30429 if (SWIG_arg_fail(2)) SWIG_fail;
30430 }
30431 {
30432 arg3 = (int)(SWIG_As_int(obj2));
30433 if (SWIG_arg_fail(3)) SWIG_fail;
30434 }
30435 if (obj3) {
30436 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30437 if (SWIG_arg_fail(4)) SWIG_fail;
30438 }
30439 {
30440 PyThreadState* __tstate = wxPyBeginAllowThreads();
30441 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30442
30443 wxPyEndAllowThreads(__tstate);
30444 if (PyErr_Occurred()) SWIG_fail;
30445 }
30446 Py_INCREF(Py_None); resultobj = Py_None;
30447 return resultobj;
30448 fail:
30449 return NULL;
30450 }
30451
30452
30453 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30454 PyObject *resultobj;
30455 wxWindow *arg1 = (wxWindow *) 0 ;
30456 int arg2 ;
30457 bool result;
30458 PyObject * obj0 = 0 ;
30459 PyObject * obj1 = 0 ;
30460 char *kwnames[] = {
30461 (char *) "self",(char *) "lines", NULL
30462 };
30463
30464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30466 if (SWIG_arg_fail(1)) SWIG_fail;
30467 {
30468 arg2 = (int)(SWIG_As_int(obj1));
30469 if (SWIG_arg_fail(2)) SWIG_fail;
30470 }
30471 {
30472 PyThreadState* __tstate = wxPyBeginAllowThreads();
30473 result = (bool)(arg1)->ScrollLines(arg2);
30474
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 {
30479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30480 }
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30488 PyObject *resultobj;
30489 wxWindow *arg1 = (wxWindow *) 0 ;
30490 int arg2 ;
30491 bool result;
30492 PyObject * obj0 = 0 ;
30493 PyObject * obj1 = 0 ;
30494 char *kwnames[] = {
30495 (char *) "self",(char *) "pages", NULL
30496 };
30497
30498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30500 if (SWIG_arg_fail(1)) SWIG_fail;
30501 {
30502 arg2 = (int)(SWIG_As_int(obj1));
30503 if (SWIG_arg_fail(2)) SWIG_fail;
30504 }
30505 {
30506 PyThreadState* __tstate = wxPyBeginAllowThreads();
30507 result = (bool)(arg1)->ScrollPages(arg2);
30508
30509 wxPyEndAllowThreads(__tstate);
30510 if (PyErr_Occurred()) SWIG_fail;
30511 }
30512 {
30513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30514 }
30515 return resultobj;
30516 fail:
30517 return NULL;
30518 }
30519
30520
30521 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30522 PyObject *resultobj;
30523 wxWindow *arg1 = (wxWindow *) 0 ;
30524 bool result;
30525 PyObject * obj0 = 0 ;
30526 char *kwnames[] = {
30527 (char *) "self", NULL
30528 };
30529
30530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30532 if (SWIG_arg_fail(1)) SWIG_fail;
30533 {
30534 PyThreadState* __tstate = wxPyBeginAllowThreads();
30535 result = (bool)(arg1)->LineUp();
30536
30537 wxPyEndAllowThreads(__tstate);
30538 if (PyErr_Occurred()) SWIG_fail;
30539 }
30540 {
30541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30542 }
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30550 PyObject *resultobj;
30551 wxWindow *arg1 = (wxWindow *) 0 ;
30552 bool result;
30553 PyObject * obj0 = 0 ;
30554 char *kwnames[] = {
30555 (char *) "self", NULL
30556 };
30557
30558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30560 if (SWIG_arg_fail(1)) SWIG_fail;
30561 {
30562 PyThreadState* __tstate = wxPyBeginAllowThreads();
30563 result = (bool)(arg1)->LineDown();
30564
30565 wxPyEndAllowThreads(__tstate);
30566 if (PyErr_Occurred()) SWIG_fail;
30567 }
30568 {
30569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30570 }
30571 return resultobj;
30572 fail:
30573 return NULL;
30574 }
30575
30576
30577 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30578 PyObject *resultobj;
30579 wxWindow *arg1 = (wxWindow *) 0 ;
30580 bool result;
30581 PyObject * obj0 = 0 ;
30582 char *kwnames[] = {
30583 (char *) "self", NULL
30584 };
30585
30586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30588 if (SWIG_arg_fail(1)) SWIG_fail;
30589 {
30590 PyThreadState* __tstate = wxPyBeginAllowThreads();
30591 result = (bool)(arg1)->PageUp();
30592
30593 wxPyEndAllowThreads(__tstate);
30594 if (PyErr_Occurred()) SWIG_fail;
30595 }
30596 {
30597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30598 }
30599 return resultobj;
30600 fail:
30601 return NULL;
30602 }
30603
30604
30605 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30606 PyObject *resultobj;
30607 wxWindow *arg1 = (wxWindow *) 0 ;
30608 bool result;
30609 PyObject * obj0 = 0 ;
30610 char *kwnames[] = {
30611 (char *) "self", NULL
30612 };
30613
30614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30616 if (SWIG_arg_fail(1)) SWIG_fail;
30617 {
30618 PyThreadState* __tstate = wxPyBeginAllowThreads();
30619 result = (bool)(arg1)->PageDown();
30620
30621 wxPyEndAllowThreads(__tstate);
30622 if (PyErr_Occurred()) SWIG_fail;
30623 }
30624 {
30625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30626 }
30627 return resultobj;
30628 fail:
30629 return NULL;
30630 }
30631
30632
30633 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30634 PyObject *resultobj;
30635 wxWindow *arg1 = (wxWindow *) 0 ;
30636 wxString *arg2 = 0 ;
30637 bool temp2 = false ;
30638 PyObject * obj0 = 0 ;
30639 PyObject * obj1 = 0 ;
30640 char *kwnames[] = {
30641 (char *) "self",(char *) "text", NULL
30642 };
30643
30644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30646 if (SWIG_arg_fail(1)) SWIG_fail;
30647 {
30648 arg2 = wxString_in_helper(obj1);
30649 if (arg2 == NULL) SWIG_fail;
30650 temp2 = true;
30651 }
30652 {
30653 PyThreadState* __tstate = wxPyBeginAllowThreads();
30654 (arg1)->SetHelpText((wxString const &)*arg2);
30655
30656 wxPyEndAllowThreads(__tstate);
30657 if (PyErr_Occurred()) SWIG_fail;
30658 }
30659 Py_INCREF(Py_None); resultobj = Py_None;
30660 {
30661 if (temp2)
30662 delete arg2;
30663 }
30664 return resultobj;
30665 fail:
30666 {
30667 if (temp2)
30668 delete arg2;
30669 }
30670 return NULL;
30671 }
30672
30673
30674 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30675 PyObject *resultobj;
30676 wxWindow *arg1 = (wxWindow *) 0 ;
30677 wxString *arg2 = 0 ;
30678 bool temp2 = false ;
30679 PyObject * obj0 = 0 ;
30680 PyObject * obj1 = 0 ;
30681 char *kwnames[] = {
30682 (char *) "self",(char *) "text", NULL
30683 };
30684
30685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) 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 {
30689 arg2 = wxString_in_helper(obj1);
30690 if (arg2 == NULL) SWIG_fail;
30691 temp2 = true;
30692 }
30693 {
30694 PyThreadState* __tstate = wxPyBeginAllowThreads();
30695 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30696
30697 wxPyEndAllowThreads(__tstate);
30698 if (PyErr_Occurred()) SWIG_fail;
30699 }
30700 Py_INCREF(Py_None); resultobj = Py_None;
30701 {
30702 if (temp2)
30703 delete arg2;
30704 }
30705 return resultobj;
30706 fail:
30707 {
30708 if (temp2)
30709 delete arg2;
30710 }
30711 return NULL;
30712 }
30713
30714
30715 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30716 PyObject *resultobj;
30717 wxWindow *arg1 = (wxWindow *) 0 ;
30718 wxString result;
30719 PyObject * obj0 = 0 ;
30720 char *kwnames[] = {
30721 (char *) "self", NULL
30722 };
30723
30724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
30725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30726 if (SWIG_arg_fail(1)) SWIG_fail;
30727 {
30728 PyThreadState* __tstate = wxPyBeginAllowThreads();
30729 result = ((wxWindow const *)arg1)->GetHelpText();
30730
30731 wxPyEndAllowThreads(__tstate);
30732 if (PyErr_Occurred()) SWIG_fail;
30733 }
30734 {
30735 #if wxUSE_UNICODE
30736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30737 #else
30738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30739 #endif
30740 }
30741 return resultobj;
30742 fail:
30743 return NULL;
30744 }
30745
30746
30747 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
30748 PyObject *resultobj;
30749 wxWindow *arg1 = (wxWindow *) 0 ;
30750 wxString *arg2 = 0 ;
30751 bool temp2 = false ;
30752 PyObject * obj0 = 0 ;
30753 PyObject * obj1 = 0 ;
30754 char *kwnames[] = {
30755 (char *) "self",(char *) "tip", NULL
30756 };
30757
30758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
30759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30760 if (SWIG_arg_fail(1)) SWIG_fail;
30761 {
30762 arg2 = wxString_in_helper(obj1);
30763 if (arg2 == NULL) SWIG_fail;
30764 temp2 = true;
30765 }
30766 {
30767 PyThreadState* __tstate = wxPyBeginAllowThreads();
30768 (arg1)->SetToolTip((wxString const &)*arg2);
30769
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 Py_INCREF(Py_None); resultobj = Py_None;
30774 {
30775 if (temp2)
30776 delete arg2;
30777 }
30778 return resultobj;
30779 fail:
30780 {
30781 if (temp2)
30782 delete arg2;
30783 }
30784 return NULL;
30785 }
30786
30787
30788 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30789 PyObject *resultobj;
30790 wxWindow *arg1 = (wxWindow *) 0 ;
30791 wxToolTip *arg2 = (wxToolTip *) 0 ;
30792 PyObject * obj0 = 0 ;
30793 PyObject * obj1 = 0 ;
30794 char *kwnames[] = {
30795 (char *) "self",(char *) "tip", NULL
30796 };
30797
30798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
30799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30800 if (SWIG_arg_fail(1)) SWIG_fail;
30801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
30802 if (SWIG_arg_fail(2)) SWIG_fail;
30803 {
30804 PyThreadState* __tstate = wxPyBeginAllowThreads();
30805 (arg1)->SetToolTip(arg2);
30806
30807 wxPyEndAllowThreads(__tstate);
30808 if (PyErr_Occurred()) SWIG_fail;
30809 }
30810 Py_INCREF(Py_None); resultobj = Py_None;
30811 return resultobj;
30812 fail:
30813 return NULL;
30814 }
30815
30816
30817 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30818 PyObject *resultobj;
30819 wxWindow *arg1 = (wxWindow *) 0 ;
30820 wxToolTip *result;
30821 PyObject * obj0 = 0 ;
30822 char *kwnames[] = {
30823 (char *) "self", NULL
30824 };
30825
30826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
30827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30828 if (SWIG_arg_fail(1)) SWIG_fail;
30829 {
30830 PyThreadState* __tstate = wxPyBeginAllowThreads();
30831 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
30832
30833 wxPyEndAllowThreads(__tstate);
30834 if (PyErr_Occurred()) SWIG_fail;
30835 }
30836 {
30837 resultobj = wxPyMake_wxObject(result, 0);
30838 }
30839 return resultobj;
30840 fail:
30841 return NULL;
30842 }
30843
30844
30845 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30846 PyObject *resultobj;
30847 wxWindow *arg1 = (wxWindow *) 0 ;
30848 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
30849 PyObject * obj0 = 0 ;
30850 PyObject * obj1 = 0 ;
30851 char *kwnames[] = {
30852 (char *) "self",(char *) "dropTarget", NULL
30853 };
30854
30855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
30856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30857 if (SWIG_arg_fail(1)) SWIG_fail;
30858 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30859 if (SWIG_arg_fail(2)) SWIG_fail;
30860 {
30861 PyThreadState* __tstate = wxPyBeginAllowThreads();
30862 (arg1)->SetDropTarget(arg2);
30863
30864 wxPyEndAllowThreads(__tstate);
30865 if (PyErr_Occurred()) SWIG_fail;
30866 }
30867 Py_INCREF(Py_None); resultobj = Py_None;
30868 return resultobj;
30869 fail:
30870 return NULL;
30871 }
30872
30873
30874 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30875 PyObject *resultobj;
30876 wxWindow *arg1 = (wxWindow *) 0 ;
30877 wxPyDropTarget *result;
30878 PyObject * obj0 = 0 ;
30879 char *kwnames[] = {
30880 (char *) "self", NULL
30881 };
30882
30883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
30884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30885 if (SWIG_arg_fail(1)) SWIG_fail;
30886 {
30887 PyThreadState* __tstate = wxPyBeginAllowThreads();
30888 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
30889
30890 wxPyEndAllowThreads(__tstate);
30891 if (PyErr_Occurred()) SWIG_fail;
30892 }
30893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
30894 return resultobj;
30895 fail:
30896 return NULL;
30897 }
30898
30899
30900 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30901 PyObject *resultobj;
30902 wxWindow *arg1 = (wxWindow *) 0 ;
30903 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
30904 PyObject * obj0 = 0 ;
30905 PyObject * obj1 = 0 ;
30906 char *kwnames[] = {
30907 (char *) "self",(char *) "constraints", NULL
30908 };
30909
30910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
30911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30912 if (SWIG_arg_fail(1)) SWIG_fail;
30913 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
30914 if (SWIG_arg_fail(2)) SWIG_fail;
30915 {
30916 PyThreadState* __tstate = wxPyBeginAllowThreads();
30917 (arg1)->SetConstraints(arg2);
30918
30919 wxPyEndAllowThreads(__tstate);
30920 if (PyErr_Occurred()) SWIG_fail;
30921 }
30922 Py_INCREF(Py_None); resultobj = Py_None;
30923 return resultobj;
30924 fail:
30925 return NULL;
30926 }
30927
30928
30929 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30930 PyObject *resultobj;
30931 wxWindow *arg1 = (wxWindow *) 0 ;
30932 wxLayoutConstraints *result;
30933 PyObject * obj0 = 0 ;
30934 char *kwnames[] = {
30935 (char *) "self", NULL
30936 };
30937
30938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
30939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30940 if (SWIG_arg_fail(1)) SWIG_fail;
30941 {
30942 PyThreadState* __tstate = wxPyBeginAllowThreads();
30943 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
30944
30945 wxPyEndAllowThreads(__tstate);
30946 if (PyErr_Occurred()) SWIG_fail;
30947 }
30948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
30949 return resultobj;
30950 fail:
30951 return NULL;
30952 }
30953
30954
30955 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30956 PyObject *resultobj;
30957 wxWindow *arg1 = (wxWindow *) 0 ;
30958 bool arg2 ;
30959 PyObject * obj0 = 0 ;
30960 PyObject * obj1 = 0 ;
30961 char *kwnames[] = {
30962 (char *) "self",(char *) "autoLayout", NULL
30963 };
30964
30965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
30966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30967 if (SWIG_arg_fail(1)) SWIG_fail;
30968 {
30969 arg2 = (bool)(SWIG_As_bool(obj1));
30970 if (SWIG_arg_fail(2)) SWIG_fail;
30971 }
30972 {
30973 PyThreadState* __tstate = wxPyBeginAllowThreads();
30974 (arg1)->SetAutoLayout(arg2);
30975
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 Py_INCREF(Py_None); resultobj = Py_None;
30980 return resultobj;
30981 fail:
30982 return NULL;
30983 }
30984
30985
30986 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30987 PyObject *resultobj;
30988 wxWindow *arg1 = (wxWindow *) 0 ;
30989 bool result;
30990 PyObject * obj0 = 0 ;
30991 char *kwnames[] = {
30992 (char *) "self", NULL
30993 };
30994
30995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
30996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30997 if (SWIG_arg_fail(1)) SWIG_fail;
30998 {
30999 PyThreadState* __tstate = wxPyBeginAllowThreads();
31000 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31001
31002 wxPyEndAllowThreads(__tstate);
31003 if (PyErr_Occurred()) SWIG_fail;
31004 }
31005 {
31006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31007 }
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31015 PyObject *resultobj;
31016 wxWindow *arg1 = (wxWindow *) 0 ;
31017 bool result;
31018 PyObject * obj0 = 0 ;
31019 char *kwnames[] = {
31020 (char *) "self", NULL
31021 };
31022
31023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31025 if (SWIG_arg_fail(1)) SWIG_fail;
31026 {
31027 PyThreadState* __tstate = wxPyBeginAllowThreads();
31028 result = (bool)(arg1)->Layout();
31029
31030 wxPyEndAllowThreads(__tstate);
31031 if (PyErr_Occurred()) SWIG_fail;
31032 }
31033 {
31034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31035 }
31036 return resultobj;
31037 fail:
31038 return NULL;
31039 }
31040
31041
31042 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31043 PyObject *resultobj;
31044 wxWindow *arg1 = (wxWindow *) 0 ;
31045 wxSizer *arg2 = (wxSizer *) 0 ;
31046 bool arg3 = (bool) true ;
31047 PyObject * obj0 = 0 ;
31048 PyObject * obj1 = 0 ;
31049 PyObject * obj2 = 0 ;
31050 char *kwnames[] = {
31051 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31052 };
31053
31054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31056 if (SWIG_arg_fail(1)) SWIG_fail;
31057 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31058 if (SWIG_arg_fail(2)) SWIG_fail;
31059 if (obj2) {
31060 {
31061 arg3 = (bool)(SWIG_As_bool(obj2));
31062 if (SWIG_arg_fail(3)) SWIG_fail;
31063 }
31064 }
31065 {
31066 PyThreadState* __tstate = wxPyBeginAllowThreads();
31067 (arg1)->SetSizer(arg2,arg3);
31068
31069 wxPyEndAllowThreads(__tstate);
31070 if (PyErr_Occurred()) SWIG_fail;
31071 }
31072 Py_INCREF(Py_None); resultobj = Py_None;
31073 return resultobj;
31074 fail:
31075 return NULL;
31076 }
31077
31078
31079 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31080 PyObject *resultobj;
31081 wxWindow *arg1 = (wxWindow *) 0 ;
31082 wxSizer *arg2 = (wxSizer *) 0 ;
31083 bool arg3 = (bool) true ;
31084 PyObject * obj0 = 0 ;
31085 PyObject * obj1 = 0 ;
31086 PyObject * obj2 = 0 ;
31087 char *kwnames[] = {
31088 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31089 };
31090
31091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31093 if (SWIG_arg_fail(1)) SWIG_fail;
31094 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31095 if (SWIG_arg_fail(2)) SWIG_fail;
31096 if (obj2) {
31097 {
31098 arg3 = (bool)(SWIG_As_bool(obj2));
31099 if (SWIG_arg_fail(3)) SWIG_fail;
31100 }
31101 }
31102 {
31103 PyThreadState* __tstate = wxPyBeginAllowThreads();
31104 (arg1)->SetSizerAndFit(arg2,arg3);
31105
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 Py_INCREF(Py_None); resultobj = Py_None;
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31117 PyObject *resultobj;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 wxSizer *result;
31120 PyObject * obj0 = 0 ;
31121 char *kwnames[] = {
31122 (char *) "self", NULL
31123 };
31124
31125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31127 if (SWIG_arg_fail(1)) SWIG_fail;
31128 {
31129 PyThreadState* __tstate = wxPyBeginAllowThreads();
31130 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31131
31132 wxPyEndAllowThreads(__tstate);
31133 if (PyErr_Occurred()) SWIG_fail;
31134 }
31135 {
31136 resultobj = wxPyMake_wxSizer(result, 0);
31137 }
31138 return resultobj;
31139 fail:
31140 return NULL;
31141 }
31142
31143
31144 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31145 PyObject *resultobj;
31146 wxWindow *arg1 = (wxWindow *) 0 ;
31147 wxSizer *arg2 = (wxSizer *) 0 ;
31148 PyObject * obj0 = 0 ;
31149 PyObject * obj1 = 0 ;
31150 char *kwnames[] = {
31151 (char *) "self",(char *) "sizer", NULL
31152 };
31153
31154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31158 if (SWIG_arg_fail(2)) SWIG_fail;
31159 {
31160 PyThreadState* __tstate = wxPyBeginAllowThreads();
31161 (arg1)->SetContainingSizer(arg2);
31162
31163 wxPyEndAllowThreads(__tstate);
31164 if (PyErr_Occurred()) SWIG_fail;
31165 }
31166 Py_INCREF(Py_None); resultobj = Py_None;
31167 return resultobj;
31168 fail:
31169 return NULL;
31170 }
31171
31172
31173 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31174 PyObject *resultobj;
31175 wxWindow *arg1 = (wxWindow *) 0 ;
31176 wxSizer *result;
31177 PyObject * obj0 = 0 ;
31178 char *kwnames[] = {
31179 (char *) "self", NULL
31180 };
31181
31182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",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 = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31188
31189 wxPyEndAllowThreads(__tstate);
31190 if (PyErr_Occurred()) SWIG_fail;
31191 }
31192 {
31193 resultobj = wxPyMake_wxSizer(result, 0);
31194 }
31195 return resultobj;
31196 fail:
31197 return NULL;
31198 }
31199
31200
31201 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31202 PyObject *resultobj;
31203 wxWindow *arg1 = (wxWindow *) 0 ;
31204 PyObject * obj0 = 0 ;
31205 char *kwnames[] = {
31206 (char *) "self", NULL
31207 };
31208
31209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31211 if (SWIG_arg_fail(1)) SWIG_fail;
31212 {
31213 PyThreadState* __tstate = wxPyBeginAllowThreads();
31214 (arg1)->InheritAttributes();
31215
31216 wxPyEndAllowThreads(__tstate);
31217 if (PyErr_Occurred()) SWIG_fail;
31218 }
31219 Py_INCREF(Py_None); resultobj = Py_None;
31220 return resultobj;
31221 fail:
31222 return NULL;
31223 }
31224
31225
31226 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31227 PyObject *resultobj;
31228 wxWindow *arg1 = (wxWindow *) 0 ;
31229 bool result;
31230 PyObject * obj0 = 0 ;
31231 char *kwnames[] = {
31232 (char *) "self", NULL
31233 };
31234
31235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31237 if (SWIG_arg_fail(1)) SWIG_fail;
31238 {
31239 PyThreadState* __tstate = wxPyBeginAllowThreads();
31240 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31241
31242 wxPyEndAllowThreads(__tstate);
31243 if (PyErr_Occurred()) SWIG_fail;
31244 }
31245 {
31246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31247 }
31248 return resultobj;
31249 fail:
31250 return NULL;
31251 }
31252
31253
31254 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31255 PyObject *obj;
31256 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31257 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31258 Py_INCREF(obj);
31259 return Py_BuildValue((char *)"");
31260 }
31261 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31262 PyObject *resultobj;
31263 long arg1 ;
31264 wxWindow *arg2 = (wxWindow *) NULL ;
31265 wxWindow *result;
31266 PyObject * obj0 = 0 ;
31267 PyObject * obj1 = 0 ;
31268 char *kwnames[] = {
31269 (char *) "id",(char *) "parent", NULL
31270 };
31271
31272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31273 {
31274 arg1 = (long)(SWIG_As_long(obj0));
31275 if (SWIG_arg_fail(1)) SWIG_fail;
31276 }
31277 if (obj1) {
31278 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31279 if (SWIG_arg_fail(2)) SWIG_fail;
31280 }
31281 {
31282 if (!wxPyCheckForApp()) SWIG_fail;
31283 PyThreadState* __tstate = wxPyBeginAllowThreads();
31284 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31285
31286 wxPyEndAllowThreads(__tstate);
31287 if (PyErr_Occurred()) SWIG_fail;
31288 }
31289 {
31290 resultobj = wxPyMake_wxObject(result, 0);
31291 }
31292 return resultobj;
31293 fail:
31294 return NULL;
31295 }
31296
31297
31298 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31299 PyObject *resultobj;
31300 wxString *arg1 = 0 ;
31301 wxWindow *arg2 = (wxWindow *) NULL ;
31302 wxWindow *result;
31303 bool temp1 = false ;
31304 PyObject * obj0 = 0 ;
31305 PyObject * obj1 = 0 ;
31306 char *kwnames[] = {
31307 (char *) "name",(char *) "parent", NULL
31308 };
31309
31310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31311 {
31312 arg1 = wxString_in_helper(obj0);
31313 if (arg1 == NULL) SWIG_fail;
31314 temp1 = true;
31315 }
31316 if (obj1) {
31317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31318 if (SWIG_arg_fail(2)) SWIG_fail;
31319 }
31320 {
31321 if (!wxPyCheckForApp()) SWIG_fail;
31322 PyThreadState* __tstate = wxPyBeginAllowThreads();
31323 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31324
31325 wxPyEndAllowThreads(__tstate);
31326 if (PyErr_Occurred()) SWIG_fail;
31327 }
31328 {
31329 resultobj = wxPyMake_wxObject(result, 0);
31330 }
31331 {
31332 if (temp1)
31333 delete arg1;
31334 }
31335 return resultobj;
31336 fail:
31337 {
31338 if (temp1)
31339 delete arg1;
31340 }
31341 return NULL;
31342 }
31343
31344
31345 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31346 PyObject *resultobj;
31347 wxString *arg1 = 0 ;
31348 wxWindow *arg2 = (wxWindow *) NULL ;
31349 wxWindow *result;
31350 bool temp1 = false ;
31351 PyObject * obj0 = 0 ;
31352 PyObject * obj1 = 0 ;
31353 char *kwnames[] = {
31354 (char *) "label",(char *) "parent", NULL
31355 };
31356
31357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31358 {
31359 arg1 = wxString_in_helper(obj0);
31360 if (arg1 == NULL) SWIG_fail;
31361 temp1 = true;
31362 }
31363 if (obj1) {
31364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31365 if (SWIG_arg_fail(2)) SWIG_fail;
31366 }
31367 {
31368 if (!wxPyCheckForApp()) SWIG_fail;
31369 PyThreadState* __tstate = wxPyBeginAllowThreads();
31370 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31371
31372 wxPyEndAllowThreads(__tstate);
31373 if (PyErr_Occurred()) SWIG_fail;
31374 }
31375 {
31376 resultobj = wxPyMake_wxObject(result, 0);
31377 }
31378 {
31379 if (temp1)
31380 delete arg1;
31381 }
31382 return resultobj;
31383 fail:
31384 {
31385 if (temp1)
31386 delete arg1;
31387 }
31388 return NULL;
31389 }
31390
31391
31392 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31393 PyObject *resultobj;
31394 wxWindow *arg1 = (wxWindow *) 0 ;
31395 unsigned long arg2 ;
31396 wxWindow *result;
31397 PyObject * obj0 = 0 ;
31398 PyObject * obj1 = 0 ;
31399 char *kwnames[] = {
31400 (char *) "parent",(char *) "_hWnd", NULL
31401 };
31402
31403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31405 if (SWIG_arg_fail(1)) SWIG_fail;
31406 {
31407 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31408 if (SWIG_arg_fail(2)) SWIG_fail;
31409 }
31410 {
31411 PyThreadState* __tstate = wxPyBeginAllowThreads();
31412 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31413
31414 wxPyEndAllowThreads(__tstate);
31415 if (PyErr_Occurred()) SWIG_fail;
31416 }
31417 {
31418 resultobj = wxPyMake_wxObject(result, 0);
31419 }
31420 return resultobj;
31421 fail:
31422 return NULL;
31423 }
31424
31425
31426 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31427 PyObject *resultobj;
31428 wxValidator *result;
31429 char *kwnames[] = {
31430 NULL
31431 };
31432
31433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31434 {
31435 PyThreadState* __tstate = wxPyBeginAllowThreads();
31436 result = (wxValidator *)new wxValidator();
31437
31438 wxPyEndAllowThreads(__tstate);
31439 if (PyErr_Occurred()) SWIG_fail;
31440 }
31441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31442 return resultobj;
31443 fail:
31444 return NULL;
31445 }
31446
31447
31448 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31449 PyObject *resultobj;
31450 wxValidator *arg1 = (wxValidator *) 0 ;
31451 wxValidator *result;
31452 PyObject * obj0 = 0 ;
31453 char *kwnames[] = {
31454 (char *) "self", NULL
31455 };
31456
31457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31459 if (SWIG_arg_fail(1)) SWIG_fail;
31460 {
31461 PyThreadState* __tstate = wxPyBeginAllowThreads();
31462 result = (wxValidator *)(arg1)->Clone();
31463
31464 wxPyEndAllowThreads(__tstate);
31465 if (PyErr_Occurred()) SWIG_fail;
31466 }
31467 {
31468 resultobj = wxPyMake_wxObject(result, 0);
31469 }
31470 return resultobj;
31471 fail:
31472 return NULL;
31473 }
31474
31475
31476 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31477 PyObject *resultobj;
31478 wxValidator *arg1 = (wxValidator *) 0 ;
31479 wxWindow *arg2 = (wxWindow *) 0 ;
31480 bool result;
31481 PyObject * obj0 = 0 ;
31482 PyObject * obj1 = 0 ;
31483 char *kwnames[] = {
31484 (char *) "self",(char *) "parent", NULL
31485 };
31486
31487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31489 if (SWIG_arg_fail(1)) SWIG_fail;
31490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31491 if (SWIG_arg_fail(2)) SWIG_fail;
31492 {
31493 PyThreadState* __tstate = wxPyBeginAllowThreads();
31494 result = (bool)(arg1)->Validate(arg2);
31495
31496 wxPyEndAllowThreads(__tstate);
31497 if (PyErr_Occurred()) SWIG_fail;
31498 }
31499 {
31500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31501 }
31502 return resultobj;
31503 fail:
31504 return NULL;
31505 }
31506
31507
31508 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31509 PyObject *resultobj;
31510 wxValidator *arg1 = (wxValidator *) 0 ;
31511 bool result;
31512 PyObject * obj0 = 0 ;
31513 char *kwnames[] = {
31514 (char *) "self", NULL
31515 };
31516
31517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31519 if (SWIG_arg_fail(1)) SWIG_fail;
31520 {
31521 PyThreadState* __tstate = wxPyBeginAllowThreads();
31522 result = (bool)(arg1)->TransferToWindow();
31523
31524 wxPyEndAllowThreads(__tstate);
31525 if (PyErr_Occurred()) SWIG_fail;
31526 }
31527 {
31528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31529 }
31530 return resultobj;
31531 fail:
31532 return NULL;
31533 }
31534
31535
31536 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31537 PyObject *resultobj;
31538 wxValidator *arg1 = (wxValidator *) 0 ;
31539 bool result;
31540 PyObject * obj0 = 0 ;
31541 char *kwnames[] = {
31542 (char *) "self", NULL
31543 };
31544
31545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31547 if (SWIG_arg_fail(1)) SWIG_fail;
31548 {
31549 PyThreadState* __tstate = wxPyBeginAllowThreads();
31550 result = (bool)(arg1)->TransferFromWindow();
31551
31552 wxPyEndAllowThreads(__tstate);
31553 if (PyErr_Occurred()) SWIG_fail;
31554 }
31555 {
31556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31557 }
31558 return resultobj;
31559 fail:
31560 return NULL;
31561 }
31562
31563
31564 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31565 PyObject *resultobj;
31566 wxValidator *arg1 = (wxValidator *) 0 ;
31567 wxWindow *result;
31568 PyObject * obj0 = 0 ;
31569 char *kwnames[] = {
31570 (char *) "self", NULL
31571 };
31572
31573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31575 if (SWIG_arg_fail(1)) SWIG_fail;
31576 {
31577 PyThreadState* __tstate = wxPyBeginAllowThreads();
31578 result = (wxWindow *)(arg1)->GetWindow();
31579
31580 wxPyEndAllowThreads(__tstate);
31581 if (PyErr_Occurred()) SWIG_fail;
31582 }
31583 {
31584 resultobj = wxPyMake_wxObject(result, 0);
31585 }
31586 return resultobj;
31587 fail:
31588 return NULL;
31589 }
31590
31591
31592 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31593 PyObject *resultobj;
31594 wxValidator *arg1 = (wxValidator *) 0 ;
31595 wxWindow *arg2 = (wxWindow *) 0 ;
31596 PyObject * obj0 = 0 ;
31597 PyObject * obj1 = 0 ;
31598 char *kwnames[] = {
31599 (char *) "self",(char *) "window", NULL
31600 };
31601
31602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31604 if (SWIG_arg_fail(1)) SWIG_fail;
31605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31606 if (SWIG_arg_fail(2)) SWIG_fail;
31607 {
31608 PyThreadState* __tstate = wxPyBeginAllowThreads();
31609 (arg1)->SetWindow(arg2);
31610
31611 wxPyEndAllowThreads(__tstate);
31612 if (PyErr_Occurred()) SWIG_fail;
31613 }
31614 Py_INCREF(Py_None); resultobj = Py_None;
31615 return resultobj;
31616 fail:
31617 return NULL;
31618 }
31619
31620
31621 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31622 PyObject *resultobj;
31623 bool result;
31624 char *kwnames[] = {
31625 NULL
31626 };
31627
31628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31629 {
31630 PyThreadState* __tstate = wxPyBeginAllowThreads();
31631 result = (bool)wxValidator::IsSilent();
31632
31633 wxPyEndAllowThreads(__tstate);
31634 if (PyErr_Occurred()) SWIG_fail;
31635 }
31636 {
31637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31638 }
31639 return resultobj;
31640 fail:
31641 return NULL;
31642 }
31643
31644
31645 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31646 PyObject *resultobj;
31647 int arg1 = (int) true ;
31648 PyObject * obj0 = 0 ;
31649 char *kwnames[] = {
31650 (char *) "doIt", NULL
31651 };
31652
31653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31654 if (obj0) {
31655 {
31656 arg1 = (int)(SWIG_As_int(obj0));
31657 if (SWIG_arg_fail(1)) SWIG_fail;
31658 }
31659 }
31660 {
31661 PyThreadState* __tstate = wxPyBeginAllowThreads();
31662 wxValidator::SetBellOnError(arg1);
31663
31664 wxPyEndAllowThreads(__tstate);
31665 if (PyErr_Occurred()) SWIG_fail;
31666 }
31667 Py_INCREF(Py_None); resultobj = Py_None;
31668 return resultobj;
31669 fail:
31670 return NULL;
31671 }
31672
31673
31674 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31675 PyObject *obj;
31676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31677 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31678 Py_INCREF(obj);
31679 return Py_BuildValue((char *)"");
31680 }
31681 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31682 PyObject *resultobj;
31683 wxPyValidator *result;
31684 char *kwnames[] = {
31685 NULL
31686 };
31687
31688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31689 {
31690 PyThreadState* __tstate = wxPyBeginAllowThreads();
31691 result = (wxPyValidator *)new wxPyValidator();
31692
31693 wxPyEndAllowThreads(__tstate);
31694 if (PyErr_Occurred()) SWIG_fail;
31695 }
31696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31697 return resultobj;
31698 fail:
31699 return NULL;
31700 }
31701
31702
31703 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31704 PyObject *resultobj;
31705 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31706 PyObject *arg2 = (PyObject *) 0 ;
31707 PyObject *arg3 = (PyObject *) 0 ;
31708 int arg4 = (int) true ;
31709 PyObject * obj0 = 0 ;
31710 PyObject * obj1 = 0 ;
31711 PyObject * obj2 = 0 ;
31712 PyObject * obj3 = 0 ;
31713 char *kwnames[] = {
31714 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
31715 };
31716
31717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
31719 if (SWIG_arg_fail(1)) SWIG_fail;
31720 arg2 = obj1;
31721 arg3 = obj2;
31722 if (obj3) {
31723 {
31724 arg4 = (int)(SWIG_As_int(obj3));
31725 if (SWIG_arg_fail(4)) SWIG_fail;
31726 }
31727 }
31728 {
31729 PyThreadState* __tstate = wxPyBeginAllowThreads();
31730 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
31731
31732 wxPyEndAllowThreads(__tstate);
31733 if (PyErr_Occurred()) SWIG_fail;
31734 }
31735 Py_INCREF(Py_None); resultobj = Py_None;
31736 return resultobj;
31737 fail:
31738 return NULL;
31739 }
31740
31741
31742 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
31743 PyObject *obj;
31744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31745 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
31746 Py_INCREF(obj);
31747 return Py_BuildValue((char *)"");
31748 }
31749 static int _wrap_DefaultValidator_set(PyObject *) {
31750 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
31751 return 1;
31752 }
31753
31754
31755 static PyObject *_wrap_DefaultValidator_get(void) {
31756 PyObject *pyobj;
31757
31758 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
31759 return pyobj;
31760 }
31761
31762
31763 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
31764 PyObject *resultobj;
31765 wxString const &arg1_defvalue = wxPyEmptyString ;
31766 wxString *arg1 = (wxString *) &arg1_defvalue ;
31767 long arg2 = (long) 0 ;
31768 wxMenu *result;
31769 bool temp1 = false ;
31770 PyObject * obj0 = 0 ;
31771 PyObject * obj1 = 0 ;
31772 char *kwnames[] = {
31773 (char *) "title",(char *) "style", NULL
31774 };
31775
31776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
31777 if (obj0) {
31778 {
31779 arg1 = wxString_in_helper(obj0);
31780 if (arg1 == NULL) SWIG_fail;
31781 temp1 = true;
31782 }
31783 }
31784 if (obj1) {
31785 {
31786 arg2 = (long)(SWIG_As_long(obj1));
31787 if (SWIG_arg_fail(2)) SWIG_fail;
31788 }
31789 }
31790 {
31791 if (!wxPyCheckForApp()) SWIG_fail;
31792 PyThreadState* __tstate = wxPyBeginAllowThreads();
31793 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
31794
31795 wxPyEndAllowThreads(__tstate);
31796 if (PyErr_Occurred()) SWIG_fail;
31797 }
31798 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
31799 {
31800 if (temp1)
31801 delete arg1;
31802 }
31803 return resultobj;
31804 fail:
31805 {
31806 if (temp1)
31807 delete arg1;
31808 }
31809 return NULL;
31810 }
31811
31812
31813 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
31814 PyObject *resultobj;
31815 wxMenu *arg1 = (wxMenu *) 0 ;
31816 int arg2 ;
31817 wxString *arg3 = 0 ;
31818 wxString const &arg4_defvalue = wxPyEmptyString ;
31819 wxString *arg4 = (wxString *) &arg4_defvalue ;
31820 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
31821 wxMenuItem *result;
31822 bool temp3 = false ;
31823 bool temp4 = false ;
31824 PyObject * obj0 = 0 ;
31825 PyObject * obj1 = 0 ;
31826 PyObject * obj2 = 0 ;
31827 PyObject * obj3 = 0 ;
31828 PyObject * obj4 = 0 ;
31829 char *kwnames[] = {
31830 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
31831 };
31832
31833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
31834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31835 if (SWIG_arg_fail(1)) SWIG_fail;
31836 {
31837 arg2 = (int)(SWIG_As_int(obj1));
31838 if (SWIG_arg_fail(2)) SWIG_fail;
31839 }
31840 {
31841 arg3 = wxString_in_helper(obj2);
31842 if (arg3 == NULL) SWIG_fail;
31843 temp3 = true;
31844 }
31845 if (obj3) {
31846 {
31847 arg4 = wxString_in_helper(obj3);
31848 if (arg4 == NULL) SWIG_fail;
31849 temp4 = true;
31850 }
31851 }
31852 if (obj4) {
31853 {
31854 arg5 = (wxItemKind)(SWIG_As_int(obj4));
31855 if (SWIG_arg_fail(5)) SWIG_fail;
31856 }
31857 }
31858 {
31859 PyThreadState* __tstate = wxPyBeginAllowThreads();
31860 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
31861
31862 wxPyEndAllowThreads(__tstate);
31863 if (PyErr_Occurred()) SWIG_fail;
31864 }
31865 {
31866 resultobj = wxPyMake_wxObject(result, 0);
31867 }
31868 {
31869 if (temp3)
31870 delete arg3;
31871 }
31872 {
31873 if (temp4)
31874 delete arg4;
31875 }
31876 return resultobj;
31877 fail:
31878 {
31879 if (temp3)
31880 delete arg3;
31881 }
31882 {
31883 if (temp4)
31884 delete arg4;
31885 }
31886 return NULL;
31887 }
31888
31889
31890 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
31891 PyObject *resultobj;
31892 wxMenu *arg1 = (wxMenu *) 0 ;
31893 wxMenuItem *result;
31894 PyObject * obj0 = 0 ;
31895 char *kwnames[] = {
31896 (char *) "self", NULL
31897 };
31898
31899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
31900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31901 if (SWIG_arg_fail(1)) SWIG_fail;
31902 {
31903 PyThreadState* __tstate = wxPyBeginAllowThreads();
31904 result = (wxMenuItem *)(arg1)->AppendSeparator();
31905
31906 wxPyEndAllowThreads(__tstate);
31907 if (PyErr_Occurred()) SWIG_fail;
31908 }
31909 {
31910 resultobj = wxPyMake_wxObject(result, 0);
31911 }
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
31919 PyObject *resultobj;
31920 wxMenu *arg1 = (wxMenu *) 0 ;
31921 int arg2 ;
31922 wxString *arg3 = 0 ;
31923 wxString const &arg4_defvalue = wxPyEmptyString ;
31924 wxString *arg4 = (wxString *) &arg4_defvalue ;
31925 wxMenuItem *result;
31926 bool temp3 = false ;
31927 bool temp4 = false ;
31928 PyObject * obj0 = 0 ;
31929 PyObject * obj1 = 0 ;
31930 PyObject * obj2 = 0 ;
31931 PyObject * obj3 = 0 ;
31932 char *kwnames[] = {
31933 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31934 };
31935
31936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31938 if (SWIG_arg_fail(1)) SWIG_fail;
31939 {
31940 arg2 = (int)(SWIG_As_int(obj1));
31941 if (SWIG_arg_fail(2)) SWIG_fail;
31942 }
31943 {
31944 arg3 = wxString_in_helper(obj2);
31945 if (arg3 == NULL) SWIG_fail;
31946 temp3 = true;
31947 }
31948 if (obj3) {
31949 {
31950 arg4 = wxString_in_helper(obj3);
31951 if (arg4 == NULL) SWIG_fail;
31952 temp4 = true;
31953 }
31954 }
31955 {
31956 PyThreadState* __tstate = wxPyBeginAllowThreads();
31957 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
31958
31959 wxPyEndAllowThreads(__tstate);
31960 if (PyErr_Occurred()) SWIG_fail;
31961 }
31962 {
31963 resultobj = wxPyMake_wxObject(result, 0);
31964 }
31965 {
31966 if (temp3)
31967 delete arg3;
31968 }
31969 {
31970 if (temp4)
31971 delete arg4;
31972 }
31973 return resultobj;
31974 fail:
31975 {
31976 if (temp3)
31977 delete arg3;
31978 }
31979 {
31980 if (temp4)
31981 delete arg4;
31982 }
31983 return NULL;
31984 }
31985
31986
31987 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
31988 PyObject *resultobj;
31989 wxMenu *arg1 = (wxMenu *) 0 ;
31990 int arg2 ;
31991 wxString *arg3 = 0 ;
31992 wxString const &arg4_defvalue = wxPyEmptyString ;
31993 wxString *arg4 = (wxString *) &arg4_defvalue ;
31994 wxMenuItem *result;
31995 bool temp3 = false ;
31996 bool temp4 = false ;
31997 PyObject * obj0 = 0 ;
31998 PyObject * obj1 = 0 ;
31999 PyObject * obj2 = 0 ;
32000 PyObject * obj3 = 0 ;
32001 char *kwnames[] = {
32002 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32003 };
32004
32005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32007 if (SWIG_arg_fail(1)) SWIG_fail;
32008 {
32009 arg2 = (int)(SWIG_As_int(obj1));
32010 if (SWIG_arg_fail(2)) SWIG_fail;
32011 }
32012 {
32013 arg3 = wxString_in_helper(obj2);
32014 if (arg3 == NULL) SWIG_fail;
32015 temp3 = true;
32016 }
32017 if (obj3) {
32018 {
32019 arg4 = wxString_in_helper(obj3);
32020 if (arg4 == NULL) SWIG_fail;
32021 temp4 = true;
32022 }
32023 }
32024 {
32025 PyThreadState* __tstate = wxPyBeginAllowThreads();
32026 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32027
32028 wxPyEndAllowThreads(__tstate);
32029 if (PyErr_Occurred()) SWIG_fail;
32030 }
32031 {
32032 resultobj = wxPyMake_wxObject(result, 0);
32033 }
32034 {
32035 if (temp3)
32036 delete arg3;
32037 }
32038 {
32039 if (temp4)
32040 delete arg4;
32041 }
32042 return resultobj;
32043 fail:
32044 {
32045 if (temp3)
32046 delete arg3;
32047 }
32048 {
32049 if (temp4)
32050 delete arg4;
32051 }
32052 return NULL;
32053 }
32054
32055
32056 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32057 PyObject *resultobj;
32058 wxMenu *arg1 = (wxMenu *) 0 ;
32059 int arg2 ;
32060 wxString *arg3 = 0 ;
32061 wxMenu *arg4 = (wxMenu *) 0 ;
32062 wxString const &arg5_defvalue = wxPyEmptyString ;
32063 wxString *arg5 = (wxString *) &arg5_defvalue ;
32064 wxMenuItem *result;
32065 bool temp3 = false ;
32066 bool temp5 = false ;
32067 PyObject * obj0 = 0 ;
32068 PyObject * obj1 = 0 ;
32069 PyObject * obj2 = 0 ;
32070 PyObject * obj3 = 0 ;
32071 PyObject * obj4 = 0 ;
32072 char *kwnames[] = {
32073 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32074 };
32075
32076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32078 if (SWIG_arg_fail(1)) SWIG_fail;
32079 {
32080 arg2 = (int)(SWIG_As_int(obj1));
32081 if (SWIG_arg_fail(2)) SWIG_fail;
32082 }
32083 {
32084 arg3 = wxString_in_helper(obj2);
32085 if (arg3 == NULL) SWIG_fail;
32086 temp3 = true;
32087 }
32088 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32089 if (SWIG_arg_fail(4)) SWIG_fail;
32090 if (obj4) {
32091 {
32092 arg5 = wxString_in_helper(obj4);
32093 if (arg5 == NULL) SWIG_fail;
32094 temp5 = true;
32095 }
32096 }
32097 {
32098 PyThreadState* __tstate = wxPyBeginAllowThreads();
32099 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32100
32101 wxPyEndAllowThreads(__tstate);
32102 if (PyErr_Occurred()) SWIG_fail;
32103 }
32104 {
32105 resultobj = wxPyMake_wxObject(result, 0);
32106 }
32107 {
32108 if (temp3)
32109 delete arg3;
32110 }
32111 {
32112 if (temp5)
32113 delete arg5;
32114 }
32115 return resultobj;
32116 fail:
32117 {
32118 if (temp3)
32119 delete arg3;
32120 }
32121 {
32122 if (temp5)
32123 delete arg5;
32124 }
32125 return NULL;
32126 }
32127
32128
32129 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32130 PyObject *resultobj;
32131 wxMenu *arg1 = (wxMenu *) 0 ;
32132 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32133 wxMenuItem *result;
32134 PyObject * obj0 = 0 ;
32135 PyObject * obj1 = 0 ;
32136 char *kwnames[] = {
32137 (char *) "self",(char *) "item", NULL
32138 };
32139
32140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32142 if (SWIG_arg_fail(1)) SWIG_fail;
32143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32144 if (SWIG_arg_fail(2)) SWIG_fail;
32145 {
32146 PyThreadState* __tstate = wxPyBeginAllowThreads();
32147 result = (wxMenuItem *)(arg1)->Append(arg2);
32148
32149 wxPyEndAllowThreads(__tstate);
32150 if (PyErr_Occurred()) SWIG_fail;
32151 }
32152 {
32153 resultobj = wxPyMake_wxObject(result, 0);
32154 }
32155 return resultobj;
32156 fail:
32157 return NULL;
32158 }
32159
32160
32161 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32162 PyObject *resultobj;
32163 wxMenu *arg1 = (wxMenu *) 0 ;
32164 PyObject * obj0 = 0 ;
32165 char *kwnames[] = {
32166 (char *) "self", NULL
32167 };
32168
32169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32171 if (SWIG_arg_fail(1)) SWIG_fail;
32172 {
32173 PyThreadState* __tstate = wxPyBeginAllowThreads();
32174 (arg1)->Break();
32175
32176 wxPyEndAllowThreads(__tstate);
32177 if (PyErr_Occurred()) SWIG_fail;
32178 }
32179 Py_INCREF(Py_None); resultobj = Py_None;
32180 return resultobj;
32181 fail:
32182 return NULL;
32183 }
32184
32185
32186 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32187 PyObject *resultobj;
32188 wxMenu *arg1 = (wxMenu *) 0 ;
32189 size_t arg2 ;
32190 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32191 wxMenuItem *result;
32192 PyObject * obj0 = 0 ;
32193 PyObject * obj1 = 0 ;
32194 PyObject * obj2 = 0 ;
32195 char *kwnames[] = {
32196 (char *) "self",(char *) "pos",(char *) "item", NULL
32197 };
32198
32199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32201 if (SWIG_arg_fail(1)) SWIG_fail;
32202 {
32203 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32204 if (SWIG_arg_fail(2)) SWIG_fail;
32205 }
32206 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32207 if (SWIG_arg_fail(3)) SWIG_fail;
32208 {
32209 PyThreadState* __tstate = wxPyBeginAllowThreads();
32210 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32211
32212 wxPyEndAllowThreads(__tstate);
32213 if (PyErr_Occurred()) SWIG_fail;
32214 }
32215 {
32216 resultobj = wxPyMake_wxObject(result, 0);
32217 }
32218 return resultobj;
32219 fail:
32220 return NULL;
32221 }
32222
32223
32224 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32225 PyObject *resultobj;
32226 wxMenu *arg1 = (wxMenu *) 0 ;
32227 size_t arg2 ;
32228 int arg3 ;
32229 wxString *arg4 = 0 ;
32230 wxString const &arg5_defvalue = wxPyEmptyString ;
32231 wxString *arg5 = (wxString *) &arg5_defvalue ;
32232 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32233 wxMenuItem *result;
32234 bool temp4 = false ;
32235 bool temp5 = false ;
32236 PyObject * obj0 = 0 ;
32237 PyObject * obj1 = 0 ;
32238 PyObject * obj2 = 0 ;
32239 PyObject * obj3 = 0 ;
32240 PyObject * obj4 = 0 ;
32241 PyObject * obj5 = 0 ;
32242 char *kwnames[] = {
32243 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32244 };
32245
32246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32248 if (SWIG_arg_fail(1)) SWIG_fail;
32249 {
32250 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32251 if (SWIG_arg_fail(2)) SWIG_fail;
32252 }
32253 {
32254 arg3 = (int)(SWIG_As_int(obj2));
32255 if (SWIG_arg_fail(3)) SWIG_fail;
32256 }
32257 {
32258 arg4 = wxString_in_helper(obj3);
32259 if (arg4 == NULL) SWIG_fail;
32260 temp4 = true;
32261 }
32262 if (obj4) {
32263 {
32264 arg5 = wxString_in_helper(obj4);
32265 if (arg5 == NULL) SWIG_fail;
32266 temp5 = true;
32267 }
32268 }
32269 if (obj5) {
32270 {
32271 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32272 if (SWIG_arg_fail(6)) SWIG_fail;
32273 }
32274 }
32275 {
32276 PyThreadState* __tstate = wxPyBeginAllowThreads();
32277 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32278
32279 wxPyEndAllowThreads(__tstate);
32280 if (PyErr_Occurred()) SWIG_fail;
32281 }
32282 {
32283 resultobj = wxPyMake_wxObject(result, 0);
32284 }
32285 {
32286 if (temp4)
32287 delete arg4;
32288 }
32289 {
32290 if (temp5)
32291 delete arg5;
32292 }
32293 return resultobj;
32294 fail:
32295 {
32296 if (temp4)
32297 delete arg4;
32298 }
32299 {
32300 if (temp5)
32301 delete arg5;
32302 }
32303 return NULL;
32304 }
32305
32306
32307 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32308 PyObject *resultobj;
32309 wxMenu *arg1 = (wxMenu *) 0 ;
32310 size_t arg2 ;
32311 wxMenuItem *result;
32312 PyObject * obj0 = 0 ;
32313 PyObject * obj1 = 0 ;
32314 char *kwnames[] = {
32315 (char *) "self",(char *) "pos", NULL
32316 };
32317
32318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32320 if (SWIG_arg_fail(1)) SWIG_fail;
32321 {
32322 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32323 if (SWIG_arg_fail(2)) SWIG_fail;
32324 }
32325 {
32326 PyThreadState* __tstate = wxPyBeginAllowThreads();
32327 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32328
32329 wxPyEndAllowThreads(__tstate);
32330 if (PyErr_Occurred()) SWIG_fail;
32331 }
32332 {
32333 resultobj = wxPyMake_wxObject(result, 0);
32334 }
32335 return resultobj;
32336 fail:
32337 return NULL;
32338 }
32339
32340
32341 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32342 PyObject *resultobj;
32343 wxMenu *arg1 = (wxMenu *) 0 ;
32344 size_t arg2 ;
32345 int arg3 ;
32346 wxString *arg4 = 0 ;
32347 wxString const &arg5_defvalue = wxPyEmptyString ;
32348 wxString *arg5 = (wxString *) &arg5_defvalue ;
32349 wxMenuItem *result;
32350 bool temp4 = false ;
32351 bool temp5 = false ;
32352 PyObject * obj0 = 0 ;
32353 PyObject * obj1 = 0 ;
32354 PyObject * obj2 = 0 ;
32355 PyObject * obj3 = 0 ;
32356 PyObject * obj4 = 0 ;
32357 char *kwnames[] = {
32358 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32359 };
32360
32361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32363 if (SWIG_arg_fail(1)) SWIG_fail;
32364 {
32365 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32366 if (SWIG_arg_fail(2)) SWIG_fail;
32367 }
32368 {
32369 arg3 = (int)(SWIG_As_int(obj2));
32370 if (SWIG_arg_fail(3)) SWIG_fail;
32371 }
32372 {
32373 arg4 = wxString_in_helper(obj3);
32374 if (arg4 == NULL) SWIG_fail;
32375 temp4 = true;
32376 }
32377 if (obj4) {
32378 {
32379 arg5 = wxString_in_helper(obj4);
32380 if (arg5 == NULL) SWIG_fail;
32381 temp5 = true;
32382 }
32383 }
32384 {
32385 PyThreadState* __tstate = wxPyBeginAllowThreads();
32386 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32387
32388 wxPyEndAllowThreads(__tstate);
32389 if (PyErr_Occurred()) SWIG_fail;
32390 }
32391 {
32392 resultobj = wxPyMake_wxObject(result, 0);
32393 }
32394 {
32395 if (temp4)
32396 delete arg4;
32397 }
32398 {
32399 if (temp5)
32400 delete arg5;
32401 }
32402 return resultobj;
32403 fail:
32404 {
32405 if (temp4)
32406 delete arg4;
32407 }
32408 {
32409 if (temp5)
32410 delete arg5;
32411 }
32412 return NULL;
32413 }
32414
32415
32416 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32417 PyObject *resultobj;
32418 wxMenu *arg1 = (wxMenu *) 0 ;
32419 size_t arg2 ;
32420 int arg3 ;
32421 wxString *arg4 = 0 ;
32422 wxString const &arg5_defvalue = wxPyEmptyString ;
32423 wxString *arg5 = (wxString *) &arg5_defvalue ;
32424 wxMenuItem *result;
32425 bool temp4 = false ;
32426 bool temp5 = false ;
32427 PyObject * obj0 = 0 ;
32428 PyObject * obj1 = 0 ;
32429 PyObject * obj2 = 0 ;
32430 PyObject * obj3 = 0 ;
32431 PyObject * obj4 = 0 ;
32432 char *kwnames[] = {
32433 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32434 };
32435
32436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32438 if (SWIG_arg_fail(1)) SWIG_fail;
32439 {
32440 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32441 if (SWIG_arg_fail(2)) SWIG_fail;
32442 }
32443 {
32444 arg3 = (int)(SWIG_As_int(obj2));
32445 if (SWIG_arg_fail(3)) SWIG_fail;
32446 }
32447 {
32448 arg4 = wxString_in_helper(obj3);
32449 if (arg4 == NULL) SWIG_fail;
32450 temp4 = true;
32451 }
32452 if (obj4) {
32453 {
32454 arg5 = wxString_in_helper(obj4);
32455 if (arg5 == NULL) SWIG_fail;
32456 temp5 = true;
32457 }
32458 }
32459 {
32460 PyThreadState* __tstate = wxPyBeginAllowThreads();
32461 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32462
32463 wxPyEndAllowThreads(__tstate);
32464 if (PyErr_Occurred()) SWIG_fail;
32465 }
32466 {
32467 resultobj = wxPyMake_wxObject(result, 0);
32468 }
32469 {
32470 if (temp4)
32471 delete arg4;
32472 }
32473 {
32474 if (temp5)
32475 delete arg5;
32476 }
32477 return resultobj;
32478 fail:
32479 {
32480 if (temp4)
32481 delete arg4;
32482 }
32483 {
32484 if (temp5)
32485 delete arg5;
32486 }
32487 return NULL;
32488 }
32489
32490
32491 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32492 PyObject *resultobj;
32493 wxMenu *arg1 = (wxMenu *) 0 ;
32494 size_t arg2 ;
32495 int arg3 ;
32496 wxString *arg4 = 0 ;
32497 wxMenu *arg5 = (wxMenu *) 0 ;
32498 wxString const &arg6_defvalue = wxPyEmptyString ;
32499 wxString *arg6 = (wxString *) &arg6_defvalue ;
32500 wxMenuItem *result;
32501 bool temp4 = false ;
32502 bool temp6 = false ;
32503 PyObject * obj0 = 0 ;
32504 PyObject * obj1 = 0 ;
32505 PyObject * obj2 = 0 ;
32506 PyObject * obj3 = 0 ;
32507 PyObject * obj4 = 0 ;
32508 PyObject * obj5 = 0 ;
32509 char *kwnames[] = {
32510 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32511 };
32512
32513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32515 if (SWIG_arg_fail(1)) SWIG_fail;
32516 {
32517 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32518 if (SWIG_arg_fail(2)) SWIG_fail;
32519 }
32520 {
32521 arg3 = (int)(SWIG_As_int(obj2));
32522 if (SWIG_arg_fail(3)) SWIG_fail;
32523 }
32524 {
32525 arg4 = wxString_in_helper(obj3);
32526 if (arg4 == NULL) SWIG_fail;
32527 temp4 = true;
32528 }
32529 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32530 if (SWIG_arg_fail(5)) SWIG_fail;
32531 if (obj5) {
32532 {
32533 arg6 = wxString_in_helper(obj5);
32534 if (arg6 == NULL) SWIG_fail;
32535 temp6 = true;
32536 }
32537 }
32538 {
32539 PyThreadState* __tstate = wxPyBeginAllowThreads();
32540 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32541
32542 wxPyEndAllowThreads(__tstate);
32543 if (PyErr_Occurred()) SWIG_fail;
32544 }
32545 {
32546 resultobj = wxPyMake_wxObject(result, 0);
32547 }
32548 {
32549 if (temp4)
32550 delete arg4;
32551 }
32552 {
32553 if (temp6)
32554 delete arg6;
32555 }
32556 return resultobj;
32557 fail:
32558 {
32559 if (temp4)
32560 delete arg4;
32561 }
32562 {
32563 if (temp6)
32564 delete arg6;
32565 }
32566 return NULL;
32567 }
32568
32569
32570 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32571 PyObject *resultobj;
32572 wxMenu *arg1 = (wxMenu *) 0 ;
32573 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32574 wxMenuItem *result;
32575 PyObject * obj0 = 0 ;
32576 PyObject * obj1 = 0 ;
32577 char *kwnames[] = {
32578 (char *) "self",(char *) "item", NULL
32579 };
32580
32581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32583 if (SWIG_arg_fail(1)) SWIG_fail;
32584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32585 if (SWIG_arg_fail(2)) SWIG_fail;
32586 {
32587 PyThreadState* __tstate = wxPyBeginAllowThreads();
32588 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32589
32590 wxPyEndAllowThreads(__tstate);
32591 if (PyErr_Occurred()) SWIG_fail;
32592 }
32593 {
32594 resultobj = wxPyMake_wxObject(result, 0);
32595 }
32596 return resultobj;
32597 fail:
32598 return NULL;
32599 }
32600
32601
32602 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32603 PyObject *resultobj;
32604 wxMenu *arg1 = (wxMenu *) 0 ;
32605 int arg2 ;
32606 wxString *arg3 = 0 ;
32607 wxString const &arg4_defvalue = wxPyEmptyString ;
32608 wxString *arg4 = (wxString *) &arg4_defvalue ;
32609 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32610 wxMenuItem *result;
32611 bool temp3 = false ;
32612 bool temp4 = false ;
32613 PyObject * obj0 = 0 ;
32614 PyObject * obj1 = 0 ;
32615 PyObject * obj2 = 0 ;
32616 PyObject * obj3 = 0 ;
32617 PyObject * obj4 = 0 ;
32618 char *kwnames[] = {
32619 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32620 };
32621
32622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32624 if (SWIG_arg_fail(1)) SWIG_fail;
32625 {
32626 arg2 = (int)(SWIG_As_int(obj1));
32627 if (SWIG_arg_fail(2)) SWIG_fail;
32628 }
32629 {
32630 arg3 = wxString_in_helper(obj2);
32631 if (arg3 == NULL) SWIG_fail;
32632 temp3 = true;
32633 }
32634 if (obj3) {
32635 {
32636 arg4 = wxString_in_helper(obj3);
32637 if (arg4 == NULL) SWIG_fail;
32638 temp4 = true;
32639 }
32640 }
32641 if (obj4) {
32642 {
32643 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32644 if (SWIG_arg_fail(5)) SWIG_fail;
32645 }
32646 }
32647 {
32648 PyThreadState* __tstate = wxPyBeginAllowThreads();
32649 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32650
32651 wxPyEndAllowThreads(__tstate);
32652 if (PyErr_Occurred()) SWIG_fail;
32653 }
32654 {
32655 resultobj = wxPyMake_wxObject(result, 0);
32656 }
32657 {
32658 if (temp3)
32659 delete arg3;
32660 }
32661 {
32662 if (temp4)
32663 delete arg4;
32664 }
32665 return resultobj;
32666 fail:
32667 {
32668 if (temp3)
32669 delete arg3;
32670 }
32671 {
32672 if (temp4)
32673 delete arg4;
32674 }
32675 return NULL;
32676 }
32677
32678
32679 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32680 PyObject *resultobj;
32681 wxMenu *arg1 = (wxMenu *) 0 ;
32682 wxMenuItem *result;
32683 PyObject * obj0 = 0 ;
32684 char *kwnames[] = {
32685 (char *) "self", NULL
32686 };
32687
32688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32690 if (SWIG_arg_fail(1)) SWIG_fail;
32691 {
32692 PyThreadState* __tstate = wxPyBeginAllowThreads();
32693 result = (wxMenuItem *)(arg1)->PrependSeparator();
32694
32695 wxPyEndAllowThreads(__tstate);
32696 if (PyErr_Occurred()) SWIG_fail;
32697 }
32698 {
32699 resultobj = wxPyMake_wxObject(result, 0);
32700 }
32701 return resultobj;
32702 fail:
32703 return NULL;
32704 }
32705
32706
32707 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32708 PyObject *resultobj;
32709 wxMenu *arg1 = (wxMenu *) 0 ;
32710 int arg2 ;
32711 wxString *arg3 = 0 ;
32712 wxString const &arg4_defvalue = wxPyEmptyString ;
32713 wxString *arg4 = (wxString *) &arg4_defvalue ;
32714 wxMenuItem *result;
32715 bool temp3 = false ;
32716 bool temp4 = false ;
32717 PyObject * obj0 = 0 ;
32718 PyObject * obj1 = 0 ;
32719 PyObject * obj2 = 0 ;
32720 PyObject * obj3 = 0 ;
32721 char *kwnames[] = {
32722 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32723 };
32724
32725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32727 if (SWIG_arg_fail(1)) SWIG_fail;
32728 {
32729 arg2 = (int)(SWIG_As_int(obj1));
32730 if (SWIG_arg_fail(2)) SWIG_fail;
32731 }
32732 {
32733 arg3 = wxString_in_helper(obj2);
32734 if (arg3 == NULL) SWIG_fail;
32735 temp3 = true;
32736 }
32737 if (obj3) {
32738 {
32739 arg4 = wxString_in_helper(obj3);
32740 if (arg4 == NULL) SWIG_fail;
32741 temp4 = true;
32742 }
32743 }
32744 {
32745 PyThreadState* __tstate = wxPyBeginAllowThreads();
32746 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32747
32748 wxPyEndAllowThreads(__tstate);
32749 if (PyErr_Occurred()) SWIG_fail;
32750 }
32751 {
32752 resultobj = wxPyMake_wxObject(result, 0);
32753 }
32754 {
32755 if (temp3)
32756 delete arg3;
32757 }
32758 {
32759 if (temp4)
32760 delete arg4;
32761 }
32762 return resultobj;
32763 fail:
32764 {
32765 if (temp3)
32766 delete arg3;
32767 }
32768 {
32769 if (temp4)
32770 delete arg4;
32771 }
32772 return NULL;
32773 }
32774
32775
32776 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32777 PyObject *resultobj;
32778 wxMenu *arg1 = (wxMenu *) 0 ;
32779 int arg2 ;
32780 wxString *arg3 = 0 ;
32781 wxString const &arg4_defvalue = wxPyEmptyString ;
32782 wxString *arg4 = (wxString *) &arg4_defvalue ;
32783 wxMenuItem *result;
32784 bool temp3 = false ;
32785 bool temp4 = false ;
32786 PyObject * obj0 = 0 ;
32787 PyObject * obj1 = 0 ;
32788 PyObject * obj2 = 0 ;
32789 PyObject * obj3 = 0 ;
32790 char *kwnames[] = {
32791 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32792 };
32793
32794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32796 if (SWIG_arg_fail(1)) SWIG_fail;
32797 {
32798 arg2 = (int)(SWIG_As_int(obj1));
32799 if (SWIG_arg_fail(2)) SWIG_fail;
32800 }
32801 {
32802 arg3 = wxString_in_helper(obj2);
32803 if (arg3 == NULL) SWIG_fail;
32804 temp3 = true;
32805 }
32806 if (obj3) {
32807 {
32808 arg4 = wxString_in_helper(obj3);
32809 if (arg4 == NULL) SWIG_fail;
32810 temp4 = true;
32811 }
32812 }
32813 {
32814 PyThreadState* __tstate = wxPyBeginAllowThreads();
32815 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32816
32817 wxPyEndAllowThreads(__tstate);
32818 if (PyErr_Occurred()) SWIG_fail;
32819 }
32820 {
32821 resultobj = wxPyMake_wxObject(result, 0);
32822 }
32823 {
32824 if (temp3)
32825 delete arg3;
32826 }
32827 {
32828 if (temp4)
32829 delete arg4;
32830 }
32831 return resultobj;
32832 fail:
32833 {
32834 if (temp3)
32835 delete arg3;
32836 }
32837 {
32838 if (temp4)
32839 delete arg4;
32840 }
32841 return NULL;
32842 }
32843
32844
32845 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32846 PyObject *resultobj;
32847 wxMenu *arg1 = (wxMenu *) 0 ;
32848 int arg2 ;
32849 wxString *arg3 = 0 ;
32850 wxMenu *arg4 = (wxMenu *) 0 ;
32851 wxString const &arg5_defvalue = wxPyEmptyString ;
32852 wxString *arg5 = (wxString *) &arg5_defvalue ;
32853 wxMenuItem *result;
32854 bool temp3 = false ;
32855 bool temp5 = false ;
32856 PyObject * obj0 = 0 ;
32857 PyObject * obj1 = 0 ;
32858 PyObject * obj2 = 0 ;
32859 PyObject * obj3 = 0 ;
32860 PyObject * obj4 = 0 ;
32861 char *kwnames[] = {
32862 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32863 };
32864
32865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32867 if (SWIG_arg_fail(1)) SWIG_fail;
32868 {
32869 arg2 = (int)(SWIG_As_int(obj1));
32870 if (SWIG_arg_fail(2)) SWIG_fail;
32871 }
32872 {
32873 arg3 = wxString_in_helper(obj2);
32874 if (arg3 == NULL) SWIG_fail;
32875 temp3 = true;
32876 }
32877 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32878 if (SWIG_arg_fail(4)) SWIG_fail;
32879 if (obj4) {
32880 {
32881 arg5 = wxString_in_helper(obj4);
32882 if (arg5 == NULL) SWIG_fail;
32883 temp5 = true;
32884 }
32885 }
32886 {
32887 PyThreadState* __tstate = wxPyBeginAllowThreads();
32888 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32889
32890 wxPyEndAllowThreads(__tstate);
32891 if (PyErr_Occurred()) SWIG_fail;
32892 }
32893 {
32894 resultobj = wxPyMake_wxObject(result, 0);
32895 }
32896 {
32897 if (temp3)
32898 delete arg3;
32899 }
32900 {
32901 if (temp5)
32902 delete arg5;
32903 }
32904 return resultobj;
32905 fail:
32906 {
32907 if (temp3)
32908 delete arg3;
32909 }
32910 {
32911 if (temp5)
32912 delete arg5;
32913 }
32914 return NULL;
32915 }
32916
32917
32918 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
32919 PyObject *resultobj;
32920 wxMenu *arg1 = (wxMenu *) 0 ;
32921 int arg2 ;
32922 wxMenuItem *result;
32923 PyObject * obj0 = 0 ;
32924 PyObject * obj1 = 0 ;
32925 char *kwnames[] = {
32926 (char *) "self",(char *) "id", NULL
32927 };
32928
32929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
32930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32931 if (SWIG_arg_fail(1)) SWIG_fail;
32932 {
32933 arg2 = (int)(SWIG_As_int(obj1));
32934 if (SWIG_arg_fail(2)) SWIG_fail;
32935 }
32936 {
32937 PyThreadState* __tstate = wxPyBeginAllowThreads();
32938 result = (wxMenuItem *)(arg1)->Remove(arg2);
32939
32940 wxPyEndAllowThreads(__tstate);
32941 if (PyErr_Occurred()) SWIG_fail;
32942 }
32943 {
32944 resultobj = wxPyMake_wxObject(result, 0);
32945 }
32946 return resultobj;
32947 fail:
32948 return NULL;
32949 }
32950
32951
32952 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
32953 PyObject *resultobj;
32954 wxMenu *arg1 = (wxMenu *) 0 ;
32955 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32956 wxMenuItem *result;
32957 PyObject * obj0 = 0 ;
32958 PyObject * obj1 = 0 ;
32959 char *kwnames[] = {
32960 (char *) "self",(char *) "item", NULL
32961 };
32962
32963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
32964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32965 if (SWIG_arg_fail(1)) SWIG_fail;
32966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32967 if (SWIG_arg_fail(2)) SWIG_fail;
32968 {
32969 PyThreadState* __tstate = wxPyBeginAllowThreads();
32970 result = (wxMenuItem *)(arg1)->Remove(arg2);
32971
32972 wxPyEndAllowThreads(__tstate);
32973 if (PyErr_Occurred()) SWIG_fail;
32974 }
32975 {
32976 resultobj = wxPyMake_wxObject(result, 0);
32977 }
32978 return resultobj;
32979 fail:
32980 return NULL;
32981 }
32982
32983
32984 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
32985 PyObject *resultobj;
32986 wxMenu *arg1 = (wxMenu *) 0 ;
32987 int arg2 ;
32988 bool result;
32989 PyObject * obj0 = 0 ;
32990 PyObject * obj1 = 0 ;
32991 char *kwnames[] = {
32992 (char *) "self",(char *) "id", NULL
32993 };
32994
32995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
32996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32997 if (SWIG_arg_fail(1)) SWIG_fail;
32998 {
32999 arg2 = (int)(SWIG_As_int(obj1));
33000 if (SWIG_arg_fail(2)) SWIG_fail;
33001 }
33002 {
33003 PyThreadState* __tstate = wxPyBeginAllowThreads();
33004 result = (bool)(arg1)->Delete(arg2);
33005
33006 wxPyEndAllowThreads(__tstate);
33007 if (PyErr_Occurred()) SWIG_fail;
33008 }
33009 {
33010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33011 }
33012 return resultobj;
33013 fail:
33014 return NULL;
33015 }
33016
33017
33018 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33019 PyObject *resultobj;
33020 wxMenu *arg1 = (wxMenu *) 0 ;
33021 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33022 bool result;
33023 PyObject * obj0 = 0 ;
33024 PyObject * obj1 = 0 ;
33025 char *kwnames[] = {
33026 (char *) "self",(char *) "item", NULL
33027 };
33028
33029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33031 if (SWIG_arg_fail(1)) SWIG_fail;
33032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33033 if (SWIG_arg_fail(2)) SWIG_fail;
33034 {
33035 PyThreadState* __tstate = wxPyBeginAllowThreads();
33036 result = (bool)(arg1)->Delete(arg2);
33037
33038 wxPyEndAllowThreads(__tstate);
33039 if (PyErr_Occurred()) SWIG_fail;
33040 }
33041 {
33042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33043 }
33044 return resultobj;
33045 fail:
33046 return NULL;
33047 }
33048
33049
33050 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33051 PyObject *resultobj;
33052 wxMenu *arg1 = (wxMenu *) 0 ;
33053 PyObject * obj0 = 0 ;
33054 char *kwnames[] = {
33055 (char *) "self", NULL
33056 };
33057
33058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33060 if (SWIG_arg_fail(1)) SWIG_fail;
33061 {
33062 PyThreadState* __tstate = wxPyBeginAllowThreads();
33063 wxMenu_Destroy(arg1);
33064
33065 wxPyEndAllowThreads(__tstate);
33066 if (PyErr_Occurred()) SWIG_fail;
33067 }
33068 Py_INCREF(Py_None); resultobj = Py_None;
33069 return resultobj;
33070 fail:
33071 return NULL;
33072 }
33073
33074
33075 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33076 PyObject *resultobj;
33077 wxMenu *arg1 = (wxMenu *) 0 ;
33078 int arg2 ;
33079 bool result;
33080 PyObject * obj0 = 0 ;
33081 PyObject * obj1 = 0 ;
33082 char *kwnames[] = {
33083 (char *) "self",(char *) "id", NULL
33084 };
33085
33086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33088 if (SWIG_arg_fail(1)) SWIG_fail;
33089 {
33090 arg2 = (int)(SWIG_As_int(obj1));
33091 if (SWIG_arg_fail(2)) SWIG_fail;
33092 }
33093 {
33094 PyThreadState* __tstate = wxPyBeginAllowThreads();
33095 result = (bool)(arg1)->Destroy(arg2);
33096
33097 wxPyEndAllowThreads(__tstate);
33098 if (PyErr_Occurred()) SWIG_fail;
33099 }
33100 {
33101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33102 }
33103 return resultobj;
33104 fail:
33105 return NULL;
33106 }
33107
33108
33109 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33110 PyObject *resultobj;
33111 wxMenu *arg1 = (wxMenu *) 0 ;
33112 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33113 bool result;
33114 PyObject * obj0 = 0 ;
33115 PyObject * obj1 = 0 ;
33116 char *kwnames[] = {
33117 (char *) "self",(char *) "item", NULL
33118 };
33119
33120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33122 if (SWIG_arg_fail(1)) SWIG_fail;
33123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33124 if (SWIG_arg_fail(2)) SWIG_fail;
33125 {
33126 PyThreadState* __tstate = wxPyBeginAllowThreads();
33127 result = (bool)(arg1)->Destroy(arg2);
33128
33129 wxPyEndAllowThreads(__tstate);
33130 if (PyErr_Occurred()) SWIG_fail;
33131 }
33132 {
33133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33134 }
33135 return resultobj;
33136 fail:
33137 return NULL;
33138 }
33139
33140
33141 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33142 PyObject *resultobj;
33143 wxMenu *arg1 = (wxMenu *) 0 ;
33144 size_t result;
33145 PyObject * obj0 = 0 ;
33146 char *kwnames[] = {
33147 (char *) "self", NULL
33148 };
33149
33150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33152 if (SWIG_arg_fail(1)) SWIG_fail;
33153 {
33154 PyThreadState* __tstate = wxPyBeginAllowThreads();
33155 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33156
33157 wxPyEndAllowThreads(__tstate);
33158 if (PyErr_Occurred()) SWIG_fail;
33159 }
33160 {
33161 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33162 }
33163 return resultobj;
33164 fail:
33165 return NULL;
33166 }
33167
33168
33169 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33170 PyObject *resultobj;
33171 wxMenu *arg1 = (wxMenu *) 0 ;
33172 PyObject *result;
33173 PyObject * obj0 = 0 ;
33174 char *kwnames[] = {
33175 (char *) "self", NULL
33176 };
33177
33178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33180 if (SWIG_arg_fail(1)) SWIG_fail;
33181 {
33182 PyThreadState* __tstate = wxPyBeginAllowThreads();
33183 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33184
33185 wxPyEndAllowThreads(__tstate);
33186 if (PyErr_Occurred()) SWIG_fail;
33187 }
33188 resultobj = result;
33189 return resultobj;
33190 fail:
33191 return NULL;
33192 }
33193
33194
33195 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33196 PyObject *resultobj;
33197 wxMenu *arg1 = (wxMenu *) 0 ;
33198 wxString *arg2 = 0 ;
33199 int result;
33200 bool temp2 = false ;
33201 PyObject * obj0 = 0 ;
33202 PyObject * obj1 = 0 ;
33203 char *kwnames[] = {
33204 (char *) "self",(char *) "item", NULL
33205 };
33206
33207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33209 if (SWIG_arg_fail(1)) SWIG_fail;
33210 {
33211 arg2 = wxString_in_helper(obj1);
33212 if (arg2 == NULL) SWIG_fail;
33213 temp2 = true;
33214 }
33215 {
33216 PyThreadState* __tstate = wxPyBeginAllowThreads();
33217 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33218
33219 wxPyEndAllowThreads(__tstate);
33220 if (PyErr_Occurred()) SWIG_fail;
33221 }
33222 {
33223 resultobj = SWIG_From_int((int)(result));
33224 }
33225 {
33226 if (temp2)
33227 delete arg2;
33228 }
33229 return resultobj;
33230 fail:
33231 {
33232 if (temp2)
33233 delete arg2;
33234 }
33235 return NULL;
33236 }
33237
33238
33239 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33240 PyObject *resultobj;
33241 wxMenu *arg1 = (wxMenu *) 0 ;
33242 int arg2 ;
33243 wxMenuItem *result;
33244 PyObject * obj0 = 0 ;
33245 PyObject * obj1 = 0 ;
33246 char *kwnames[] = {
33247 (char *) "self",(char *) "id", NULL
33248 };
33249
33250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33252 if (SWIG_arg_fail(1)) SWIG_fail;
33253 {
33254 arg2 = (int)(SWIG_As_int(obj1));
33255 if (SWIG_arg_fail(2)) SWIG_fail;
33256 }
33257 {
33258 PyThreadState* __tstate = wxPyBeginAllowThreads();
33259 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33260
33261 wxPyEndAllowThreads(__tstate);
33262 if (PyErr_Occurred()) SWIG_fail;
33263 }
33264 {
33265 resultobj = wxPyMake_wxObject(result, 0);
33266 }
33267 return resultobj;
33268 fail:
33269 return NULL;
33270 }
33271
33272
33273 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33274 PyObject *resultobj;
33275 wxMenu *arg1 = (wxMenu *) 0 ;
33276 size_t arg2 ;
33277 wxMenuItem *result;
33278 PyObject * obj0 = 0 ;
33279 PyObject * obj1 = 0 ;
33280 char *kwnames[] = {
33281 (char *) "self",(char *) "position", NULL
33282 };
33283
33284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33286 if (SWIG_arg_fail(1)) SWIG_fail;
33287 {
33288 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33289 if (SWIG_arg_fail(2)) SWIG_fail;
33290 }
33291 {
33292 PyThreadState* __tstate = wxPyBeginAllowThreads();
33293 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33294
33295 wxPyEndAllowThreads(__tstate);
33296 if (PyErr_Occurred()) SWIG_fail;
33297 }
33298 {
33299 resultobj = wxPyMake_wxObject(result, 0);
33300 }
33301 return resultobj;
33302 fail:
33303 return NULL;
33304 }
33305
33306
33307 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33308 PyObject *resultobj;
33309 wxMenu *arg1 = (wxMenu *) 0 ;
33310 int arg2 ;
33311 bool arg3 ;
33312 PyObject * obj0 = 0 ;
33313 PyObject * obj1 = 0 ;
33314 PyObject * obj2 = 0 ;
33315 char *kwnames[] = {
33316 (char *) "self",(char *) "id",(char *) "enable", NULL
33317 };
33318
33319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33321 if (SWIG_arg_fail(1)) SWIG_fail;
33322 {
33323 arg2 = (int)(SWIG_As_int(obj1));
33324 if (SWIG_arg_fail(2)) SWIG_fail;
33325 }
33326 {
33327 arg3 = (bool)(SWIG_As_bool(obj2));
33328 if (SWIG_arg_fail(3)) SWIG_fail;
33329 }
33330 {
33331 PyThreadState* __tstate = wxPyBeginAllowThreads();
33332 (arg1)->Enable(arg2,arg3);
33333
33334 wxPyEndAllowThreads(__tstate);
33335 if (PyErr_Occurred()) SWIG_fail;
33336 }
33337 Py_INCREF(Py_None); resultobj = Py_None;
33338 return resultobj;
33339 fail:
33340 return NULL;
33341 }
33342
33343
33344 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33345 PyObject *resultobj;
33346 wxMenu *arg1 = (wxMenu *) 0 ;
33347 int arg2 ;
33348 bool result;
33349 PyObject * obj0 = 0 ;
33350 PyObject * obj1 = 0 ;
33351 char *kwnames[] = {
33352 (char *) "self",(char *) "id", NULL
33353 };
33354
33355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33357 if (SWIG_arg_fail(1)) SWIG_fail;
33358 {
33359 arg2 = (int)(SWIG_As_int(obj1));
33360 if (SWIG_arg_fail(2)) SWIG_fail;
33361 }
33362 {
33363 PyThreadState* __tstate = wxPyBeginAllowThreads();
33364 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33365
33366 wxPyEndAllowThreads(__tstate);
33367 if (PyErr_Occurred()) SWIG_fail;
33368 }
33369 {
33370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33371 }
33372 return resultobj;
33373 fail:
33374 return NULL;
33375 }
33376
33377
33378 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33379 PyObject *resultobj;
33380 wxMenu *arg1 = (wxMenu *) 0 ;
33381 int arg2 ;
33382 bool arg3 ;
33383 PyObject * obj0 = 0 ;
33384 PyObject * obj1 = 0 ;
33385 PyObject * obj2 = 0 ;
33386 char *kwnames[] = {
33387 (char *) "self",(char *) "id",(char *) "check", NULL
33388 };
33389
33390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33392 if (SWIG_arg_fail(1)) SWIG_fail;
33393 {
33394 arg2 = (int)(SWIG_As_int(obj1));
33395 if (SWIG_arg_fail(2)) SWIG_fail;
33396 }
33397 {
33398 arg3 = (bool)(SWIG_As_bool(obj2));
33399 if (SWIG_arg_fail(3)) SWIG_fail;
33400 }
33401 {
33402 PyThreadState* __tstate = wxPyBeginAllowThreads();
33403 (arg1)->Check(arg2,arg3);
33404
33405 wxPyEndAllowThreads(__tstate);
33406 if (PyErr_Occurred()) SWIG_fail;
33407 }
33408 Py_INCREF(Py_None); resultobj = Py_None;
33409 return resultobj;
33410 fail:
33411 return NULL;
33412 }
33413
33414
33415 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33416 PyObject *resultobj;
33417 wxMenu *arg1 = (wxMenu *) 0 ;
33418 int arg2 ;
33419 bool result;
33420 PyObject * obj0 = 0 ;
33421 PyObject * obj1 = 0 ;
33422 char *kwnames[] = {
33423 (char *) "self",(char *) "id", NULL
33424 };
33425
33426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33428 if (SWIG_arg_fail(1)) SWIG_fail;
33429 {
33430 arg2 = (int)(SWIG_As_int(obj1));
33431 if (SWIG_arg_fail(2)) SWIG_fail;
33432 }
33433 {
33434 PyThreadState* __tstate = wxPyBeginAllowThreads();
33435 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33436
33437 wxPyEndAllowThreads(__tstate);
33438 if (PyErr_Occurred()) SWIG_fail;
33439 }
33440 {
33441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33442 }
33443 return resultobj;
33444 fail:
33445 return NULL;
33446 }
33447
33448
33449 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33450 PyObject *resultobj;
33451 wxMenu *arg1 = (wxMenu *) 0 ;
33452 int arg2 ;
33453 wxString *arg3 = 0 ;
33454 bool temp3 = false ;
33455 PyObject * obj0 = 0 ;
33456 PyObject * obj1 = 0 ;
33457 PyObject * obj2 = 0 ;
33458 char *kwnames[] = {
33459 (char *) "self",(char *) "id",(char *) "label", NULL
33460 };
33461
33462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33464 if (SWIG_arg_fail(1)) SWIG_fail;
33465 {
33466 arg2 = (int)(SWIG_As_int(obj1));
33467 if (SWIG_arg_fail(2)) SWIG_fail;
33468 }
33469 {
33470 arg3 = wxString_in_helper(obj2);
33471 if (arg3 == NULL) SWIG_fail;
33472 temp3 = true;
33473 }
33474 {
33475 PyThreadState* __tstate = wxPyBeginAllowThreads();
33476 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33477
33478 wxPyEndAllowThreads(__tstate);
33479 if (PyErr_Occurred()) SWIG_fail;
33480 }
33481 Py_INCREF(Py_None); resultobj = Py_None;
33482 {
33483 if (temp3)
33484 delete arg3;
33485 }
33486 return resultobj;
33487 fail:
33488 {
33489 if (temp3)
33490 delete arg3;
33491 }
33492 return NULL;
33493 }
33494
33495
33496 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33497 PyObject *resultobj;
33498 wxMenu *arg1 = (wxMenu *) 0 ;
33499 int arg2 ;
33500 wxString result;
33501 PyObject * obj0 = 0 ;
33502 PyObject * obj1 = 0 ;
33503 char *kwnames[] = {
33504 (char *) "self",(char *) "id", NULL
33505 };
33506
33507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33509 if (SWIG_arg_fail(1)) SWIG_fail;
33510 {
33511 arg2 = (int)(SWIG_As_int(obj1));
33512 if (SWIG_arg_fail(2)) SWIG_fail;
33513 }
33514 {
33515 PyThreadState* __tstate = wxPyBeginAllowThreads();
33516 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33517
33518 wxPyEndAllowThreads(__tstate);
33519 if (PyErr_Occurred()) SWIG_fail;
33520 }
33521 {
33522 #if wxUSE_UNICODE
33523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33524 #else
33525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33526 #endif
33527 }
33528 return resultobj;
33529 fail:
33530 return NULL;
33531 }
33532
33533
33534 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33535 PyObject *resultobj;
33536 wxMenu *arg1 = (wxMenu *) 0 ;
33537 int arg2 ;
33538 wxString *arg3 = 0 ;
33539 bool temp3 = false ;
33540 PyObject * obj0 = 0 ;
33541 PyObject * obj1 = 0 ;
33542 PyObject * obj2 = 0 ;
33543 char *kwnames[] = {
33544 (char *) "self",(char *) "id",(char *) "helpString", NULL
33545 };
33546
33547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33549 if (SWIG_arg_fail(1)) SWIG_fail;
33550 {
33551 arg2 = (int)(SWIG_As_int(obj1));
33552 if (SWIG_arg_fail(2)) SWIG_fail;
33553 }
33554 {
33555 arg3 = wxString_in_helper(obj2);
33556 if (arg3 == NULL) SWIG_fail;
33557 temp3 = true;
33558 }
33559 {
33560 PyThreadState* __tstate = wxPyBeginAllowThreads();
33561 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33562
33563 wxPyEndAllowThreads(__tstate);
33564 if (PyErr_Occurred()) SWIG_fail;
33565 }
33566 Py_INCREF(Py_None); resultobj = Py_None;
33567 {
33568 if (temp3)
33569 delete arg3;
33570 }
33571 return resultobj;
33572 fail:
33573 {
33574 if (temp3)
33575 delete arg3;
33576 }
33577 return NULL;
33578 }
33579
33580
33581 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33582 PyObject *resultobj;
33583 wxMenu *arg1 = (wxMenu *) 0 ;
33584 int arg2 ;
33585 wxString result;
33586 PyObject * obj0 = 0 ;
33587 PyObject * obj1 = 0 ;
33588 char *kwnames[] = {
33589 (char *) "self",(char *) "id", NULL
33590 };
33591
33592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33594 if (SWIG_arg_fail(1)) SWIG_fail;
33595 {
33596 arg2 = (int)(SWIG_As_int(obj1));
33597 if (SWIG_arg_fail(2)) SWIG_fail;
33598 }
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33602
33603 wxPyEndAllowThreads(__tstate);
33604 if (PyErr_Occurred()) SWIG_fail;
33605 }
33606 {
33607 #if wxUSE_UNICODE
33608 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33609 #else
33610 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33611 #endif
33612 }
33613 return resultobj;
33614 fail:
33615 return NULL;
33616 }
33617
33618
33619 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33620 PyObject *resultobj;
33621 wxMenu *arg1 = (wxMenu *) 0 ;
33622 wxString *arg2 = 0 ;
33623 bool temp2 = false ;
33624 PyObject * obj0 = 0 ;
33625 PyObject * obj1 = 0 ;
33626 char *kwnames[] = {
33627 (char *) "self",(char *) "title", NULL
33628 };
33629
33630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33632 if (SWIG_arg_fail(1)) SWIG_fail;
33633 {
33634 arg2 = wxString_in_helper(obj1);
33635 if (arg2 == NULL) SWIG_fail;
33636 temp2 = true;
33637 }
33638 {
33639 PyThreadState* __tstate = wxPyBeginAllowThreads();
33640 (arg1)->SetTitle((wxString const &)*arg2);
33641
33642 wxPyEndAllowThreads(__tstate);
33643 if (PyErr_Occurred()) SWIG_fail;
33644 }
33645 Py_INCREF(Py_None); resultobj = Py_None;
33646 {
33647 if (temp2)
33648 delete arg2;
33649 }
33650 return resultobj;
33651 fail:
33652 {
33653 if (temp2)
33654 delete arg2;
33655 }
33656 return NULL;
33657 }
33658
33659
33660 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33661 PyObject *resultobj;
33662 wxMenu *arg1 = (wxMenu *) 0 ;
33663 wxString result;
33664 PyObject * obj0 = 0 ;
33665 char *kwnames[] = {
33666 (char *) "self", NULL
33667 };
33668
33669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33671 if (SWIG_arg_fail(1)) SWIG_fail;
33672 {
33673 PyThreadState* __tstate = wxPyBeginAllowThreads();
33674 result = ((wxMenu const *)arg1)->GetTitle();
33675
33676 wxPyEndAllowThreads(__tstate);
33677 if (PyErr_Occurred()) SWIG_fail;
33678 }
33679 {
33680 #if wxUSE_UNICODE
33681 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33682 #else
33683 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33684 #endif
33685 }
33686 return resultobj;
33687 fail:
33688 return NULL;
33689 }
33690
33691
33692 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33693 PyObject *resultobj;
33694 wxMenu *arg1 = (wxMenu *) 0 ;
33695 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33696 PyObject * obj0 = 0 ;
33697 PyObject * obj1 = 0 ;
33698 char *kwnames[] = {
33699 (char *) "self",(char *) "handler", NULL
33700 };
33701
33702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33704 if (SWIG_arg_fail(1)) SWIG_fail;
33705 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33706 if (SWIG_arg_fail(2)) SWIG_fail;
33707 {
33708 PyThreadState* __tstate = wxPyBeginAllowThreads();
33709 (arg1)->SetEventHandler(arg2);
33710
33711 wxPyEndAllowThreads(__tstate);
33712 if (PyErr_Occurred()) SWIG_fail;
33713 }
33714 Py_INCREF(Py_None); resultobj = Py_None;
33715 return resultobj;
33716 fail:
33717 return NULL;
33718 }
33719
33720
33721 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33722 PyObject *resultobj;
33723 wxMenu *arg1 = (wxMenu *) 0 ;
33724 wxEvtHandler *result;
33725 PyObject * obj0 = 0 ;
33726 char *kwnames[] = {
33727 (char *) "self", NULL
33728 };
33729
33730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
33731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33732 if (SWIG_arg_fail(1)) SWIG_fail;
33733 {
33734 PyThreadState* __tstate = wxPyBeginAllowThreads();
33735 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
33736
33737 wxPyEndAllowThreads(__tstate);
33738 if (PyErr_Occurred()) SWIG_fail;
33739 }
33740 {
33741 resultobj = wxPyMake_wxObject(result, 0);
33742 }
33743 return resultobj;
33744 fail:
33745 return NULL;
33746 }
33747
33748
33749 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33750 PyObject *resultobj;
33751 wxMenu *arg1 = (wxMenu *) 0 ;
33752 wxWindow *arg2 = (wxWindow *) 0 ;
33753 PyObject * obj0 = 0 ;
33754 PyObject * obj1 = 0 ;
33755 char *kwnames[] = {
33756 (char *) "self",(char *) "win", NULL
33757 };
33758
33759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
33760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33761 if (SWIG_arg_fail(1)) SWIG_fail;
33762 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33763 if (SWIG_arg_fail(2)) SWIG_fail;
33764 {
33765 PyThreadState* __tstate = wxPyBeginAllowThreads();
33766 (arg1)->SetInvokingWindow(arg2);
33767
33768 wxPyEndAllowThreads(__tstate);
33769 if (PyErr_Occurred()) SWIG_fail;
33770 }
33771 Py_INCREF(Py_None); resultobj = Py_None;
33772 return resultobj;
33773 fail:
33774 return NULL;
33775 }
33776
33777
33778 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33779 PyObject *resultobj;
33780 wxMenu *arg1 = (wxMenu *) 0 ;
33781 wxWindow *result;
33782 PyObject * obj0 = 0 ;
33783 char *kwnames[] = {
33784 (char *) "self", NULL
33785 };
33786
33787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
33788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33789 if (SWIG_arg_fail(1)) SWIG_fail;
33790 {
33791 PyThreadState* __tstate = wxPyBeginAllowThreads();
33792 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
33793
33794 wxPyEndAllowThreads(__tstate);
33795 if (PyErr_Occurred()) SWIG_fail;
33796 }
33797 {
33798 resultobj = wxPyMake_wxObject(result, 0);
33799 }
33800 return resultobj;
33801 fail:
33802 return NULL;
33803 }
33804
33805
33806 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
33807 PyObject *resultobj;
33808 wxMenu *arg1 = (wxMenu *) 0 ;
33809 long result;
33810 PyObject * obj0 = 0 ;
33811 char *kwnames[] = {
33812 (char *) "self", NULL
33813 };
33814
33815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
33816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33817 if (SWIG_arg_fail(1)) SWIG_fail;
33818 {
33819 PyThreadState* __tstate = wxPyBeginAllowThreads();
33820 result = (long)((wxMenu const *)arg1)->GetStyle();
33821
33822 wxPyEndAllowThreads(__tstate);
33823 if (PyErr_Occurred()) SWIG_fail;
33824 }
33825 {
33826 resultobj = SWIG_From_long((long)(result));
33827 }
33828 return resultobj;
33829 fail:
33830 return NULL;
33831 }
33832
33833
33834 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
33835 PyObject *resultobj;
33836 wxMenu *arg1 = (wxMenu *) 0 ;
33837 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
33838 PyObject * obj0 = 0 ;
33839 PyObject * obj1 = 0 ;
33840 char *kwnames[] = {
33841 (char *) "self",(char *) "source", NULL
33842 };
33843
33844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
33845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33846 if (SWIG_arg_fail(1)) SWIG_fail;
33847 if (obj1) {
33848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33849 if (SWIG_arg_fail(2)) SWIG_fail;
33850 }
33851 {
33852 PyThreadState* __tstate = wxPyBeginAllowThreads();
33853 (arg1)->UpdateUI(arg2);
33854
33855 wxPyEndAllowThreads(__tstate);
33856 if (PyErr_Occurred()) SWIG_fail;
33857 }
33858 Py_INCREF(Py_None); resultobj = Py_None;
33859 return resultobj;
33860 fail:
33861 return NULL;
33862 }
33863
33864
33865 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
33866 PyObject *resultobj;
33867 wxMenu *arg1 = (wxMenu *) 0 ;
33868 wxMenuBar *result;
33869 PyObject * obj0 = 0 ;
33870 char *kwnames[] = {
33871 (char *) "self", NULL
33872 };
33873
33874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
33879 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
33880
33881 wxPyEndAllowThreads(__tstate);
33882 if (PyErr_Occurred()) SWIG_fail;
33883 }
33884 {
33885 resultobj = wxPyMake_wxObject(result, 0);
33886 }
33887 return resultobj;
33888 fail:
33889 return NULL;
33890 }
33891
33892
33893 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
33894 PyObject *resultobj;
33895 wxMenu *arg1 = (wxMenu *) 0 ;
33896 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
33897 PyObject * obj0 = 0 ;
33898 PyObject * obj1 = 0 ;
33899 char *kwnames[] = {
33900 (char *) "self",(char *) "menubar", NULL
33901 };
33902
33903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
33904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33905 if (SWIG_arg_fail(1)) SWIG_fail;
33906 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
33907 if (SWIG_arg_fail(2)) SWIG_fail;
33908 {
33909 PyThreadState* __tstate = wxPyBeginAllowThreads();
33910 (arg1)->Attach(arg2);
33911
33912 wxPyEndAllowThreads(__tstate);
33913 if (PyErr_Occurred()) SWIG_fail;
33914 }
33915 Py_INCREF(Py_None); resultobj = Py_None;
33916 return resultobj;
33917 fail:
33918 return NULL;
33919 }
33920
33921
33922 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
33923 PyObject *resultobj;
33924 wxMenu *arg1 = (wxMenu *) 0 ;
33925 PyObject * obj0 = 0 ;
33926 char *kwnames[] = {
33927 (char *) "self", NULL
33928 };
33929
33930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
33931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33932 if (SWIG_arg_fail(1)) SWIG_fail;
33933 {
33934 PyThreadState* __tstate = wxPyBeginAllowThreads();
33935 (arg1)->Detach();
33936
33937 wxPyEndAllowThreads(__tstate);
33938 if (PyErr_Occurred()) SWIG_fail;
33939 }
33940 Py_INCREF(Py_None); resultobj = Py_None;
33941 return resultobj;
33942 fail:
33943 return NULL;
33944 }
33945
33946
33947 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
33948 PyObject *resultobj;
33949 wxMenu *arg1 = (wxMenu *) 0 ;
33950 bool result;
33951 PyObject * obj0 = 0 ;
33952 char *kwnames[] = {
33953 (char *) "self", NULL
33954 };
33955
33956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
33957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33958 if (SWIG_arg_fail(1)) SWIG_fail;
33959 {
33960 PyThreadState* __tstate = wxPyBeginAllowThreads();
33961 result = (bool)((wxMenu const *)arg1)->IsAttached();
33962
33963 wxPyEndAllowThreads(__tstate);
33964 if (PyErr_Occurred()) SWIG_fail;
33965 }
33966 {
33967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33968 }
33969 return resultobj;
33970 fail:
33971 return NULL;
33972 }
33973
33974
33975 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
33976 PyObject *resultobj;
33977 wxMenu *arg1 = (wxMenu *) 0 ;
33978 wxMenu *arg2 = (wxMenu *) 0 ;
33979 PyObject * obj0 = 0 ;
33980 PyObject * obj1 = 0 ;
33981 char *kwnames[] = {
33982 (char *) "self",(char *) "parent", NULL
33983 };
33984
33985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
33986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33987 if (SWIG_arg_fail(1)) SWIG_fail;
33988 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33989 if (SWIG_arg_fail(2)) SWIG_fail;
33990 {
33991 PyThreadState* __tstate = wxPyBeginAllowThreads();
33992 (arg1)->SetParent(arg2);
33993
33994 wxPyEndAllowThreads(__tstate);
33995 if (PyErr_Occurred()) SWIG_fail;
33996 }
33997 Py_INCREF(Py_None); resultobj = Py_None;
33998 return resultobj;
33999 fail:
34000 return NULL;
34001 }
34002
34003
34004 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34005 PyObject *resultobj;
34006 wxMenu *arg1 = (wxMenu *) 0 ;
34007 wxMenu *result;
34008 PyObject * obj0 = 0 ;
34009 char *kwnames[] = {
34010 (char *) "self", NULL
34011 };
34012
34013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34015 if (SWIG_arg_fail(1)) SWIG_fail;
34016 {
34017 PyThreadState* __tstate = wxPyBeginAllowThreads();
34018 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34019
34020 wxPyEndAllowThreads(__tstate);
34021 if (PyErr_Occurred()) SWIG_fail;
34022 }
34023 {
34024 resultobj = wxPyMake_wxObject(result, 0);
34025 }
34026 return resultobj;
34027 fail:
34028 return NULL;
34029 }
34030
34031
34032 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34033 PyObject *obj;
34034 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34035 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34036 Py_INCREF(obj);
34037 return Py_BuildValue((char *)"");
34038 }
34039 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34040 PyObject *resultobj;
34041 long arg1 = (long) 0 ;
34042 wxMenuBar *result;
34043 PyObject * obj0 = 0 ;
34044 char *kwnames[] = {
34045 (char *) "style", NULL
34046 };
34047
34048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34049 if (obj0) {
34050 {
34051 arg1 = (long)(SWIG_As_long(obj0));
34052 if (SWIG_arg_fail(1)) SWIG_fail;
34053 }
34054 }
34055 {
34056 if (!wxPyCheckForApp()) SWIG_fail;
34057 PyThreadState* __tstate = wxPyBeginAllowThreads();
34058 result = (wxMenuBar *)new wxMenuBar(arg1);
34059
34060 wxPyEndAllowThreads(__tstate);
34061 if (PyErr_Occurred()) SWIG_fail;
34062 }
34063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34064 return resultobj;
34065 fail:
34066 return NULL;
34067 }
34068
34069
34070 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34071 PyObject *resultobj;
34072 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34073 wxMenu *arg2 = (wxMenu *) 0 ;
34074 wxString *arg3 = 0 ;
34075 bool result;
34076 bool temp3 = false ;
34077 PyObject * obj0 = 0 ;
34078 PyObject * obj1 = 0 ;
34079 PyObject * obj2 = 0 ;
34080 char *kwnames[] = {
34081 (char *) "self",(char *) "menu",(char *) "title", NULL
34082 };
34083
34084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34086 if (SWIG_arg_fail(1)) SWIG_fail;
34087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34088 if (SWIG_arg_fail(2)) SWIG_fail;
34089 {
34090 arg3 = wxString_in_helper(obj2);
34091 if (arg3 == NULL) SWIG_fail;
34092 temp3 = true;
34093 }
34094 {
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34097
34098 wxPyEndAllowThreads(__tstate);
34099 if (PyErr_Occurred()) SWIG_fail;
34100 }
34101 {
34102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34103 }
34104 {
34105 if (temp3)
34106 delete arg3;
34107 }
34108 return resultobj;
34109 fail:
34110 {
34111 if (temp3)
34112 delete arg3;
34113 }
34114 return NULL;
34115 }
34116
34117
34118 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34119 PyObject *resultobj;
34120 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34121 size_t arg2 ;
34122 wxMenu *arg3 = (wxMenu *) 0 ;
34123 wxString *arg4 = 0 ;
34124 bool result;
34125 bool temp4 = false ;
34126 PyObject * obj0 = 0 ;
34127 PyObject * obj1 = 0 ;
34128 PyObject * obj2 = 0 ;
34129 PyObject * obj3 = 0 ;
34130 char *kwnames[] = {
34131 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34132 };
34133
34134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34136 if (SWIG_arg_fail(1)) SWIG_fail;
34137 {
34138 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34139 if (SWIG_arg_fail(2)) SWIG_fail;
34140 }
34141 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34142 if (SWIG_arg_fail(3)) SWIG_fail;
34143 {
34144 arg4 = wxString_in_helper(obj3);
34145 if (arg4 == NULL) SWIG_fail;
34146 temp4 = true;
34147 }
34148 {
34149 PyThreadState* __tstate = wxPyBeginAllowThreads();
34150 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34151
34152 wxPyEndAllowThreads(__tstate);
34153 if (PyErr_Occurred()) SWIG_fail;
34154 }
34155 {
34156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34157 }
34158 {
34159 if (temp4)
34160 delete arg4;
34161 }
34162 return resultobj;
34163 fail:
34164 {
34165 if (temp4)
34166 delete arg4;
34167 }
34168 return NULL;
34169 }
34170
34171
34172 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34173 PyObject *resultobj;
34174 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34175 size_t result;
34176 PyObject * obj0 = 0 ;
34177 char *kwnames[] = {
34178 (char *) "self", NULL
34179 };
34180
34181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34183 if (SWIG_arg_fail(1)) SWIG_fail;
34184 {
34185 PyThreadState* __tstate = wxPyBeginAllowThreads();
34186 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34187
34188 wxPyEndAllowThreads(__tstate);
34189 if (PyErr_Occurred()) SWIG_fail;
34190 }
34191 {
34192 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34193 }
34194 return resultobj;
34195 fail:
34196 return NULL;
34197 }
34198
34199
34200 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34201 PyObject *resultobj;
34202 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34203 size_t arg2 ;
34204 wxMenu *result;
34205 PyObject * obj0 = 0 ;
34206 PyObject * obj1 = 0 ;
34207 char *kwnames[] = {
34208 (char *) "self",(char *) "pos", NULL
34209 };
34210
34211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34213 if (SWIG_arg_fail(1)) SWIG_fail;
34214 {
34215 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34216 if (SWIG_arg_fail(2)) SWIG_fail;
34217 }
34218 {
34219 PyThreadState* __tstate = wxPyBeginAllowThreads();
34220 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34221
34222 wxPyEndAllowThreads(__tstate);
34223 if (PyErr_Occurred()) SWIG_fail;
34224 }
34225 {
34226 resultobj = wxPyMake_wxObject(result, 0);
34227 }
34228 return resultobj;
34229 fail:
34230 return NULL;
34231 }
34232
34233
34234 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34235 PyObject *resultobj;
34236 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34237 size_t arg2 ;
34238 wxMenu *arg3 = (wxMenu *) 0 ;
34239 wxString *arg4 = 0 ;
34240 wxMenu *result;
34241 bool temp4 = false ;
34242 PyObject * obj0 = 0 ;
34243 PyObject * obj1 = 0 ;
34244 PyObject * obj2 = 0 ;
34245 PyObject * obj3 = 0 ;
34246 char *kwnames[] = {
34247 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34248 };
34249
34250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34252 if (SWIG_arg_fail(1)) SWIG_fail;
34253 {
34254 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34255 if (SWIG_arg_fail(2)) SWIG_fail;
34256 }
34257 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34258 if (SWIG_arg_fail(3)) SWIG_fail;
34259 {
34260 arg4 = wxString_in_helper(obj3);
34261 if (arg4 == NULL) SWIG_fail;
34262 temp4 = true;
34263 }
34264 {
34265 PyThreadState* __tstate = wxPyBeginAllowThreads();
34266 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34267
34268 wxPyEndAllowThreads(__tstate);
34269 if (PyErr_Occurred()) SWIG_fail;
34270 }
34271 {
34272 resultobj = wxPyMake_wxObject(result, 0);
34273 }
34274 {
34275 if (temp4)
34276 delete arg4;
34277 }
34278 return resultobj;
34279 fail:
34280 {
34281 if (temp4)
34282 delete arg4;
34283 }
34284 return NULL;
34285 }
34286
34287
34288 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34289 PyObject *resultobj;
34290 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34291 size_t arg2 ;
34292 wxMenu *result;
34293 PyObject * obj0 = 0 ;
34294 PyObject * obj1 = 0 ;
34295 char *kwnames[] = {
34296 (char *) "self",(char *) "pos", NULL
34297 };
34298
34299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34301 if (SWIG_arg_fail(1)) SWIG_fail;
34302 {
34303 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34304 if (SWIG_arg_fail(2)) SWIG_fail;
34305 }
34306 {
34307 PyThreadState* __tstate = wxPyBeginAllowThreads();
34308 result = (wxMenu *)(arg1)->Remove(arg2);
34309
34310 wxPyEndAllowThreads(__tstate);
34311 if (PyErr_Occurred()) SWIG_fail;
34312 }
34313 {
34314 resultobj = wxPyMake_wxObject(result, 0);
34315 }
34316 return resultobj;
34317 fail:
34318 return NULL;
34319 }
34320
34321
34322 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34323 PyObject *resultobj;
34324 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34325 size_t arg2 ;
34326 bool arg3 ;
34327 PyObject * obj0 = 0 ;
34328 PyObject * obj1 = 0 ;
34329 PyObject * obj2 = 0 ;
34330 char *kwnames[] = {
34331 (char *) "self",(char *) "pos",(char *) "enable", NULL
34332 };
34333
34334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34336 if (SWIG_arg_fail(1)) SWIG_fail;
34337 {
34338 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34339 if (SWIG_arg_fail(2)) SWIG_fail;
34340 }
34341 {
34342 arg3 = (bool)(SWIG_As_bool(obj2));
34343 if (SWIG_arg_fail(3)) SWIG_fail;
34344 }
34345 {
34346 PyThreadState* __tstate = wxPyBeginAllowThreads();
34347 (arg1)->EnableTop(arg2,arg3);
34348
34349 wxPyEndAllowThreads(__tstate);
34350 if (PyErr_Occurred()) SWIG_fail;
34351 }
34352 Py_INCREF(Py_None); resultobj = Py_None;
34353 return resultobj;
34354 fail:
34355 return NULL;
34356 }
34357
34358
34359 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34360 PyObject *resultobj;
34361 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34362 size_t arg2 ;
34363 bool result;
34364 PyObject * obj0 = 0 ;
34365 PyObject * obj1 = 0 ;
34366 char *kwnames[] = {
34367 (char *) "self",(char *) "pos", NULL
34368 };
34369
34370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34372 if (SWIG_arg_fail(1)) SWIG_fail;
34373 {
34374 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34375 if (SWIG_arg_fail(2)) SWIG_fail;
34376 }
34377 {
34378 PyThreadState* __tstate = wxPyBeginAllowThreads();
34379 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34380
34381 wxPyEndAllowThreads(__tstate);
34382 if (PyErr_Occurred()) SWIG_fail;
34383 }
34384 {
34385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34386 }
34387 return resultobj;
34388 fail:
34389 return NULL;
34390 }
34391
34392
34393 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34394 PyObject *resultobj;
34395 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34396 size_t arg2 ;
34397 wxString *arg3 = 0 ;
34398 bool temp3 = false ;
34399 PyObject * obj0 = 0 ;
34400 PyObject * obj1 = 0 ;
34401 PyObject * obj2 = 0 ;
34402 char *kwnames[] = {
34403 (char *) "self",(char *) "pos",(char *) "label", NULL
34404 };
34405
34406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34408 if (SWIG_arg_fail(1)) SWIG_fail;
34409 {
34410 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34411 if (SWIG_arg_fail(2)) SWIG_fail;
34412 }
34413 {
34414 arg3 = wxString_in_helper(obj2);
34415 if (arg3 == NULL) SWIG_fail;
34416 temp3 = true;
34417 }
34418 {
34419 PyThreadState* __tstate = wxPyBeginAllowThreads();
34420 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34421
34422 wxPyEndAllowThreads(__tstate);
34423 if (PyErr_Occurred()) SWIG_fail;
34424 }
34425 Py_INCREF(Py_None); resultobj = Py_None;
34426 {
34427 if (temp3)
34428 delete arg3;
34429 }
34430 return resultobj;
34431 fail:
34432 {
34433 if (temp3)
34434 delete arg3;
34435 }
34436 return NULL;
34437 }
34438
34439
34440 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34441 PyObject *resultobj;
34442 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34443 size_t arg2 ;
34444 wxString result;
34445 PyObject * obj0 = 0 ;
34446 PyObject * obj1 = 0 ;
34447 char *kwnames[] = {
34448 (char *) "self",(char *) "pos", NULL
34449 };
34450
34451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34453 if (SWIG_arg_fail(1)) SWIG_fail;
34454 {
34455 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34456 if (SWIG_arg_fail(2)) SWIG_fail;
34457 }
34458 {
34459 PyThreadState* __tstate = wxPyBeginAllowThreads();
34460 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34461
34462 wxPyEndAllowThreads(__tstate);
34463 if (PyErr_Occurred()) SWIG_fail;
34464 }
34465 {
34466 #if wxUSE_UNICODE
34467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34468 #else
34469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34470 #endif
34471 }
34472 return resultobj;
34473 fail:
34474 return NULL;
34475 }
34476
34477
34478 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34479 PyObject *resultobj;
34480 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34481 wxString *arg2 = 0 ;
34482 wxString *arg3 = 0 ;
34483 int result;
34484 bool temp2 = false ;
34485 bool temp3 = false ;
34486 PyObject * obj0 = 0 ;
34487 PyObject * obj1 = 0 ;
34488 PyObject * obj2 = 0 ;
34489 char *kwnames[] = {
34490 (char *) "self",(char *) "menu",(char *) "item", NULL
34491 };
34492
34493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34495 if (SWIG_arg_fail(1)) SWIG_fail;
34496 {
34497 arg2 = wxString_in_helper(obj1);
34498 if (arg2 == NULL) SWIG_fail;
34499 temp2 = true;
34500 }
34501 {
34502 arg3 = wxString_in_helper(obj2);
34503 if (arg3 == NULL) SWIG_fail;
34504 temp3 = true;
34505 }
34506 {
34507 PyThreadState* __tstate = wxPyBeginAllowThreads();
34508 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34509
34510 wxPyEndAllowThreads(__tstate);
34511 if (PyErr_Occurred()) SWIG_fail;
34512 }
34513 {
34514 resultobj = SWIG_From_int((int)(result));
34515 }
34516 {
34517 if (temp2)
34518 delete arg2;
34519 }
34520 {
34521 if (temp3)
34522 delete arg3;
34523 }
34524 return resultobj;
34525 fail:
34526 {
34527 if (temp2)
34528 delete arg2;
34529 }
34530 {
34531 if (temp3)
34532 delete arg3;
34533 }
34534 return NULL;
34535 }
34536
34537
34538 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34539 PyObject *resultobj;
34540 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34541 int arg2 ;
34542 wxMenuItem *result;
34543 PyObject * obj0 = 0 ;
34544 PyObject * obj1 = 0 ;
34545 char *kwnames[] = {
34546 (char *) "self",(char *) "id", NULL
34547 };
34548
34549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34551 if (SWIG_arg_fail(1)) SWIG_fail;
34552 {
34553 arg2 = (int)(SWIG_As_int(obj1));
34554 if (SWIG_arg_fail(2)) SWIG_fail;
34555 }
34556 {
34557 PyThreadState* __tstate = wxPyBeginAllowThreads();
34558 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34559
34560 wxPyEndAllowThreads(__tstate);
34561 if (PyErr_Occurred()) SWIG_fail;
34562 }
34563 {
34564 resultobj = wxPyMake_wxObject(result, 0);
34565 }
34566 return resultobj;
34567 fail:
34568 return NULL;
34569 }
34570
34571
34572 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34573 PyObject *resultobj;
34574 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34575 wxString *arg2 = 0 ;
34576 int result;
34577 bool temp2 = false ;
34578 PyObject * obj0 = 0 ;
34579 PyObject * obj1 = 0 ;
34580 char *kwnames[] = {
34581 (char *) "self",(char *) "title", NULL
34582 };
34583
34584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34586 if (SWIG_arg_fail(1)) SWIG_fail;
34587 {
34588 arg2 = wxString_in_helper(obj1);
34589 if (arg2 == NULL) SWIG_fail;
34590 temp2 = true;
34591 }
34592 {
34593 PyThreadState* __tstate = wxPyBeginAllowThreads();
34594 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34595
34596 wxPyEndAllowThreads(__tstate);
34597 if (PyErr_Occurred()) SWIG_fail;
34598 }
34599 {
34600 resultobj = SWIG_From_int((int)(result));
34601 }
34602 {
34603 if (temp2)
34604 delete arg2;
34605 }
34606 return resultobj;
34607 fail:
34608 {
34609 if (temp2)
34610 delete arg2;
34611 }
34612 return NULL;
34613 }
34614
34615
34616 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34617 PyObject *resultobj;
34618 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34619 int arg2 ;
34620 bool arg3 ;
34621 PyObject * obj0 = 0 ;
34622 PyObject * obj1 = 0 ;
34623 PyObject * obj2 = 0 ;
34624 char *kwnames[] = {
34625 (char *) "self",(char *) "id",(char *) "enable", NULL
34626 };
34627
34628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34630 if (SWIG_arg_fail(1)) SWIG_fail;
34631 {
34632 arg2 = (int)(SWIG_As_int(obj1));
34633 if (SWIG_arg_fail(2)) SWIG_fail;
34634 }
34635 {
34636 arg3 = (bool)(SWIG_As_bool(obj2));
34637 if (SWIG_arg_fail(3)) SWIG_fail;
34638 }
34639 {
34640 PyThreadState* __tstate = wxPyBeginAllowThreads();
34641 (arg1)->Enable(arg2,arg3);
34642
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 Py_INCREF(Py_None); resultobj = Py_None;
34647 return resultobj;
34648 fail:
34649 return NULL;
34650 }
34651
34652
34653 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34654 PyObject *resultobj;
34655 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34656 int arg2 ;
34657 bool arg3 ;
34658 PyObject * obj0 = 0 ;
34659 PyObject * obj1 = 0 ;
34660 PyObject * obj2 = 0 ;
34661 char *kwnames[] = {
34662 (char *) "self",(char *) "id",(char *) "check", NULL
34663 };
34664
34665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34667 if (SWIG_arg_fail(1)) SWIG_fail;
34668 {
34669 arg2 = (int)(SWIG_As_int(obj1));
34670 if (SWIG_arg_fail(2)) SWIG_fail;
34671 }
34672 {
34673 arg3 = (bool)(SWIG_As_bool(obj2));
34674 if (SWIG_arg_fail(3)) SWIG_fail;
34675 }
34676 {
34677 PyThreadState* __tstate = wxPyBeginAllowThreads();
34678 (arg1)->Check(arg2,arg3);
34679
34680 wxPyEndAllowThreads(__tstate);
34681 if (PyErr_Occurred()) SWIG_fail;
34682 }
34683 Py_INCREF(Py_None); resultobj = Py_None;
34684 return resultobj;
34685 fail:
34686 return NULL;
34687 }
34688
34689
34690 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34691 PyObject *resultobj;
34692 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34693 int arg2 ;
34694 bool result;
34695 PyObject * obj0 = 0 ;
34696 PyObject * obj1 = 0 ;
34697 char *kwnames[] = {
34698 (char *) "self",(char *) "id", NULL
34699 };
34700
34701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34703 if (SWIG_arg_fail(1)) SWIG_fail;
34704 {
34705 arg2 = (int)(SWIG_As_int(obj1));
34706 if (SWIG_arg_fail(2)) SWIG_fail;
34707 }
34708 {
34709 PyThreadState* __tstate = wxPyBeginAllowThreads();
34710 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
34711
34712 wxPyEndAllowThreads(__tstate);
34713 if (PyErr_Occurred()) SWIG_fail;
34714 }
34715 {
34716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34717 }
34718 return resultobj;
34719 fail:
34720 return NULL;
34721 }
34722
34723
34724 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34725 PyObject *resultobj;
34726 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34727 int arg2 ;
34728 bool result;
34729 PyObject * obj0 = 0 ;
34730 PyObject * obj1 = 0 ;
34731 char *kwnames[] = {
34732 (char *) "self",(char *) "id", NULL
34733 };
34734
34735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34737 if (SWIG_arg_fail(1)) SWIG_fail;
34738 {
34739 arg2 = (int)(SWIG_As_int(obj1));
34740 if (SWIG_arg_fail(2)) SWIG_fail;
34741 }
34742 {
34743 PyThreadState* __tstate = wxPyBeginAllowThreads();
34744 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
34745
34746 wxPyEndAllowThreads(__tstate);
34747 if (PyErr_Occurred()) SWIG_fail;
34748 }
34749 {
34750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34751 }
34752 return resultobj;
34753 fail:
34754 return NULL;
34755 }
34756
34757
34758 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34759 PyObject *resultobj;
34760 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34761 int arg2 ;
34762 wxString *arg3 = 0 ;
34763 bool temp3 = false ;
34764 PyObject * obj0 = 0 ;
34765 PyObject * obj1 = 0 ;
34766 PyObject * obj2 = 0 ;
34767 char *kwnames[] = {
34768 (char *) "self",(char *) "id",(char *) "label", NULL
34769 };
34770
34771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34773 if (SWIG_arg_fail(1)) SWIG_fail;
34774 {
34775 arg2 = (int)(SWIG_As_int(obj1));
34776 if (SWIG_arg_fail(2)) SWIG_fail;
34777 }
34778 {
34779 arg3 = wxString_in_helper(obj2);
34780 if (arg3 == NULL) SWIG_fail;
34781 temp3 = true;
34782 }
34783 {
34784 PyThreadState* __tstate = wxPyBeginAllowThreads();
34785 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34786
34787 wxPyEndAllowThreads(__tstate);
34788 if (PyErr_Occurred()) SWIG_fail;
34789 }
34790 Py_INCREF(Py_None); resultobj = Py_None;
34791 {
34792 if (temp3)
34793 delete arg3;
34794 }
34795 return resultobj;
34796 fail:
34797 {
34798 if (temp3)
34799 delete arg3;
34800 }
34801 return NULL;
34802 }
34803
34804
34805 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34806 PyObject *resultobj;
34807 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34808 int arg2 ;
34809 wxString result;
34810 PyObject * obj0 = 0 ;
34811 PyObject * obj1 = 0 ;
34812 char *kwnames[] = {
34813 (char *) "self",(char *) "id", NULL
34814 };
34815
34816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34818 if (SWIG_arg_fail(1)) SWIG_fail;
34819 {
34820 arg2 = (int)(SWIG_As_int(obj1));
34821 if (SWIG_arg_fail(2)) SWIG_fail;
34822 }
34823 {
34824 PyThreadState* __tstate = wxPyBeginAllowThreads();
34825 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
34826
34827 wxPyEndAllowThreads(__tstate);
34828 if (PyErr_Occurred()) SWIG_fail;
34829 }
34830 {
34831 #if wxUSE_UNICODE
34832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34833 #else
34834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34835 #endif
34836 }
34837 return resultobj;
34838 fail:
34839 return NULL;
34840 }
34841
34842
34843 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34844 PyObject *resultobj;
34845 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34846 int arg2 ;
34847 wxString *arg3 = 0 ;
34848 bool temp3 = false ;
34849 PyObject * obj0 = 0 ;
34850 PyObject * obj1 = 0 ;
34851 PyObject * obj2 = 0 ;
34852 char *kwnames[] = {
34853 (char *) "self",(char *) "id",(char *) "helpString", NULL
34854 };
34855
34856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34858 if (SWIG_arg_fail(1)) SWIG_fail;
34859 {
34860 arg2 = (int)(SWIG_As_int(obj1));
34861 if (SWIG_arg_fail(2)) SWIG_fail;
34862 }
34863 {
34864 arg3 = wxString_in_helper(obj2);
34865 if (arg3 == NULL) SWIG_fail;
34866 temp3 = true;
34867 }
34868 {
34869 PyThreadState* __tstate = wxPyBeginAllowThreads();
34870 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34871
34872 wxPyEndAllowThreads(__tstate);
34873 if (PyErr_Occurred()) SWIG_fail;
34874 }
34875 Py_INCREF(Py_None); resultobj = Py_None;
34876 {
34877 if (temp3)
34878 delete arg3;
34879 }
34880 return resultobj;
34881 fail:
34882 {
34883 if (temp3)
34884 delete arg3;
34885 }
34886 return NULL;
34887 }
34888
34889
34890 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34891 PyObject *resultobj;
34892 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34893 int arg2 ;
34894 wxString result;
34895 PyObject * obj0 = 0 ;
34896 PyObject * obj1 = 0 ;
34897 char *kwnames[] = {
34898 (char *) "self",(char *) "id", NULL
34899 };
34900
34901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34903 if (SWIG_arg_fail(1)) SWIG_fail;
34904 {
34905 arg2 = (int)(SWIG_As_int(obj1));
34906 if (SWIG_arg_fail(2)) SWIG_fail;
34907 }
34908 {
34909 PyThreadState* __tstate = wxPyBeginAllowThreads();
34910 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
34911
34912 wxPyEndAllowThreads(__tstate);
34913 if (PyErr_Occurred()) SWIG_fail;
34914 }
34915 {
34916 #if wxUSE_UNICODE
34917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34918 #else
34919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34920 #endif
34921 }
34922 return resultobj;
34923 fail:
34924 return NULL;
34925 }
34926
34927
34928 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
34929 PyObject *resultobj;
34930 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34931 wxFrame *result;
34932 PyObject * obj0 = 0 ;
34933 char *kwnames[] = {
34934 (char *) "self", NULL
34935 };
34936
34937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
34938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34939 if (SWIG_arg_fail(1)) SWIG_fail;
34940 {
34941 PyThreadState* __tstate = wxPyBeginAllowThreads();
34942 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
34943
34944 wxPyEndAllowThreads(__tstate);
34945 if (PyErr_Occurred()) SWIG_fail;
34946 }
34947 {
34948 resultobj = wxPyMake_wxObject(result, 0);
34949 }
34950 return resultobj;
34951 fail:
34952 return NULL;
34953 }
34954
34955
34956 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34957 PyObject *resultobj;
34958 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34959 bool result;
34960 PyObject * obj0 = 0 ;
34961 char *kwnames[] = {
34962 (char *) "self", NULL
34963 };
34964
34965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
34966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34967 if (SWIG_arg_fail(1)) SWIG_fail;
34968 {
34969 PyThreadState* __tstate = wxPyBeginAllowThreads();
34970 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
34971
34972 wxPyEndAllowThreads(__tstate);
34973 if (PyErr_Occurred()) SWIG_fail;
34974 }
34975 {
34976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34977 }
34978 return resultobj;
34979 fail:
34980 return NULL;
34981 }
34982
34983
34984 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34985 PyObject *resultobj;
34986 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34987 wxFrame *arg2 = (wxFrame *) 0 ;
34988 PyObject * obj0 = 0 ;
34989 PyObject * obj1 = 0 ;
34990 char *kwnames[] = {
34991 (char *) "self",(char *) "frame", NULL
34992 };
34993
34994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
34998 if (SWIG_arg_fail(2)) SWIG_fail;
34999 {
35000 PyThreadState* __tstate = wxPyBeginAllowThreads();
35001 (arg1)->Attach(arg2);
35002
35003 wxPyEndAllowThreads(__tstate);
35004 if (PyErr_Occurred()) SWIG_fail;
35005 }
35006 Py_INCREF(Py_None); resultobj = Py_None;
35007 return resultobj;
35008 fail:
35009 return NULL;
35010 }
35011
35012
35013 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35014 PyObject *resultobj;
35015 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35016 PyObject * obj0 = 0 ;
35017 char *kwnames[] = {
35018 (char *) "self", NULL
35019 };
35020
35021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35023 if (SWIG_arg_fail(1)) SWIG_fail;
35024 {
35025 PyThreadState* __tstate = wxPyBeginAllowThreads();
35026 (arg1)->Detach();
35027
35028 wxPyEndAllowThreads(__tstate);
35029 if (PyErr_Occurred()) SWIG_fail;
35030 }
35031 Py_INCREF(Py_None); resultobj = Py_None;
35032 return resultobj;
35033 fail:
35034 return NULL;
35035 }
35036
35037
35038 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35039 PyObject *obj;
35040 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35041 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35042 Py_INCREF(obj);
35043 return Py_BuildValue((char *)"");
35044 }
35045 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35046 PyObject *resultobj;
35047 wxMenu *arg1 = (wxMenu *) NULL ;
35048 int arg2 = (int) wxID_ANY ;
35049 wxString const &arg3_defvalue = wxPyEmptyString ;
35050 wxString *arg3 = (wxString *) &arg3_defvalue ;
35051 wxString const &arg4_defvalue = wxPyEmptyString ;
35052 wxString *arg4 = (wxString *) &arg4_defvalue ;
35053 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35054 wxMenu *arg6 = (wxMenu *) NULL ;
35055 wxMenuItem *result;
35056 bool temp3 = false ;
35057 bool temp4 = false ;
35058 PyObject * obj0 = 0 ;
35059 PyObject * obj1 = 0 ;
35060 PyObject * obj2 = 0 ;
35061 PyObject * obj3 = 0 ;
35062 PyObject * obj4 = 0 ;
35063 PyObject * obj5 = 0 ;
35064 char *kwnames[] = {
35065 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35066 };
35067
35068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35069 if (obj0) {
35070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35071 if (SWIG_arg_fail(1)) SWIG_fail;
35072 }
35073 if (obj1) {
35074 {
35075 arg2 = (int)(SWIG_As_int(obj1));
35076 if (SWIG_arg_fail(2)) SWIG_fail;
35077 }
35078 }
35079 if (obj2) {
35080 {
35081 arg3 = wxString_in_helper(obj2);
35082 if (arg3 == NULL) SWIG_fail;
35083 temp3 = true;
35084 }
35085 }
35086 if (obj3) {
35087 {
35088 arg4 = wxString_in_helper(obj3);
35089 if (arg4 == NULL) SWIG_fail;
35090 temp4 = true;
35091 }
35092 }
35093 if (obj4) {
35094 {
35095 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35096 if (SWIG_arg_fail(5)) SWIG_fail;
35097 }
35098 }
35099 if (obj5) {
35100 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35101 if (SWIG_arg_fail(6)) SWIG_fail;
35102 }
35103 {
35104 PyThreadState* __tstate = wxPyBeginAllowThreads();
35105 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35106
35107 wxPyEndAllowThreads(__tstate);
35108 if (PyErr_Occurred()) SWIG_fail;
35109 }
35110 {
35111 resultobj = wxPyMake_wxObject(result, 1);
35112 }
35113 {
35114 if (temp3)
35115 delete arg3;
35116 }
35117 {
35118 if (temp4)
35119 delete arg4;
35120 }
35121 return resultobj;
35122 fail:
35123 {
35124 if (temp3)
35125 delete arg3;
35126 }
35127 {
35128 if (temp4)
35129 delete arg4;
35130 }
35131 return NULL;
35132 }
35133
35134
35135 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35136 PyObject *resultobj;
35137 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35138 wxMenu *result;
35139 PyObject * obj0 = 0 ;
35140 char *kwnames[] = {
35141 (char *) "self", NULL
35142 };
35143
35144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35146 if (SWIG_arg_fail(1)) SWIG_fail;
35147 {
35148 PyThreadState* __tstate = wxPyBeginAllowThreads();
35149 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35150
35151 wxPyEndAllowThreads(__tstate);
35152 if (PyErr_Occurred()) SWIG_fail;
35153 }
35154 {
35155 resultobj = wxPyMake_wxObject(result, 0);
35156 }
35157 return resultobj;
35158 fail:
35159 return NULL;
35160 }
35161
35162
35163 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35164 PyObject *resultobj;
35165 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35166 wxMenu *arg2 = (wxMenu *) 0 ;
35167 PyObject * obj0 = 0 ;
35168 PyObject * obj1 = 0 ;
35169 char *kwnames[] = {
35170 (char *) "self",(char *) "menu", NULL
35171 };
35172
35173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35175 if (SWIG_arg_fail(1)) SWIG_fail;
35176 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35177 if (SWIG_arg_fail(2)) SWIG_fail;
35178 {
35179 PyThreadState* __tstate = wxPyBeginAllowThreads();
35180 (arg1)->SetMenu(arg2);
35181
35182 wxPyEndAllowThreads(__tstate);
35183 if (PyErr_Occurred()) SWIG_fail;
35184 }
35185 Py_INCREF(Py_None); resultobj = Py_None;
35186 return resultobj;
35187 fail:
35188 return NULL;
35189 }
35190
35191
35192 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35193 PyObject *resultobj;
35194 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35195 int arg2 ;
35196 PyObject * obj0 = 0 ;
35197 PyObject * obj1 = 0 ;
35198 char *kwnames[] = {
35199 (char *) "self",(char *) "id", NULL
35200 };
35201
35202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35204 if (SWIG_arg_fail(1)) SWIG_fail;
35205 {
35206 arg2 = (int)(SWIG_As_int(obj1));
35207 if (SWIG_arg_fail(2)) SWIG_fail;
35208 }
35209 {
35210 PyThreadState* __tstate = wxPyBeginAllowThreads();
35211 (arg1)->SetId(arg2);
35212
35213 wxPyEndAllowThreads(__tstate);
35214 if (PyErr_Occurred()) SWIG_fail;
35215 }
35216 Py_INCREF(Py_None); resultobj = Py_None;
35217 return resultobj;
35218 fail:
35219 return NULL;
35220 }
35221
35222
35223 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35224 PyObject *resultobj;
35225 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35226 int result;
35227 PyObject * obj0 = 0 ;
35228 char *kwnames[] = {
35229 (char *) "self", NULL
35230 };
35231
35232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35234 if (SWIG_arg_fail(1)) SWIG_fail;
35235 {
35236 PyThreadState* __tstate = wxPyBeginAllowThreads();
35237 result = (int)((wxMenuItem const *)arg1)->GetId();
35238
35239 wxPyEndAllowThreads(__tstate);
35240 if (PyErr_Occurred()) SWIG_fail;
35241 }
35242 {
35243 resultobj = SWIG_From_int((int)(result));
35244 }
35245 return resultobj;
35246 fail:
35247 return NULL;
35248 }
35249
35250
35251 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35252 PyObject *resultobj;
35253 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35254 bool result;
35255 PyObject * obj0 = 0 ;
35256 char *kwnames[] = {
35257 (char *) "self", NULL
35258 };
35259
35260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35262 if (SWIG_arg_fail(1)) SWIG_fail;
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35266
35267 wxPyEndAllowThreads(__tstate);
35268 if (PyErr_Occurred()) SWIG_fail;
35269 }
35270 {
35271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35272 }
35273 return resultobj;
35274 fail:
35275 return NULL;
35276 }
35277
35278
35279 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35280 PyObject *resultobj;
35281 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35282 wxString *arg2 = 0 ;
35283 bool temp2 = false ;
35284 PyObject * obj0 = 0 ;
35285 PyObject * obj1 = 0 ;
35286 char *kwnames[] = {
35287 (char *) "self",(char *) "str", NULL
35288 };
35289
35290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35292 if (SWIG_arg_fail(1)) SWIG_fail;
35293 {
35294 arg2 = wxString_in_helper(obj1);
35295 if (arg2 == NULL) SWIG_fail;
35296 temp2 = true;
35297 }
35298 {
35299 PyThreadState* __tstate = wxPyBeginAllowThreads();
35300 (arg1)->SetText((wxString const &)*arg2);
35301
35302 wxPyEndAllowThreads(__tstate);
35303 if (PyErr_Occurred()) SWIG_fail;
35304 }
35305 Py_INCREF(Py_None); resultobj = Py_None;
35306 {
35307 if (temp2)
35308 delete arg2;
35309 }
35310 return resultobj;
35311 fail:
35312 {
35313 if (temp2)
35314 delete arg2;
35315 }
35316 return NULL;
35317 }
35318
35319
35320 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35321 PyObject *resultobj;
35322 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35323 wxString result;
35324 PyObject * obj0 = 0 ;
35325 char *kwnames[] = {
35326 (char *) "self", NULL
35327 };
35328
35329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35331 if (SWIG_arg_fail(1)) SWIG_fail;
35332 {
35333 PyThreadState* __tstate = wxPyBeginAllowThreads();
35334 result = ((wxMenuItem const *)arg1)->GetLabel();
35335
35336 wxPyEndAllowThreads(__tstate);
35337 if (PyErr_Occurred()) SWIG_fail;
35338 }
35339 {
35340 #if wxUSE_UNICODE
35341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35342 #else
35343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35344 #endif
35345 }
35346 return resultobj;
35347 fail:
35348 return NULL;
35349 }
35350
35351
35352 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35353 PyObject *resultobj;
35354 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35355 wxString *result;
35356 PyObject * obj0 = 0 ;
35357 char *kwnames[] = {
35358 (char *) "self", NULL
35359 };
35360
35361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35363 if (SWIG_arg_fail(1)) SWIG_fail;
35364 {
35365 PyThreadState* __tstate = wxPyBeginAllowThreads();
35366 {
35367 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35368 result = (wxString *) &_result_ref;
35369 }
35370
35371 wxPyEndAllowThreads(__tstate);
35372 if (PyErr_Occurred()) SWIG_fail;
35373 }
35374 {
35375 #if wxUSE_UNICODE
35376 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35377 #else
35378 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35379 #endif
35380 }
35381 return resultobj;
35382 fail:
35383 return NULL;
35384 }
35385
35386
35387 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35388 PyObject *resultobj;
35389 wxString *arg1 = 0 ;
35390 wxString result;
35391 bool temp1 = false ;
35392 PyObject * obj0 = 0 ;
35393 char *kwnames[] = {
35394 (char *) "text", NULL
35395 };
35396
35397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35398 {
35399 arg1 = wxString_in_helper(obj0);
35400 if (arg1 == NULL) SWIG_fail;
35401 temp1 = true;
35402 }
35403 {
35404 PyThreadState* __tstate = wxPyBeginAllowThreads();
35405 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35406
35407 wxPyEndAllowThreads(__tstate);
35408 if (PyErr_Occurred()) SWIG_fail;
35409 }
35410 {
35411 #if wxUSE_UNICODE
35412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35413 #else
35414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35415 #endif
35416 }
35417 {
35418 if (temp1)
35419 delete arg1;
35420 }
35421 return resultobj;
35422 fail:
35423 {
35424 if (temp1)
35425 delete arg1;
35426 }
35427 return NULL;
35428 }
35429
35430
35431 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35432 PyObject *resultobj;
35433 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35434 wxItemKind result;
35435 PyObject * obj0 = 0 ;
35436 char *kwnames[] = {
35437 (char *) "self", NULL
35438 };
35439
35440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35442 if (SWIG_arg_fail(1)) SWIG_fail;
35443 {
35444 PyThreadState* __tstate = wxPyBeginAllowThreads();
35445 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35446
35447 wxPyEndAllowThreads(__tstate);
35448 if (PyErr_Occurred()) SWIG_fail;
35449 }
35450 resultobj = SWIG_From_int((result));
35451 return resultobj;
35452 fail:
35453 return NULL;
35454 }
35455
35456
35457 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35458 PyObject *resultobj;
35459 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35460 wxItemKind arg2 ;
35461 PyObject * obj0 = 0 ;
35462 PyObject * obj1 = 0 ;
35463 char *kwnames[] = {
35464 (char *) "self",(char *) "kind", NULL
35465 };
35466
35467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35469 if (SWIG_arg_fail(1)) SWIG_fail;
35470 {
35471 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35472 if (SWIG_arg_fail(2)) SWIG_fail;
35473 }
35474 {
35475 PyThreadState* __tstate = wxPyBeginAllowThreads();
35476 (arg1)->SetKind((wxItemKind )arg2);
35477
35478 wxPyEndAllowThreads(__tstate);
35479 if (PyErr_Occurred()) SWIG_fail;
35480 }
35481 Py_INCREF(Py_None); resultobj = Py_None;
35482 return resultobj;
35483 fail:
35484 return NULL;
35485 }
35486
35487
35488 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35489 PyObject *resultobj;
35490 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35491 bool arg2 ;
35492 PyObject * obj0 = 0 ;
35493 PyObject * obj1 = 0 ;
35494 char *kwnames[] = {
35495 (char *) "self",(char *) "checkable", NULL
35496 };
35497
35498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35500 if (SWIG_arg_fail(1)) SWIG_fail;
35501 {
35502 arg2 = (bool)(SWIG_As_bool(obj1));
35503 if (SWIG_arg_fail(2)) SWIG_fail;
35504 }
35505 {
35506 PyThreadState* __tstate = wxPyBeginAllowThreads();
35507 (arg1)->SetCheckable(arg2);
35508
35509 wxPyEndAllowThreads(__tstate);
35510 if (PyErr_Occurred()) SWIG_fail;
35511 }
35512 Py_INCREF(Py_None); resultobj = Py_None;
35513 return resultobj;
35514 fail:
35515 return NULL;
35516 }
35517
35518
35519 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35520 PyObject *resultobj;
35521 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35522 bool result;
35523 PyObject * obj0 = 0 ;
35524 char *kwnames[] = {
35525 (char *) "self", NULL
35526 };
35527
35528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35530 if (SWIG_arg_fail(1)) SWIG_fail;
35531 {
35532 PyThreadState* __tstate = wxPyBeginAllowThreads();
35533 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35534
35535 wxPyEndAllowThreads(__tstate);
35536 if (PyErr_Occurred()) SWIG_fail;
35537 }
35538 {
35539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35540 }
35541 return resultobj;
35542 fail:
35543 return NULL;
35544 }
35545
35546
35547 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35548 PyObject *resultobj;
35549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35550 bool result;
35551 PyObject * obj0 = 0 ;
35552 char *kwnames[] = {
35553 (char *) "self", NULL
35554 };
35555
35556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35558 if (SWIG_arg_fail(1)) SWIG_fail;
35559 {
35560 PyThreadState* __tstate = wxPyBeginAllowThreads();
35561 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35562
35563 wxPyEndAllowThreads(__tstate);
35564 if (PyErr_Occurred()) SWIG_fail;
35565 }
35566 {
35567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35568 }
35569 return resultobj;
35570 fail:
35571 return NULL;
35572 }
35573
35574
35575 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35576 PyObject *resultobj;
35577 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35578 wxMenu *arg2 = (wxMenu *) 0 ;
35579 PyObject * obj0 = 0 ;
35580 PyObject * obj1 = 0 ;
35581 char *kwnames[] = {
35582 (char *) "self",(char *) "menu", NULL
35583 };
35584
35585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35587 if (SWIG_arg_fail(1)) SWIG_fail;
35588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35589 if (SWIG_arg_fail(2)) SWIG_fail;
35590 {
35591 PyThreadState* __tstate = wxPyBeginAllowThreads();
35592 (arg1)->SetSubMenu(arg2);
35593
35594 wxPyEndAllowThreads(__tstate);
35595 if (PyErr_Occurred()) SWIG_fail;
35596 }
35597 Py_INCREF(Py_None); resultobj = Py_None;
35598 return resultobj;
35599 fail:
35600 return NULL;
35601 }
35602
35603
35604 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35605 PyObject *resultobj;
35606 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35607 wxMenu *result;
35608 PyObject * obj0 = 0 ;
35609 char *kwnames[] = {
35610 (char *) "self", NULL
35611 };
35612
35613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35615 if (SWIG_arg_fail(1)) SWIG_fail;
35616 {
35617 PyThreadState* __tstate = wxPyBeginAllowThreads();
35618 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35619
35620 wxPyEndAllowThreads(__tstate);
35621 if (PyErr_Occurred()) SWIG_fail;
35622 }
35623 {
35624 resultobj = wxPyMake_wxObject(result, 0);
35625 }
35626 return resultobj;
35627 fail:
35628 return NULL;
35629 }
35630
35631
35632 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35633 PyObject *resultobj;
35634 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35635 bool arg2 = (bool) true ;
35636 PyObject * obj0 = 0 ;
35637 PyObject * obj1 = 0 ;
35638 char *kwnames[] = {
35639 (char *) "self",(char *) "enable", NULL
35640 };
35641
35642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35644 if (SWIG_arg_fail(1)) SWIG_fail;
35645 if (obj1) {
35646 {
35647 arg2 = (bool)(SWIG_As_bool(obj1));
35648 if (SWIG_arg_fail(2)) SWIG_fail;
35649 }
35650 }
35651 {
35652 PyThreadState* __tstate = wxPyBeginAllowThreads();
35653 (arg1)->Enable(arg2);
35654
35655 wxPyEndAllowThreads(__tstate);
35656 if (PyErr_Occurred()) SWIG_fail;
35657 }
35658 Py_INCREF(Py_None); resultobj = Py_None;
35659 return resultobj;
35660 fail:
35661 return NULL;
35662 }
35663
35664
35665 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35666 PyObject *resultobj;
35667 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35668 bool result;
35669 PyObject * obj0 = 0 ;
35670 char *kwnames[] = {
35671 (char *) "self", NULL
35672 };
35673
35674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35676 if (SWIG_arg_fail(1)) SWIG_fail;
35677 {
35678 PyThreadState* __tstate = wxPyBeginAllowThreads();
35679 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35680
35681 wxPyEndAllowThreads(__tstate);
35682 if (PyErr_Occurred()) SWIG_fail;
35683 }
35684 {
35685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35686 }
35687 return resultobj;
35688 fail:
35689 return NULL;
35690 }
35691
35692
35693 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35694 PyObject *resultobj;
35695 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35696 bool arg2 = (bool) true ;
35697 PyObject * obj0 = 0 ;
35698 PyObject * obj1 = 0 ;
35699 char *kwnames[] = {
35700 (char *) "self",(char *) "check", NULL
35701 };
35702
35703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35705 if (SWIG_arg_fail(1)) SWIG_fail;
35706 if (obj1) {
35707 {
35708 arg2 = (bool)(SWIG_As_bool(obj1));
35709 if (SWIG_arg_fail(2)) SWIG_fail;
35710 }
35711 }
35712 {
35713 PyThreadState* __tstate = wxPyBeginAllowThreads();
35714 (arg1)->Check(arg2);
35715
35716 wxPyEndAllowThreads(__tstate);
35717 if (PyErr_Occurred()) SWIG_fail;
35718 }
35719 Py_INCREF(Py_None); resultobj = Py_None;
35720 return resultobj;
35721 fail:
35722 return NULL;
35723 }
35724
35725
35726 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35727 PyObject *resultobj;
35728 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35729 bool result;
35730 PyObject * obj0 = 0 ;
35731 char *kwnames[] = {
35732 (char *) "self", NULL
35733 };
35734
35735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
35736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35737 if (SWIG_arg_fail(1)) SWIG_fail;
35738 {
35739 PyThreadState* __tstate = wxPyBeginAllowThreads();
35740 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
35741
35742 wxPyEndAllowThreads(__tstate);
35743 if (PyErr_Occurred()) SWIG_fail;
35744 }
35745 {
35746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35747 }
35748 return resultobj;
35749 fail:
35750 return NULL;
35751 }
35752
35753
35754 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
35755 PyObject *resultobj;
35756 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35757 PyObject * obj0 = 0 ;
35758 char *kwnames[] = {
35759 (char *) "self", NULL
35760 };
35761
35762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
35763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35764 if (SWIG_arg_fail(1)) SWIG_fail;
35765 {
35766 PyThreadState* __tstate = wxPyBeginAllowThreads();
35767 (arg1)->Toggle();
35768
35769 wxPyEndAllowThreads(__tstate);
35770 if (PyErr_Occurred()) SWIG_fail;
35771 }
35772 Py_INCREF(Py_None); resultobj = Py_None;
35773 return resultobj;
35774 fail:
35775 return NULL;
35776 }
35777
35778
35779 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35780 PyObject *resultobj;
35781 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35782 wxString *arg2 = 0 ;
35783 bool temp2 = false ;
35784 PyObject * obj0 = 0 ;
35785 PyObject * obj1 = 0 ;
35786 char *kwnames[] = {
35787 (char *) "self",(char *) "str", NULL
35788 };
35789
35790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
35791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35792 if (SWIG_arg_fail(1)) SWIG_fail;
35793 {
35794 arg2 = wxString_in_helper(obj1);
35795 if (arg2 == NULL) SWIG_fail;
35796 temp2 = true;
35797 }
35798 {
35799 PyThreadState* __tstate = wxPyBeginAllowThreads();
35800 (arg1)->SetHelp((wxString const &)*arg2);
35801
35802 wxPyEndAllowThreads(__tstate);
35803 if (PyErr_Occurred()) SWIG_fail;
35804 }
35805 Py_INCREF(Py_None); resultobj = Py_None;
35806 {
35807 if (temp2)
35808 delete arg2;
35809 }
35810 return resultobj;
35811 fail:
35812 {
35813 if (temp2)
35814 delete arg2;
35815 }
35816 return NULL;
35817 }
35818
35819
35820 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35821 PyObject *resultobj;
35822 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35823 wxString *result;
35824 PyObject * obj0 = 0 ;
35825 char *kwnames[] = {
35826 (char *) "self", NULL
35827 };
35828
35829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
35830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35831 if (SWIG_arg_fail(1)) SWIG_fail;
35832 {
35833 PyThreadState* __tstate = wxPyBeginAllowThreads();
35834 {
35835 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
35836 result = (wxString *) &_result_ref;
35837 }
35838
35839 wxPyEndAllowThreads(__tstate);
35840 if (PyErr_Occurred()) SWIG_fail;
35841 }
35842 {
35843 #if wxUSE_UNICODE
35844 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35845 #else
35846 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35847 #endif
35848 }
35849 return resultobj;
35850 fail:
35851 return NULL;
35852 }
35853
35854
35855 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35856 PyObject *resultobj;
35857 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35858 wxAcceleratorEntry *result;
35859 PyObject * obj0 = 0 ;
35860 char *kwnames[] = {
35861 (char *) "self", NULL
35862 };
35863
35864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
35865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35866 if (SWIG_arg_fail(1)) SWIG_fail;
35867 {
35868 PyThreadState* __tstate = wxPyBeginAllowThreads();
35869 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
35870
35871 wxPyEndAllowThreads(__tstate);
35872 if (PyErr_Occurred()) SWIG_fail;
35873 }
35874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
35875 return resultobj;
35876 fail:
35877 return NULL;
35878 }
35879
35880
35881 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35882 PyObject *resultobj;
35883 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35884 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
35885 PyObject * obj0 = 0 ;
35886 PyObject * obj1 = 0 ;
35887 char *kwnames[] = {
35888 (char *) "self",(char *) "accel", NULL
35889 };
35890
35891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
35892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35893 if (SWIG_arg_fail(1)) SWIG_fail;
35894 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
35895 if (SWIG_arg_fail(2)) SWIG_fail;
35896 {
35897 PyThreadState* __tstate = wxPyBeginAllowThreads();
35898 (arg1)->SetAccel(arg2);
35899
35900 wxPyEndAllowThreads(__tstate);
35901 if (PyErr_Occurred()) SWIG_fail;
35902 }
35903 Py_INCREF(Py_None); resultobj = Py_None;
35904 return resultobj;
35905 fail:
35906 return NULL;
35907 }
35908
35909
35910 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
35911 PyObject *resultobj;
35912 int result;
35913 char *kwnames[] = {
35914 NULL
35915 };
35916
35917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
35918 {
35919 PyThreadState* __tstate = wxPyBeginAllowThreads();
35920 result = (int)MenuItem_GetDefaultMarginWidth();
35921
35922 wxPyEndAllowThreads(__tstate);
35923 if (PyErr_Occurred()) SWIG_fail;
35924 }
35925 {
35926 resultobj = SWIG_From_int((int)(result));
35927 }
35928 return resultobj;
35929 fail:
35930 return NULL;
35931 }
35932
35933
35934 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
35935 PyObject *resultobj;
35936 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35937 wxBitmap *arg2 = 0 ;
35938 PyObject * obj0 = 0 ;
35939 PyObject * obj1 = 0 ;
35940 char *kwnames[] = {
35941 (char *) "self",(char *) "bitmap", NULL
35942 };
35943
35944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
35945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35946 if (SWIG_arg_fail(1)) SWIG_fail;
35947 {
35948 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
35949 if (SWIG_arg_fail(2)) SWIG_fail;
35950 if (arg2 == NULL) {
35951 SWIG_null_ref("wxBitmap");
35952 }
35953 if (SWIG_arg_fail(2)) SWIG_fail;
35954 }
35955 {
35956 PyThreadState* __tstate = wxPyBeginAllowThreads();
35957 (arg1)->SetBitmap((wxBitmap const &)*arg2);
35958
35959 wxPyEndAllowThreads(__tstate);
35960 if (PyErr_Occurred()) SWIG_fail;
35961 }
35962 Py_INCREF(Py_None); resultobj = Py_None;
35963 return resultobj;
35964 fail:
35965 return NULL;
35966 }
35967
35968
35969 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
35970 PyObject *resultobj;
35971 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35972 wxBitmap *result;
35973 PyObject * obj0 = 0 ;
35974 char *kwnames[] = {
35975 (char *) "self", NULL
35976 };
35977
35978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
35979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35980 if (SWIG_arg_fail(1)) SWIG_fail;
35981 {
35982 PyThreadState* __tstate = wxPyBeginAllowThreads();
35983 {
35984 wxBitmap const &_result_ref = (arg1)->GetBitmap();
35985 result = (wxBitmap *) &_result_ref;
35986 }
35987
35988 wxPyEndAllowThreads(__tstate);
35989 if (PyErr_Occurred()) SWIG_fail;
35990 }
35991 {
35992 wxBitmap* resultptr = new wxBitmap(*result);
35993 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
35994 }
35995 return resultobj;
35996 fail:
35997 return NULL;
35998 }
35999
36000
36001 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36002 PyObject *obj;
36003 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36004 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36005 Py_INCREF(obj);
36006 return Py_BuildValue((char *)"");
36007 }
36008 static int _wrap_ControlNameStr_set(PyObject *) {
36009 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36010 return 1;
36011 }
36012
36013
36014 static PyObject *_wrap_ControlNameStr_get(void) {
36015 PyObject *pyobj;
36016
36017 {
36018 #if wxUSE_UNICODE
36019 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36020 #else
36021 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36022 #endif
36023 }
36024 return pyobj;
36025 }
36026
36027
36028 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36029 PyObject *resultobj;
36030 wxWindow *arg1 = (wxWindow *) 0 ;
36031 int arg2 = (int) -1 ;
36032 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36033 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36034 wxSize const &arg4_defvalue = wxDefaultSize ;
36035 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36036 long arg5 = (long) 0 ;
36037 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36038 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36039 wxString const &arg7_defvalue = wxPyControlNameStr ;
36040 wxString *arg7 = (wxString *) &arg7_defvalue ;
36041 wxControl *result;
36042 wxPoint temp3 ;
36043 wxSize temp4 ;
36044 bool temp7 = false ;
36045 PyObject * obj0 = 0 ;
36046 PyObject * obj1 = 0 ;
36047 PyObject * obj2 = 0 ;
36048 PyObject * obj3 = 0 ;
36049 PyObject * obj4 = 0 ;
36050 PyObject * obj5 = 0 ;
36051 PyObject * obj6 = 0 ;
36052 char *kwnames[] = {
36053 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36054 };
36055
36056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36058 if (SWIG_arg_fail(1)) SWIG_fail;
36059 if (obj1) {
36060 {
36061 arg2 = (int)(SWIG_As_int(obj1));
36062 if (SWIG_arg_fail(2)) SWIG_fail;
36063 }
36064 }
36065 if (obj2) {
36066 {
36067 arg3 = &temp3;
36068 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36069 }
36070 }
36071 if (obj3) {
36072 {
36073 arg4 = &temp4;
36074 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36075 }
36076 }
36077 if (obj4) {
36078 {
36079 arg5 = (long)(SWIG_As_long(obj4));
36080 if (SWIG_arg_fail(5)) SWIG_fail;
36081 }
36082 }
36083 if (obj5) {
36084 {
36085 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36086 if (SWIG_arg_fail(6)) SWIG_fail;
36087 if (arg6 == NULL) {
36088 SWIG_null_ref("wxValidator");
36089 }
36090 if (SWIG_arg_fail(6)) SWIG_fail;
36091 }
36092 }
36093 if (obj6) {
36094 {
36095 arg7 = wxString_in_helper(obj6);
36096 if (arg7 == NULL) SWIG_fail;
36097 temp7 = true;
36098 }
36099 }
36100 {
36101 if (!wxPyCheckForApp()) SWIG_fail;
36102 PyThreadState* __tstate = wxPyBeginAllowThreads();
36103 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36104
36105 wxPyEndAllowThreads(__tstate);
36106 if (PyErr_Occurred()) SWIG_fail;
36107 }
36108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36109 {
36110 if (temp7)
36111 delete arg7;
36112 }
36113 return resultobj;
36114 fail:
36115 {
36116 if (temp7)
36117 delete arg7;
36118 }
36119 return NULL;
36120 }
36121
36122
36123 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36124 PyObject *resultobj;
36125 wxControl *result;
36126 char *kwnames[] = {
36127 NULL
36128 };
36129
36130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36131 {
36132 if (!wxPyCheckForApp()) SWIG_fail;
36133 PyThreadState* __tstate = wxPyBeginAllowThreads();
36134 result = (wxControl *)new wxControl();
36135
36136 wxPyEndAllowThreads(__tstate);
36137 if (PyErr_Occurred()) SWIG_fail;
36138 }
36139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36140 return resultobj;
36141 fail:
36142 return NULL;
36143 }
36144
36145
36146 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36147 PyObject *resultobj;
36148 wxControl *arg1 = (wxControl *) 0 ;
36149 wxWindow *arg2 = (wxWindow *) 0 ;
36150 int arg3 = (int) -1 ;
36151 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36152 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36153 wxSize const &arg5_defvalue = wxDefaultSize ;
36154 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36155 long arg6 = (long) 0 ;
36156 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36157 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36158 wxString const &arg8_defvalue = wxPyControlNameStr ;
36159 wxString *arg8 = (wxString *) &arg8_defvalue ;
36160 bool result;
36161 wxPoint temp4 ;
36162 wxSize temp5 ;
36163 bool temp8 = false ;
36164 PyObject * obj0 = 0 ;
36165 PyObject * obj1 = 0 ;
36166 PyObject * obj2 = 0 ;
36167 PyObject * obj3 = 0 ;
36168 PyObject * obj4 = 0 ;
36169 PyObject * obj5 = 0 ;
36170 PyObject * obj6 = 0 ;
36171 PyObject * obj7 = 0 ;
36172 char *kwnames[] = {
36173 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36174 };
36175
36176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36178 if (SWIG_arg_fail(1)) SWIG_fail;
36179 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36180 if (SWIG_arg_fail(2)) SWIG_fail;
36181 if (obj2) {
36182 {
36183 arg3 = (int)(SWIG_As_int(obj2));
36184 if (SWIG_arg_fail(3)) SWIG_fail;
36185 }
36186 }
36187 if (obj3) {
36188 {
36189 arg4 = &temp4;
36190 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36191 }
36192 }
36193 if (obj4) {
36194 {
36195 arg5 = &temp5;
36196 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36197 }
36198 }
36199 if (obj5) {
36200 {
36201 arg6 = (long)(SWIG_As_long(obj5));
36202 if (SWIG_arg_fail(6)) SWIG_fail;
36203 }
36204 }
36205 if (obj6) {
36206 {
36207 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36208 if (SWIG_arg_fail(7)) SWIG_fail;
36209 if (arg7 == NULL) {
36210 SWIG_null_ref("wxValidator");
36211 }
36212 if (SWIG_arg_fail(7)) SWIG_fail;
36213 }
36214 }
36215 if (obj7) {
36216 {
36217 arg8 = wxString_in_helper(obj7);
36218 if (arg8 == NULL) SWIG_fail;
36219 temp8 = true;
36220 }
36221 }
36222 {
36223 PyThreadState* __tstate = wxPyBeginAllowThreads();
36224 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36225
36226 wxPyEndAllowThreads(__tstate);
36227 if (PyErr_Occurred()) SWIG_fail;
36228 }
36229 {
36230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36231 }
36232 {
36233 if (temp8)
36234 delete arg8;
36235 }
36236 return resultobj;
36237 fail:
36238 {
36239 if (temp8)
36240 delete arg8;
36241 }
36242 return NULL;
36243 }
36244
36245
36246 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36247 PyObject *resultobj;
36248 wxControl *arg1 = (wxControl *) 0 ;
36249 wxCommandEvent *arg2 = 0 ;
36250 PyObject * obj0 = 0 ;
36251 PyObject * obj1 = 0 ;
36252 char *kwnames[] = {
36253 (char *) "self",(char *) "event", NULL
36254 };
36255
36256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36258 if (SWIG_arg_fail(1)) SWIG_fail;
36259 {
36260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
36261 if (SWIG_arg_fail(2)) SWIG_fail;
36262 if (arg2 == NULL) {
36263 SWIG_null_ref("wxCommandEvent");
36264 }
36265 if (SWIG_arg_fail(2)) SWIG_fail;
36266 }
36267 {
36268 PyThreadState* __tstate = wxPyBeginAllowThreads();
36269 (arg1)->Command(*arg2);
36270
36271 wxPyEndAllowThreads(__tstate);
36272 if (PyErr_Occurred()) SWIG_fail;
36273 }
36274 Py_INCREF(Py_None); resultobj = Py_None;
36275 return resultobj;
36276 fail:
36277 return NULL;
36278 }
36279
36280
36281 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36282 PyObject *resultobj;
36283 wxControl *arg1 = (wxControl *) 0 ;
36284 wxString result;
36285 PyObject * obj0 = 0 ;
36286 char *kwnames[] = {
36287 (char *) "self", NULL
36288 };
36289
36290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
36291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36292 if (SWIG_arg_fail(1)) SWIG_fail;
36293 {
36294 PyThreadState* __tstate = wxPyBeginAllowThreads();
36295 result = (arg1)->GetLabel();
36296
36297 wxPyEndAllowThreads(__tstate);
36298 if (PyErr_Occurred()) SWIG_fail;
36299 }
36300 {
36301 #if wxUSE_UNICODE
36302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36303 #else
36304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36305 #endif
36306 }
36307 return resultobj;
36308 fail:
36309 return NULL;
36310 }
36311
36312
36313 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36314 PyObject *resultobj;
36315 wxControl *arg1 = (wxControl *) 0 ;
36316 wxString *arg2 = 0 ;
36317 bool temp2 = false ;
36318 PyObject * obj0 = 0 ;
36319 PyObject * obj1 = 0 ;
36320 char *kwnames[] = {
36321 (char *) "self",(char *) "label", NULL
36322 };
36323
36324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
36325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36326 if (SWIG_arg_fail(1)) SWIG_fail;
36327 {
36328 arg2 = wxString_in_helper(obj1);
36329 if (arg2 == NULL) SWIG_fail;
36330 temp2 = true;
36331 }
36332 {
36333 PyThreadState* __tstate = wxPyBeginAllowThreads();
36334 (arg1)->SetLabel((wxString const &)*arg2);
36335
36336 wxPyEndAllowThreads(__tstate);
36337 if (PyErr_Occurred()) SWIG_fail;
36338 }
36339 Py_INCREF(Py_None); resultobj = Py_None;
36340 {
36341 if (temp2)
36342 delete arg2;
36343 }
36344 return resultobj;
36345 fail:
36346 {
36347 if (temp2)
36348 delete arg2;
36349 }
36350 return NULL;
36351 }
36352
36353
36354 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
36355 PyObject *resultobj;
36356 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36357 wxVisualAttributes result;
36358 PyObject * obj0 = 0 ;
36359 char *kwnames[] = {
36360 (char *) "variant", NULL
36361 };
36362
36363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
36364 if (obj0) {
36365 {
36366 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
36367 if (SWIG_arg_fail(1)) SWIG_fail;
36368 }
36369 }
36370 {
36371 if (!wxPyCheckForApp()) SWIG_fail;
36372 PyThreadState* __tstate = wxPyBeginAllowThreads();
36373 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
36374
36375 wxPyEndAllowThreads(__tstate);
36376 if (PyErr_Occurred()) SWIG_fail;
36377 }
36378 {
36379 wxVisualAttributes * resultptr;
36380 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
36381 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
36382 }
36383 return resultobj;
36384 fail:
36385 return NULL;
36386 }
36387
36388
36389 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
36390 PyObject *obj;
36391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36392 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
36393 Py_INCREF(obj);
36394 return Py_BuildValue((char *)"");
36395 }
36396 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
36397 PyObject *resultobj;
36398 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36399 wxString *arg2 = 0 ;
36400 PyObject *arg3 = (PyObject *) NULL ;
36401 int result;
36402 bool temp2 = false ;
36403 PyObject * obj0 = 0 ;
36404 PyObject * obj1 = 0 ;
36405 PyObject * obj2 = 0 ;
36406 char *kwnames[] = {
36407 (char *) "self",(char *) "item",(char *) "clientData", NULL
36408 };
36409
36410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
36411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36412 if (SWIG_arg_fail(1)) SWIG_fail;
36413 {
36414 arg2 = wxString_in_helper(obj1);
36415 if (arg2 == NULL) SWIG_fail;
36416 temp2 = true;
36417 }
36418 if (obj2) {
36419 arg3 = obj2;
36420 }
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
36424
36425 wxPyEndAllowThreads(__tstate);
36426 if (PyErr_Occurred()) SWIG_fail;
36427 }
36428 {
36429 resultobj = SWIG_From_int((int)(result));
36430 }
36431 {
36432 if (temp2)
36433 delete arg2;
36434 }
36435 return resultobj;
36436 fail:
36437 {
36438 if (temp2)
36439 delete arg2;
36440 }
36441 return NULL;
36442 }
36443
36444
36445 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
36446 PyObject *resultobj;
36447 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36448 wxArrayString *arg2 = 0 ;
36449 bool temp2 = false ;
36450 PyObject * obj0 = 0 ;
36451 PyObject * obj1 = 0 ;
36452 char *kwnames[] = {
36453 (char *) "self",(char *) "strings", NULL
36454 };
36455
36456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
36457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36458 if (SWIG_arg_fail(1)) SWIG_fail;
36459 {
36460 if (! PySequence_Check(obj1)) {
36461 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
36462 SWIG_fail;
36463 }
36464 arg2 = new wxArrayString;
36465 temp2 = true;
36466 int i, len=PySequence_Length(obj1);
36467 for (i=0; i<len; i++) {
36468 PyObject* item = PySequence_GetItem(obj1, i);
36469 #if wxUSE_UNICODE
36470 PyObject* str = PyObject_Unicode(item);
36471 #else
36472 PyObject* str = PyObject_Str(item);
36473 #endif
36474 if (PyErr_Occurred()) SWIG_fail;
36475 arg2->Add(Py2wxString(str));
36476 Py_DECREF(item);
36477 Py_DECREF(str);
36478 }
36479 }
36480 {
36481 PyThreadState* __tstate = wxPyBeginAllowThreads();
36482 (arg1)->Append((wxArrayString const &)*arg2);
36483
36484 wxPyEndAllowThreads(__tstate);
36485 if (PyErr_Occurred()) SWIG_fail;
36486 }
36487 Py_INCREF(Py_None); resultobj = Py_None;
36488 {
36489 if (temp2) delete arg2;
36490 }
36491 return resultobj;
36492 fail:
36493 {
36494 if (temp2) delete arg2;
36495 }
36496 return NULL;
36497 }
36498
36499
36500 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
36501 PyObject *resultobj;
36502 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36503 wxString *arg2 = 0 ;
36504 int arg3 ;
36505 PyObject *arg4 = (PyObject *) NULL ;
36506 int result;
36507 bool temp2 = false ;
36508 PyObject * obj0 = 0 ;
36509 PyObject * obj1 = 0 ;
36510 PyObject * obj2 = 0 ;
36511 PyObject * obj3 = 0 ;
36512 char *kwnames[] = {
36513 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
36514 };
36515
36516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
36517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36518 if (SWIG_arg_fail(1)) SWIG_fail;
36519 {
36520 arg2 = wxString_in_helper(obj1);
36521 if (arg2 == NULL) SWIG_fail;
36522 temp2 = true;
36523 }
36524 {
36525 arg3 = (int)(SWIG_As_int(obj2));
36526 if (SWIG_arg_fail(3)) SWIG_fail;
36527 }
36528 if (obj3) {
36529 arg4 = obj3;
36530 }
36531 {
36532 PyThreadState* __tstate = wxPyBeginAllowThreads();
36533 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
36534
36535 wxPyEndAllowThreads(__tstate);
36536 if (PyErr_Occurred()) SWIG_fail;
36537 }
36538 {
36539 resultobj = SWIG_From_int((int)(result));
36540 }
36541 {
36542 if (temp2)
36543 delete arg2;
36544 }
36545 return resultobj;
36546 fail:
36547 {
36548 if (temp2)
36549 delete arg2;
36550 }
36551 return NULL;
36552 }
36553
36554
36555 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
36556 PyObject *resultobj;
36557 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36558 PyObject * obj0 = 0 ;
36559 char *kwnames[] = {
36560 (char *) "self", NULL
36561 };
36562
36563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
36564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36565 if (SWIG_arg_fail(1)) SWIG_fail;
36566 {
36567 PyThreadState* __tstate = wxPyBeginAllowThreads();
36568 (arg1)->Clear();
36569
36570 wxPyEndAllowThreads(__tstate);
36571 if (PyErr_Occurred()) SWIG_fail;
36572 }
36573 Py_INCREF(Py_None); resultobj = Py_None;
36574 return resultobj;
36575 fail:
36576 return NULL;
36577 }
36578
36579
36580 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
36581 PyObject *resultobj;
36582 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36583 int arg2 ;
36584 PyObject * obj0 = 0 ;
36585 PyObject * obj1 = 0 ;
36586 char *kwnames[] = {
36587 (char *) "self",(char *) "n", NULL
36588 };
36589
36590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
36591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36592 if (SWIG_arg_fail(1)) SWIG_fail;
36593 {
36594 arg2 = (int)(SWIG_As_int(obj1));
36595 if (SWIG_arg_fail(2)) SWIG_fail;
36596 }
36597 {
36598 PyThreadState* __tstate = wxPyBeginAllowThreads();
36599 (arg1)->Delete(arg2);
36600
36601 wxPyEndAllowThreads(__tstate);
36602 if (PyErr_Occurred()) SWIG_fail;
36603 }
36604 Py_INCREF(Py_None); resultobj = Py_None;
36605 return resultobj;
36606 fail:
36607 return NULL;
36608 }
36609
36610
36611 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
36612 PyObject *resultobj;
36613 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36614 int result;
36615 PyObject * obj0 = 0 ;
36616 char *kwnames[] = {
36617 (char *) "self", NULL
36618 };
36619
36620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
36621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36622 if (SWIG_arg_fail(1)) SWIG_fail;
36623 {
36624 PyThreadState* __tstate = wxPyBeginAllowThreads();
36625 result = (int)((wxItemContainer const *)arg1)->GetCount();
36626
36627 wxPyEndAllowThreads(__tstate);
36628 if (PyErr_Occurred()) SWIG_fail;
36629 }
36630 {
36631 resultobj = SWIG_From_int((int)(result));
36632 }
36633 return resultobj;
36634 fail:
36635 return NULL;
36636 }
36637
36638
36639 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
36640 PyObject *resultobj;
36641 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36642 bool result;
36643 PyObject * obj0 = 0 ;
36644 char *kwnames[] = {
36645 (char *) "self", NULL
36646 };
36647
36648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
36649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36650 if (SWIG_arg_fail(1)) SWIG_fail;
36651 {
36652 PyThreadState* __tstate = wxPyBeginAllowThreads();
36653 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
36654
36655 wxPyEndAllowThreads(__tstate);
36656 if (PyErr_Occurred()) SWIG_fail;
36657 }
36658 {
36659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36660 }
36661 return resultobj;
36662 fail:
36663 return NULL;
36664 }
36665
36666
36667 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
36668 PyObject *resultobj;
36669 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36670 int arg2 ;
36671 wxString result;
36672 PyObject * obj0 = 0 ;
36673 PyObject * obj1 = 0 ;
36674 char *kwnames[] = {
36675 (char *) "self",(char *) "n", NULL
36676 };
36677
36678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
36679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36680 if (SWIG_arg_fail(1)) SWIG_fail;
36681 {
36682 arg2 = (int)(SWIG_As_int(obj1));
36683 if (SWIG_arg_fail(2)) SWIG_fail;
36684 }
36685 {
36686 PyThreadState* __tstate = wxPyBeginAllowThreads();
36687 result = ((wxItemContainer const *)arg1)->GetString(arg2);
36688
36689 wxPyEndAllowThreads(__tstate);
36690 if (PyErr_Occurred()) SWIG_fail;
36691 }
36692 {
36693 #if wxUSE_UNICODE
36694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36695 #else
36696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36697 #endif
36698 }
36699 return resultobj;
36700 fail:
36701 return NULL;
36702 }
36703
36704
36705 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
36706 PyObject *resultobj;
36707 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36708 wxArrayString result;
36709 PyObject * obj0 = 0 ;
36710 char *kwnames[] = {
36711 (char *) "self", NULL
36712 };
36713
36714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
36715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36716 if (SWIG_arg_fail(1)) SWIG_fail;
36717 {
36718 PyThreadState* __tstate = wxPyBeginAllowThreads();
36719 result = ((wxItemContainer const *)arg1)->GetStrings();
36720
36721 wxPyEndAllowThreads(__tstate);
36722 if (PyErr_Occurred()) SWIG_fail;
36723 }
36724 {
36725 resultobj = wxArrayString2PyList_helper(result);
36726 }
36727 return resultobj;
36728 fail:
36729 return NULL;
36730 }
36731
36732
36733 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
36734 PyObject *resultobj;
36735 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36736 int arg2 ;
36737 wxString *arg3 = 0 ;
36738 bool temp3 = false ;
36739 PyObject * obj0 = 0 ;
36740 PyObject * obj1 = 0 ;
36741 PyObject * obj2 = 0 ;
36742 char *kwnames[] = {
36743 (char *) "self",(char *) "n",(char *) "s", NULL
36744 };
36745
36746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36748 if (SWIG_arg_fail(1)) SWIG_fail;
36749 {
36750 arg2 = (int)(SWIG_As_int(obj1));
36751 if (SWIG_arg_fail(2)) SWIG_fail;
36752 }
36753 {
36754 arg3 = wxString_in_helper(obj2);
36755 if (arg3 == NULL) SWIG_fail;
36756 temp3 = true;
36757 }
36758 {
36759 PyThreadState* __tstate = wxPyBeginAllowThreads();
36760 (arg1)->SetString(arg2,(wxString const &)*arg3);
36761
36762 wxPyEndAllowThreads(__tstate);
36763 if (PyErr_Occurred()) SWIG_fail;
36764 }
36765 Py_INCREF(Py_None); resultobj = Py_None;
36766 {
36767 if (temp3)
36768 delete arg3;
36769 }
36770 return resultobj;
36771 fail:
36772 {
36773 if (temp3)
36774 delete arg3;
36775 }
36776 return NULL;
36777 }
36778
36779
36780 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
36781 PyObject *resultobj;
36782 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36783 wxString *arg2 = 0 ;
36784 int result;
36785 bool temp2 = false ;
36786 PyObject * obj0 = 0 ;
36787 PyObject * obj1 = 0 ;
36788 char *kwnames[] = {
36789 (char *) "self",(char *) "s", NULL
36790 };
36791
36792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
36793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36794 if (SWIG_arg_fail(1)) SWIG_fail;
36795 {
36796 arg2 = wxString_in_helper(obj1);
36797 if (arg2 == NULL) SWIG_fail;
36798 temp2 = true;
36799 }
36800 {
36801 PyThreadState* __tstate = wxPyBeginAllowThreads();
36802 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
36803
36804 wxPyEndAllowThreads(__tstate);
36805 if (PyErr_Occurred()) SWIG_fail;
36806 }
36807 {
36808 resultobj = SWIG_From_int((int)(result));
36809 }
36810 {
36811 if (temp2)
36812 delete arg2;
36813 }
36814 return resultobj;
36815 fail:
36816 {
36817 if (temp2)
36818 delete arg2;
36819 }
36820 return NULL;
36821 }
36822
36823
36824 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
36825 PyObject *resultobj;
36826 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36827 int arg2 ;
36828 PyObject * obj0 = 0 ;
36829 PyObject * obj1 = 0 ;
36830 char *kwnames[] = {
36831 (char *) "self",(char *) "n", NULL
36832 };
36833
36834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
36835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36836 if (SWIG_arg_fail(1)) SWIG_fail;
36837 {
36838 arg2 = (int)(SWIG_As_int(obj1));
36839 if (SWIG_arg_fail(2)) SWIG_fail;
36840 }
36841 {
36842 PyThreadState* __tstate = wxPyBeginAllowThreads();
36843 (arg1)->Select(arg2);
36844
36845 wxPyEndAllowThreads(__tstate);
36846 if (PyErr_Occurred()) SWIG_fail;
36847 }
36848 Py_INCREF(Py_None); resultobj = Py_None;
36849 return resultobj;
36850 fail:
36851 return NULL;
36852 }
36853
36854
36855 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36856 PyObject *resultobj;
36857 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36858 int result;
36859 PyObject * obj0 = 0 ;
36860 char *kwnames[] = {
36861 (char *) "self", NULL
36862 };
36863
36864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
36865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36866 if (SWIG_arg_fail(1)) SWIG_fail;
36867 {
36868 PyThreadState* __tstate = wxPyBeginAllowThreads();
36869 result = (int)((wxItemContainer const *)arg1)->GetSelection();
36870
36871 wxPyEndAllowThreads(__tstate);
36872 if (PyErr_Occurred()) SWIG_fail;
36873 }
36874 {
36875 resultobj = SWIG_From_int((int)(result));
36876 }
36877 return resultobj;
36878 fail:
36879 return NULL;
36880 }
36881
36882
36883 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36884 PyObject *resultobj;
36885 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36886 wxString result;
36887 PyObject * obj0 = 0 ;
36888 char *kwnames[] = {
36889 (char *) "self", NULL
36890 };
36891
36892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
36893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36894 if (SWIG_arg_fail(1)) SWIG_fail;
36895 {
36896 PyThreadState* __tstate = wxPyBeginAllowThreads();
36897 result = ((wxItemContainer const *)arg1)->GetStringSelection();
36898
36899 wxPyEndAllowThreads(__tstate);
36900 if (PyErr_Occurred()) SWIG_fail;
36901 }
36902 {
36903 #if wxUSE_UNICODE
36904 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36905 #else
36906 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36907 #endif
36908 }
36909 return resultobj;
36910 fail:
36911 return NULL;
36912 }
36913
36914
36915 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36916 PyObject *resultobj;
36917 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36918 int arg2 ;
36919 PyObject *result;
36920 PyObject * obj0 = 0 ;
36921 PyObject * obj1 = 0 ;
36922 char *kwnames[] = {
36923 (char *) "self",(char *) "n", NULL
36924 };
36925
36926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
36927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36928 if (SWIG_arg_fail(1)) SWIG_fail;
36929 {
36930 arg2 = (int)(SWIG_As_int(obj1));
36931 if (SWIG_arg_fail(2)) SWIG_fail;
36932 }
36933 {
36934 PyThreadState* __tstate = wxPyBeginAllowThreads();
36935 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
36936
36937 wxPyEndAllowThreads(__tstate);
36938 if (PyErr_Occurred()) SWIG_fail;
36939 }
36940 resultobj = result;
36941 return resultobj;
36942 fail:
36943 return NULL;
36944 }
36945
36946
36947 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36948 PyObject *resultobj;
36949 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36950 int arg2 ;
36951 PyObject *arg3 = (PyObject *) 0 ;
36952 PyObject * obj0 = 0 ;
36953 PyObject * obj1 = 0 ;
36954 PyObject * obj2 = 0 ;
36955 char *kwnames[] = {
36956 (char *) "self",(char *) "n",(char *) "clientData", NULL
36957 };
36958
36959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
36960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36961 if (SWIG_arg_fail(1)) SWIG_fail;
36962 {
36963 arg2 = (int)(SWIG_As_int(obj1));
36964 if (SWIG_arg_fail(2)) SWIG_fail;
36965 }
36966 arg3 = obj2;
36967 {
36968 PyThreadState* __tstate = wxPyBeginAllowThreads();
36969 wxItemContainer_SetClientData(arg1,arg2,arg3);
36970
36971 wxPyEndAllowThreads(__tstate);
36972 if (PyErr_Occurred()) SWIG_fail;
36973 }
36974 Py_INCREF(Py_None); resultobj = Py_None;
36975 return resultobj;
36976 fail:
36977 return NULL;
36978 }
36979
36980
36981 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
36982 PyObject *obj;
36983 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36984 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
36985 Py_INCREF(obj);
36986 return Py_BuildValue((char *)"");
36987 }
36988 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
36989 PyObject *obj;
36990 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36991 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
36992 Py_INCREF(obj);
36993 return Py_BuildValue((char *)"");
36994 }
36995 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
36996 PyObject *resultobj;
36997 wxSizerItem *result;
36998 char *kwnames[] = {
36999 NULL
37000 };
37001
37002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37003 {
37004 PyThreadState* __tstate = wxPyBeginAllowThreads();
37005 result = (wxSizerItem *)new wxSizerItem();
37006
37007 wxPyEndAllowThreads(__tstate);
37008 if (PyErr_Occurred()) SWIG_fail;
37009 }
37010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37011 return resultobj;
37012 fail:
37013 return NULL;
37014 }
37015
37016
37017 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37018 PyObject *resultobj;
37019 wxWindow *arg1 = (wxWindow *) 0 ;
37020 int arg2 ;
37021 int arg3 ;
37022 int arg4 ;
37023 PyObject *arg5 = (PyObject *) NULL ;
37024 wxSizerItem *result;
37025 PyObject * obj0 = 0 ;
37026 PyObject * obj1 = 0 ;
37027 PyObject * obj2 = 0 ;
37028 PyObject * obj3 = 0 ;
37029 PyObject * obj4 = 0 ;
37030 char *kwnames[] = {
37031 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37032 };
37033
37034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37036 if (SWIG_arg_fail(1)) SWIG_fail;
37037 {
37038 arg2 = (int)(SWIG_As_int(obj1));
37039 if (SWIG_arg_fail(2)) SWIG_fail;
37040 }
37041 {
37042 arg3 = (int)(SWIG_As_int(obj2));
37043 if (SWIG_arg_fail(3)) SWIG_fail;
37044 }
37045 {
37046 arg4 = (int)(SWIG_As_int(obj3));
37047 if (SWIG_arg_fail(4)) SWIG_fail;
37048 }
37049 if (obj4) {
37050 arg5 = obj4;
37051 }
37052 {
37053 PyThreadState* __tstate = wxPyBeginAllowThreads();
37054 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37055
37056 wxPyEndAllowThreads(__tstate);
37057 if (PyErr_Occurred()) SWIG_fail;
37058 }
37059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37060 return resultobj;
37061 fail:
37062 return NULL;
37063 }
37064
37065
37066 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37067 PyObject *resultobj;
37068 int arg1 ;
37069 int arg2 ;
37070 int arg3 ;
37071 int arg4 ;
37072 int arg5 ;
37073 PyObject *arg6 = (PyObject *) NULL ;
37074 wxSizerItem *result;
37075 PyObject * obj0 = 0 ;
37076 PyObject * obj1 = 0 ;
37077 PyObject * obj2 = 0 ;
37078 PyObject * obj3 = 0 ;
37079 PyObject * obj4 = 0 ;
37080 PyObject * obj5 = 0 ;
37081 char *kwnames[] = {
37082 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37083 };
37084
37085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37086 {
37087 arg1 = (int)(SWIG_As_int(obj0));
37088 if (SWIG_arg_fail(1)) SWIG_fail;
37089 }
37090 {
37091 arg2 = (int)(SWIG_As_int(obj1));
37092 if (SWIG_arg_fail(2)) SWIG_fail;
37093 }
37094 {
37095 arg3 = (int)(SWIG_As_int(obj2));
37096 if (SWIG_arg_fail(3)) SWIG_fail;
37097 }
37098 {
37099 arg4 = (int)(SWIG_As_int(obj3));
37100 if (SWIG_arg_fail(4)) SWIG_fail;
37101 }
37102 {
37103 arg5 = (int)(SWIG_As_int(obj4));
37104 if (SWIG_arg_fail(5)) SWIG_fail;
37105 }
37106 if (obj5) {
37107 arg6 = obj5;
37108 }
37109 {
37110 PyThreadState* __tstate = wxPyBeginAllowThreads();
37111 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37112
37113 wxPyEndAllowThreads(__tstate);
37114 if (PyErr_Occurred()) SWIG_fail;
37115 }
37116 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37117 return resultobj;
37118 fail:
37119 return NULL;
37120 }
37121
37122
37123 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37124 PyObject *resultobj;
37125 wxSizer *arg1 = (wxSizer *) 0 ;
37126 int arg2 ;
37127 int arg3 ;
37128 int arg4 ;
37129 PyObject *arg5 = (PyObject *) NULL ;
37130 wxSizerItem *result;
37131 PyObject * obj0 = 0 ;
37132 PyObject * obj1 = 0 ;
37133 PyObject * obj2 = 0 ;
37134 PyObject * obj3 = 0 ;
37135 PyObject * obj4 = 0 ;
37136 char *kwnames[] = {
37137 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37138 };
37139
37140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37142 if (SWIG_arg_fail(1)) SWIG_fail;
37143 {
37144 arg2 = (int)(SWIG_As_int(obj1));
37145 if (SWIG_arg_fail(2)) SWIG_fail;
37146 }
37147 {
37148 arg3 = (int)(SWIG_As_int(obj2));
37149 if (SWIG_arg_fail(3)) SWIG_fail;
37150 }
37151 {
37152 arg4 = (int)(SWIG_As_int(obj3));
37153 if (SWIG_arg_fail(4)) SWIG_fail;
37154 }
37155 if (obj4) {
37156 arg5 = obj4;
37157 }
37158 {
37159 PyThreadState* __tstate = wxPyBeginAllowThreads();
37160 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37161
37162 wxPyEndAllowThreads(__tstate);
37163 if (PyErr_Occurred()) SWIG_fail;
37164 }
37165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37166 return resultobj;
37167 fail:
37168 return NULL;
37169 }
37170
37171
37172 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37173 PyObject *resultobj;
37174 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37175 PyObject * obj0 = 0 ;
37176 char *kwnames[] = {
37177 (char *) "self", NULL
37178 };
37179
37180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37182 if (SWIG_arg_fail(1)) SWIG_fail;
37183 {
37184 PyThreadState* __tstate = wxPyBeginAllowThreads();
37185 (arg1)->DeleteWindows();
37186
37187 wxPyEndAllowThreads(__tstate);
37188 if (PyErr_Occurred()) SWIG_fail;
37189 }
37190 Py_INCREF(Py_None); resultobj = Py_None;
37191 return resultobj;
37192 fail:
37193 return NULL;
37194 }
37195
37196
37197 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37198 PyObject *resultobj;
37199 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37200 PyObject * obj0 = 0 ;
37201 char *kwnames[] = {
37202 (char *) "self", NULL
37203 };
37204
37205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
37206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37207 if (SWIG_arg_fail(1)) SWIG_fail;
37208 {
37209 PyThreadState* __tstate = wxPyBeginAllowThreads();
37210 (arg1)->DetachSizer();
37211
37212 wxPyEndAllowThreads(__tstate);
37213 if (PyErr_Occurred()) SWIG_fail;
37214 }
37215 Py_INCREF(Py_None); resultobj = Py_None;
37216 return resultobj;
37217 fail:
37218 return NULL;
37219 }
37220
37221
37222 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
37223 PyObject *resultobj;
37224 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37225 wxSize result;
37226 PyObject * obj0 = 0 ;
37227 char *kwnames[] = {
37228 (char *) "self", NULL
37229 };
37230
37231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
37232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37233 if (SWIG_arg_fail(1)) SWIG_fail;
37234 {
37235 PyThreadState* __tstate = wxPyBeginAllowThreads();
37236 result = (arg1)->GetSize();
37237
37238 wxPyEndAllowThreads(__tstate);
37239 if (PyErr_Occurred()) SWIG_fail;
37240 }
37241 {
37242 wxSize * resultptr;
37243 resultptr = new wxSize((wxSize &)(result));
37244 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37245 }
37246 return resultobj;
37247 fail:
37248 return NULL;
37249 }
37250
37251
37252 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
37253 PyObject *resultobj;
37254 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37255 wxSize result;
37256 PyObject * obj0 = 0 ;
37257 char *kwnames[] = {
37258 (char *) "self", NULL
37259 };
37260
37261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
37262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37263 if (SWIG_arg_fail(1)) SWIG_fail;
37264 {
37265 PyThreadState* __tstate = wxPyBeginAllowThreads();
37266 result = (arg1)->CalcMin();
37267
37268 wxPyEndAllowThreads(__tstate);
37269 if (PyErr_Occurred()) SWIG_fail;
37270 }
37271 {
37272 wxSize * resultptr;
37273 resultptr = new wxSize((wxSize &)(result));
37274 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37275 }
37276 return resultobj;
37277 fail:
37278 return NULL;
37279 }
37280
37281
37282 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
37283 PyObject *resultobj;
37284 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37285 wxPoint arg2 ;
37286 wxSize arg3 ;
37287 PyObject * obj0 = 0 ;
37288 PyObject * obj1 = 0 ;
37289 PyObject * obj2 = 0 ;
37290 char *kwnames[] = {
37291 (char *) "self",(char *) "pos",(char *) "size", NULL
37292 };
37293
37294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
37295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37296 if (SWIG_arg_fail(1)) SWIG_fail;
37297 {
37298 wxPoint * argp;
37299 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
37300 if (SWIG_arg_fail(2)) SWIG_fail;
37301 if (argp == NULL) {
37302 SWIG_null_ref("wxPoint");
37303 }
37304 if (SWIG_arg_fail(2)) SWIG_fail;
37305 arg2 = *argp;
37306 }
37307 {
37308 wxSize * argp;
37309 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37310 if (SWIG_arg_fail(3)) SWIG_fail;
37311 if (argp == NULL) {
37312 SWIG_null_ref("wxSize");
37313 }
37314 if (SWIG_arg_fail(3)) SWIG_fail;
37315 arg3 = *argp;
37316 }
37317 {
37318 PyThreadState* __tstate = wxPyBeginAllowThreads();
37319 (arg1)->SetDimension(arg2,arg3);
37320
37321 wxPyEndAllowThreads(__tstate);
37322 if (PyErr_Occurred()) SWIG_fail;
37323 }
37324 Py_INCREF(Py_None); resultobj = Py_None;
37325 return resultobj;
37326 fail:
37327 return NULL;
37328 }
37329
37330
37331 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
37332 PyObject *resultobj;
37333 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37334 wxSize result;
37335 PyObject * obj0 = 0 ;
37336 char *kwnames[] = {
37337 (char *) "self", NULL
37338 };
37339
37340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
37341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37342 if (SWIG_arg_fail(1)) SWIG_fail;
37343 {
37344 PyThreadState* __tstate = wxPyBeginAllowThreads();
37345 result = (arg1)->GetMinSize();
37346
37347 wxPyEndAllowThreads(__tstate);
37348 if (PyErr_Occurred()) SWIG_fail;
37349 }
37350 {
37351 wxSize * resultptr;
37352 resultptr = new wxSize((wxSize &)(result));
37353 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37354 }
37355 return resultobj;
37356 fail:
37357 return NULL;
37358 }
37359
37360
37361 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37362 PyObject *resultobj;
37363 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37364 wxSize result;
37365 PyObject * obj0 = 0 ;
37366 char *kwnames[] = {
37367 (char *) "self", NULL
37368 };
37369
37370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
37371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37372 if (SWIG_arg_fail(1)) SWIG_fail;
37373 {
37374 PyThreadState* __tstate = wxPyBeginAllowThreads();
37375 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
37376
37377 wxPyEndAllowThreads(__tstate);
37378 if (PyErr_Occurred()) SWIG_fail;
37379 }
37380 {
37381 wxSize * resultptr;
37382 resultptr = new wxSize((wxSize &)(result));
37383 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37384 }
37385 return resultobj;
37386 fail:
37387 return NULL;
37388 }
37389
37390
37391 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
37392 PyObject *resultobj;
37393 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37394 int arg2 ;
37395 int arg3 ;
37396 PyObject * obj0 = 0 ;
37397 PyObject * obj1 = 0 ;
37398 PyObject * obj2 = 0 ;
37399 char *kwnames[] = {
37400 (char *) "self",(char *) "x",(char *) "y", NULL
37401 };
37402
37403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
37404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37405 if (SWIG_arg_fail(1)) SWIG_fail;
37406 {
37407 arg2 = (int)(SWIG_As_int(obj1));
37408 if (SWIG_arg_fail(2)) SWIG_fail;
37409 }
37410 {
37411 arg3 = (int)(SWIG_As_int(obj2));
37412 if (SWIG_arg_fail(3)) SWIG_fail;
37413 }
37414 {
37415 PyThreadState* __tstate = wxPyBeginAllowThreads();
37416 (arg1)->SetInitSize(arg2,arg3);
37417
37418 wxPyEndAllowThreads(__tstate);
37419 if (PyErr_Occurred()) SWIG_fail;
37420 }
37421 Py_INCREF(Py_None); resultobj = Py_None;
37422 return resultobj;
37423 fail:
37424 return NULL;
37425 }
37426
37427
37428 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
37429 PyObject *resultobj;
37430 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37431 int arg2 ;
37432 int arg3 ;
37433 PyObject * obj0 = 0 ;
37434 PyObject * obj1 = 0 ;
37435 PyObject * obj2 = 0 ;
37436 char *kwnames[] = {
37437 (char *) "self",(char *) "width",(char *) "height", NULL
37438 };
37439
37440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
37441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37442 if (SWIG_arg_fail(1)) SWIG_fail;
37443 {
37444 arg2 = (int)(SWIG_As_int(obj1));
37445 if (SWIG_arg_fail(2)) SWIG_fail;
37446 }
37447 {
37448 arg3 = (int)(SWIG_As_int(obj2));
37449 if (SWIG_arg_fail(3)) SWIG_fail;
37450 }
37451 {
37452 PyThreadState* __tstate = wxPyBeginAllowThreads();
37453 (arg1)->SetRatio(arg2,arg3);
37454
37455 wxPyEndAllowThreads(__tstate);
37456 if (PyErr_Occurred()) SWIG_fail;
37457 }
37458 Py_INCREF(Py_None); resultobj = Py_None;
37459 return resultobj;
37460 fail:
37461 return NULL;
37462 }
37463
37464
37465 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
37466 PyObject *resultobj;
37467 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37468 wxSize arg2 ;
37469 PyObject * obj0 = 0 ;
37470 PyObject * obj1 = 0 ;
37471 char *kwnames[] = {
37472 (char *) "self",(char *) "size", NULL
37473 };
37474
37475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
37476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37477 if (SWIG_arg_fail(1)) SWIG_fail;
37478 {
37479 wxSize * argp;
37480 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37481 if (SWIG_arg_fail(2)) SWIG_fail;
37482 if (argp == NULL) {
37483 SWIG_null_ref("wxSize");
37484 }
37485 if (SWIG_arg_fail(2)) SWIG_fail;
37486 arg2 = *argp;
37487 }
37488 {
37489 PyThreadState* __tstate = wxPyBeginAllowThreads();
37490 (arg1)->SetRatio(arg2);
37491
37492 wxPyEndAllowThreads(__tstate);
37493 if (PyErr_Occurred()) SWIG_fail;
37494 }
37495 Py_INCREF(Py_None); resultobj = Py_None;
37496 return resultobj;
37497 fail:
37498 return NULL;
37499 }
37500
37501
37502 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37503 PyObject *resultobj;
37504 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37505 float arg2 ;
37506 PyObject * obj0 = 0 ;
37507 PyObject * obj1 = 0 ;
37508 char *kwnames[] = {
37509 (char *) "self",(char *) "ratio", NULL
37510 };
37511
37512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
37513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37514 if (SWIG_arg_fail(1)) SWIG_fail;
37515 {
37516 arg2 = (float)(SWIG_As_float(obj1));
37517 if (SWIG_arg_fail(2)) SWIG_fail;
37518 }
37519 {
37520 PyThreadState* __tstate = wxPyBeginAllowThreads();
37521 (arg1)->SetRatio(arg2);
37522
37523 wxPyEndAllowThreads(__tstate);
37524 if (PyErr_Occurred()) SWIG_fail;
37525 }
37526 Py_INCREF(Py_None); resultobj = Py_None;
37527 return resultobj;
37528 fail:
37529 return NULL;
37530 }
37531
37532
37533 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37534 PyObject *resultobj;
37535 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37536 float result;
37537 PyObject * obj0 = 0 ;
37538 char *kwnames[] = {
37539 (char *) "self", NULL
37540 };
37541
37542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
37543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37544 if (SWIG_arg_fail(1)) SWIG_fail;
37545 {
37546 PyThreadState* __tstate = wxPyBeginAllowThreads();
37547 result = (float)(arg1)->GetRatio();
37548
37549 wxPyEndAllowThreads(__tstate);
37550 if (PyErr_Occurred()) SWIG_fail;
37551 }
37552 {
37553 resultobj = SWIG_From_float((float)(result));
37554 }
37555 return resultobj;
37556 fail:
37557 return NULL;
37558 }
37559
37560
37561 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
37562 PyObject *resultobj;
37563 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37564 wxRect result;
37565 PyObject * obj0 = 0 ;
37566 char *kwnames[] = {
37567 (char *) "self", NULL
37568 };
37569
37570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
37571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37572 if (SWIG_arg_fail(1)) SWIG_fail;
37573 {
37574 PyThreadState* __tstate = wxPyBeginAllowThreads();
37575 result = (arg1)->GetRect();
37576
37577 wxPyEndAllowThreads(__tstate);
37578 if (PyErr_Occurred()) SWIG_fail;
37579 }
37580 {
37581 wxRect * resultptr;
37582 resultptr = new wxRect((wxRect &)(result));
37583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
37584 }
37585 return resultobj;
37586 fail:
37587 return NULL;
37588 }
37589
37590
37591 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37592 PyObject *resultobj;
37593 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37594 bool result;
37595 PyObject * obj0 = 0 ;
37596 char *kwnames[] = {
37597 (char *) "self", NULL
37598 };
37599
37600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
37601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37602 if (SWIG_arg_fail(1)) SWIG_fail;
37603 {
37604 PyThreadState* __tstate = wxPyBeginAllowThreads();
37605 result = (bool)(arg1)->IsWindow();
37606
37607 wxPyEndAllowThreads(__tstate);
37608 if (PyErr_Occurred()) SWIG_fail;
37609 }
37610 {
37611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37612 }
37613 return resultobj;
37614 fail:
37615 return NULL;
37616 }
37617
37618
37619 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37620 PyObject *resultobj;
37621 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37622 bool result;
37623 PyObject * obj0 = 0 ;
37624 char *kwnames[] = {
37625 (char *) "self", NULL
37626 };
37627
37628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
37629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37630 if (SWIG_arg_fail(1)) SWIG_fail;
37631 {
37632 PyThreadState* __tstate = wxPyBeginAllowThreads();
37633 result = (bool)(arg1)->IsSizer();
37634
37635 wxPyEndAllowThreads(__tstate);
37636 if (PyErr_Occurred()) SWIG_fail;
37637 }
37638 {
37639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37640 }
37641 return resultobj;
37642 fail:
37643 return NULL;
37644 }
37645
37646
37647 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37648 PyObject *resultobj;
37649 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37650 bool result;
37651 PyObject * obj0 = 0 ;
37652 char *kwnames[] = {
37653 (char *) "self", NULL
37654 };
37655
37656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
37657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37658 if (SWIG_arg_fail(1)) SWIG_fail;
37659 {
37660 PyThreadState* __tstate = wxPyBeginAllowThreads();
37661 result = (bool)(arg1)->IsSpacer();
37662
37663 wxPyEndAllowThreads(__tstate);
37664 if (PyErr_Occurred()) SWIG_fail;
37665 }
37666 {
37667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37668 }
37669 return resultobj;
37670 fail:
37671 return NULL;
37672 }
37673
37674
37675 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37676 PyObject *resultobj;
37677 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37678 int arg2 ;
37679 PyObject * obj0 = 0 ;
37680 PyObject * obj1 = 0 ;
37681 char *kwnames[] = {
37682 (char *) "self",(char *) "proportion", NULL
37683 };
37684
37685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
37686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37687 if (SWIG_arg_fail(1)) SWIG_fail;
37688 {
37689 arg2 = (int)(SWIG_As_int(obj1));
37690 if (SWIG_arg_fail(2)) SWIG_fail;
37691 }
37692 {
37693 PyThreadState* __tstate = wxPyBeginAllowThreads();
37694 (arg1)->SetProportion(arg2);
37695
37696 wxPyEndAllowThreads(__tstate);
37697 if (PyErr_Occurred()) SWIG_fail;
37698 }
37699 Py_INCREF(Py_None); resultobj = Py_None;
37700 return resultobj;
37701 fail:
37702 return NULL;
37703 }
37704
37705
37706 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37707 PyObject *resultobj;
37708 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37709 int result;
37710 PyObject * obj0 = 0 ;
37711 char *kwnames[] = {
37712 (char *) "self", NULL
37713 };
37714
37715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
37716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37717 if (SWIG_arg_fail(1)) SWIG_fail;
37718 {
37719 PyThreadState* __tstate = wxPyBeginAllowThreads();
37720 result = (int)(arg1)->GetProportion();
37721
37722 wxPyEndAllowThreads(__tstate);
37723 if (PyErr_Occurred()) SWIG_fail;
37724 }
37725 {
37726 resultobj = SWIG_From_int((int)(result));
37727 }
37728 return resultobj;
37729 fail:
37730 return NULL;
37731 }
37732
37733
37734 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37735 PyObject *resultobj;
37736 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37737 int arg2 ;
37738 PyObject * obj0 = 0 ;
37739 PyObject * obj1 = 0 ;
37740 char *kwnames[] = {
37741 (char *) "self",(char *) "flag", NULL
37742 };
37743
37744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
37745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37746 if (SWIG_arg_fail(1)) SWIG_fail;
37747 {
37748 arg2 = (int)(SWIG_As_int(obj1));
37749 if (SWIG_arg_fail(2)) SWIG_fail;
37750 }
37751 {
37752 PyThreadState* __tstate = wxPyBeginAllowThreads();
37753 (arg1)->SetFlag(arg2);
37754
37755 wxPyEndAllowThreads(__tstate);
37756 if (PyErr_Occurred()) SWIG_fail;
37757 }
37758 Py_INCREF(Py_None); resultobj = Py_None;
37759 return resultobj;
37760 fail:
37761 return NULL;
37762 }
37763
37764
37765 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37766 PyObject *resultobj;
37767 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37768 int result;
37769 PyObject * obj0 = 0 ;
37770 char *kwnames[] = {
37771 (char *) "self", NULL
37772 };
37773
37774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
37775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37776 if (SWIG_arg_fail(1)) SWIG_fail;
37777 {
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 result = (int)(arg1)->GetFlag();
37780
37781 wxPyEndAllowThreads(__tstate);
37782 if (PyErr_Occurred()) SWIG_fail;
37783 }
37784 {
37785 resultobj = SWIG_From_int((int)(result));
37786 }
37787 return resultobj;
37788 fail:
37789 return NULL;
37790 }
37791
37792
37793 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37794 PyObject *resultobj;
37795 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37796 int arg2 ;
37797 PyObject * obj0 = 0 ;
37798 PyObject * obj1 = 0 ;
37799 char *kwnames[] = {
37800 (char *) "self",(char *) "border", NULL
37801 };
37802
37803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
37804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37805 if (SWIG_arg_fail(1)) SWIG_fail;
37806 {
37807 arg2 = (int)(SWIG_As_int(obj1));
37808 if (SWIG_arg_fail(2)) SWIG_fail;
37809 }
37810 {
37811 PyThreadState* __tstate = wxPyBeginAllowThreads();
37812 (arg1)->SetBorder(arg2);
37813
37814 wxPyEndAllowThreads(__tstate);
37815 if (PyErr_Occurred()) SWIG_fail;
37816 }
37817 Py_INCREF(Py_None); resultobj = Py_None;
37818 return resultobj;
37819 fail:
37820 return NULL;
37821 }
37822
37823
37824 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37825 PyObject *resultobj;
37826 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37827 int result;
37828 PyObject * obj0 = 0 ;
37829 char *kwnames[] = {
37830 (char *) "self", NULL
37831 };
37832
37833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
37834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37835 if (SWIG_arg_fail(1)) SWIG_fail;
37836 {
37837 PyThreadState* __tstate = wxPyBeginAllowThreads();
37838 result = (int)(arg1)->GetBorder();
37839
37840 wxPyEndAllowThreads(__tstate);
37841 if (PyErr_Occurred()) SWIG_fail;
37842 }
37843 {
37844 resultobj = SWIG_From_int((int)(result));
37845 }
37846 return resultobj;
37847 fail:
37848 return NULL;
37849 }
37850
37851
37852 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37853 PyObject *resultobj;
37854 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37855 wxWindow *result;
37856 PyObject * obj0 = 0 ;
37857 char *kwnames[] = {
37858 (char *) "self", NULL
37859 };
37860
37861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
37862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37863 if (SWIG_arg_fail(1)) SWIG_fail;
37864 {
37865 PyThreadState* __tstate = wxPyBeginAllowThreads();
37866 result = (wxWindow *)(arg1)->GetWindow();
37867
37868 wxPyEndAllowThreads(__tstate);
37869 if (PyErr_Occurred()) SWIG_fail;
37870 }
37871 {
37872 resultobj = wxPyMake_wxObject(result, 0);
37873 }
37874 return resultobj;
37875 fail:
37876 return NULL;
37877 }
37878
37879
37880 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37881 PyObject *resultobj;
37882 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37883 wxWindow *arg2 = (wxWindow *) 0 ;
37884 PyObject * obj0 = 0 ;
37885 PyObject * obj1 = 0 ;
37886 char *kwnames[] = {
37887 (char *) "self",(char *) "window", NULL
37888 };
37889
37890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
37891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37892 if (SWIG_arg_fail(1)) SWIG_fail;
37893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37894 if (SWIG_arg_fail(2)) SWIG_fail;
37895 {
37896 PyThreadState* __tstate = wxPyBeginAllowThreads();
37897 (arg1)->SetWindow(arg2);
37898
37899 wxPyEndAllowThreads(__tstate);
37900 if (PyErr_Occurred()) SWIG_fail;
37901 }
37902 Py_INCREF(Py_None); resultobj = Py_None;
37903 return resultobj;
37904 fail:
37905 return NULL;
37906 }
37907
37908
37909 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37910 PyObject *resultobj;
37911 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37912 wxSizer *result;
37913 PyObject * obj0 = 0 ;
37914 char *kwnames[] = {
37915 (char *) "self", NULL
37916 };
37917
37918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
37919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37920 if (SWIG_arg_fail(1)) SWIG_fail;
37921 {
37922 PyThreadState* __tstate = wxPyBeginAllowThreads();
37923 result = (wxSizer *)(arg1)->GetSizer();
37924
37925 wxPyEndAllowThreads(__tstate);
37926 if (PyErr_Occurred()) SWIG_fail;
37927 }
37928 {
37929 resultobj = wxPyMake_wxSizer(result, 0);
37930 }
37931 return resultobj;
37932 fail:
37933 return NULL;
37934 }
37935
37936
37937 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37938 PyObject *resultobj;
37939 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37940 wxSizer *arg2 = (wxSizer *) 0 ;
37941 PyObject * obj0 = 0 ;
37942 PyObject * obj1 = 0 ;
37943 char *kwnames[] = {
37944 (char *) "self",(char *) "sizer", NULL
37945 };
37946
37947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
37948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37949 if (SWIG_arg_fail(1)) SWIG_fail;
37950 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37951 if (SWIG_arg_fail(2)) SWIG_fail;
37952 {
37953 PyThreadState* __tstate = wxPyBeginAllowThreads();
37954 (arg1)->SetSizer(arg2);
37955
37956 wxPyEndAllowThreads(__tstate);
37957 if (PyErr_Occurred()) SWIG_fail;
37958 }
37959 Py_INCREF(Py_None); resultobj = Py_None;
37960 return resultobj;
37961 fail:
37962 return NULL;
37963 }
37964
37965
37966 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37967 PyObject *resultobj;
37968 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37969 wxSize *result;
37970 PyObject * obj0 = 0 ;
37971 char *kwnames[] = {
37972 (char *) "self", NULL
37973 };
37974
37975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
37976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37977 if (SWIG_arg_fail(1)) SWIG_fail;
37978 {
37979 PyThreadState* __tstate = wxPyBeginAllowThreads();
37980 {
37981 wxSize const &_result_ref = (arg1)->GetSpacer();
37982 result = (wxSize *) &_result_ref;
37983 }
37984
37985 wxPyEndAllowThreads(__tstate);
37986 if (PyErr_Occurred()) SWIG_fail;
37987 }
37988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
37989 return resultobj;
37990 fail:
37991 return NULL;
37992 }
37993
37994
37995 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37996 PyObject *resultobj;
37997 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37998 wxSize *arg2 = 0 ;
37999 wxSize temp2 ;
38000 PyObject * obj0 = 0 ;
38001 PyObject * obj1 = 0 ;
38002 char *kwnames[] = {
38003 (char *) "self",(char *) "size", NULL
38004 };
38005
38006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38008 if (SWIG_arg_fail(1)) SWIG_fail;
38009 {
38010 arg2 = &temp2;
38011 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38012 }
38013 {
38014 PyThreadState* __tstate = wxPyBeginAllowThreads();
38015 (arg1)->SetSpacer((wxSize const &)*arg2);
38016
38017 wxPyEndAllowThreads(__tstate);
38018 if (PyErr_Occurred()) SWIG_fail;
38019 }
38020 Py_INCREF(Py_None); resultobj = Py_None;
38021 return resultobj;
38022 fail:
38023 return NULL;
38024 }
38025
38026
38027 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38028 PyObject *resultobj;
38029 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38030 bool arg2 ;
38031 PyObject * obj0 = 0 ;
38032 PyObject * obj1 = 0 ;
38033 char *kwnames[] = {
38034 (char *) "self",(char *) "show", NULL
38035 };
38036
38037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38039 if (SWIG_arg_fail(1)) SWIG_fail;
38040 {
38041 arg2 = (bool)(SWIG_As_bool(obj1));
38042 if (SWIG_arg_fail(2)) SWIG_fail;
38043 }
38044 {
38045 PyThreadState* __tstate = wxPyBeginAllowThreads();
38046 (arg1)->Show(arg2);
38047
38048 wxPyEndAllowThreads(__tstate);
38049 if (PyErr_Occurred()) SWIG_fail;
38050 }
38051 Py_INCREF(Py_None); resultobj = Py_None;
38052 return resultobj;
38053 fail:
38054 return NULL;
38055 }
38056
38057
38058 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38059 PyObject *resultobj;
38060 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38061 bool result;
38062 PyObject * obj0 = 0 ;
38063 char *kwnames[] = {
38064 (char *) "self", NULL
38065 };
38066
38067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38069 if (SWIG_arg_fail(1)) SWIG_fail;
38070 {
38071 PyThreadState* __tstate = wxPyBeginAllowThreads();
38072 result = (bool)(arg1)->IsShown();
38073
38074 wxPyEndAllowThreads(__tstate);
38075 if (PyErr_Occurred()) SWIG_fail;
38076 }
38077 {
38078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38079 }
38080 return resultobj;
38081 fail:
38082 return NULL;
38083 }
38084
38085
38086 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38087 PyObject *resultobj;
38088 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38089 wxPoint result;
38090 PyObject * obj0 = 0 ;
38091 char *kwnames[] = {
38092 (char *) "self", NULL
38093 };
38094
38095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38097 if (SWIG_arg_fail(1)) SWIG_fail;
38098 {
38099 PyThreadState* __tstate = wxPyBeginAllowThreads();
38100 result = (arg1)->GetPosition();
38101
38102 wxPyEndAllowThreads(__tstate);
38103 if (PyErr_Occurred()) SWIG_fail;
38104 }
38105 {
38106 wxPoint * resultptr;
38107 resultptr = new wxPoint((wxPoint &)(result));
38108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38109 }
38110 return resultobj;
38111 fail:
38112 return NULL;
38113 }
38114
38115
38116 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38117 PyObject *resultobj;
38118 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38119 PyObject *result;
38120 PyObject * obj0 = 0 ;
38121 char *kwnames[] = {
38122 (char *) "self", NULL
38123 };
38124
38125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38127 if (SWIG_arg_fail(1)) SWIG_fail;
38128 {
38129 PyThreadState* __tstate = wxPyBeginAllowThreads();
38130 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38131
38132 wxPyEndAllowThreads(__tstate);
38133 if (PyErr_Occurred()) SWIG_fail;
38134 }
38135 resultobj = result;
38136 return resultobj;
38137 fail:
38138 return NULL;
38139 }
38140
38141
38142 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38143 PyObject *obj;
38144 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38145 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38146 Py_INCREF(obj);
38147 return Py_BuildValue((char *)"");
38148 }
38149 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38150 PyObject *resultobj;
38151 wxSizer *arg1 = (wxSizer *) 0 ;
38152 PyObject *arg2 = (PyObject *) 0 ;
38153 PyObject * obj0 = 0 ;
38154 PyObject * obj1 = 0 ;
38155 char *kwnames[] = {
38156 (char *) "self",(char *) "_self", NULL
38157 };
38158
38159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38161 if (SWIG_arg_fail(1)) SWIG_fail;
38162 arg2 = obj1;
38163 {
38164 PyThreadState* __tstate = wxPyBeginAllowThreads();
38165 wxSizer__setOORInfo(arg1,arg2);
38166
38167 wxPyEndAllowThreads(__tstate);
38168 if (PyErr_Occurred()) SWIG_fail;
38169 }
38170 Py_INCREF(Py_None); resultobj = Py_None;
38171 return resultobj;
38172 fail:
38173 return NULL;
38174 }
38175
38176
38177 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38178 PyObject *resultobj;
38179 wxSizer *arg1 = (wxSizer *) 0 ;
38180 PyObject *arg2 = (PyObject *) 0 ;
38181 int arg3 = (int) 0 ;
38182 int arg4 = (int) 0 ;
38183 int arg5 = (int) 0 ;
38184 PyObject *arg6 = (PyObject *) NULL ;
38185 wxSizerItem *result;
38186 PyObject * obj0 = 0 ;
38187 PyObject * obj1 = 0 ;
38188 PyObject * obj2 = 0 ;
38189 PyObject * obj3 = 0 ;
38190 PyObject * obj4 = 0 ;
38191 PyObject * obj5 = 0 ;
38192 char *kwnames[] = {
38193 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38194 };
38195
38196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38198 if (SWIG_arg_fail(1)) SWIG_fail;
38199 arg2 = obj1;
38200 if (obj2) {
38201 {
38202 arg3 = (int)(SWIG_As_int(obj2));
38203 if (SWIG_arg_fail(3)) SWIG_fail;
38204 }
38205 }
38206 if (obj3) {
38207 {
38208 arg4 = (int)(SWIG_As_int(obj3));
38209 if (SWIG_arg_fail(4)) SWIG_fail;
38210 }
38211 }
38212 if (obj4) {
38213 {
38214 arg5 = (int)(SWIG_As_int(obj4));
38215 if (SWIG_arg_fail(5)) SWIG_fail;
38216 }
38217 }
38218 if (obj5) {
38219 arg6 = obj5;
38220 }
38221 {
38222 PyThreadState* __tstate = wxPyBeginAllowThreads();
38223 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
38224
38225 wxPyEndAllowThreads(__tstate);
38226 if (PyErr_Occurred()) SWIG_fail;
38227 }
38228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38229 return resultobj;
38230 fail:
38231 return NULL;
38232 }
38233
38234
38235 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38236 PyObject *resultobj;
38237 wxSizer *arg1 = (wxSizer *) 0 ;
38238 int arg2 ;
38239 PyObject *arg3 = (PyObject *) 0 ;
38240 int arg4 = (int) 0 ;
38241 int arg5 = (int) 0 ;
38242 int arg6 = (int) 0 ;
38243 PyObject *arg7 = (PyObject *) NULL ;
38244 wxSizerItem *result;
38245 PyObject * obj0 = 0 ;
38246 PyObject * obj1 = 0 ;
38247 PyObject * obj2 = 0 ;
38248 PyObject * obj3 = 0 ;
38249 PyObject * obj4 = 0 ;
38250 PyObject * obj5 = 0 ;
38251 PyObject * obj6 = 0 ;
38252 char *kwnames[] = {
38253 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38254 };
38255
38256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38258 if (SWIG_arg_fail(1)) SWIG_fail;
38259 {
38260 arg2 = (int)(SWIG_As_int(obj1));
38261 if (SWIG_arg_fail(2)) SWIG_fail;
38262 }
38263 arg3 = obj2;
38264 if (obj3) {
38265 {
38266 arg4 = (int)(SWIG_As_int(obj3));
38267 if (SWIG_arg_fail(4)) SWIG_fail;
38268 }
38269 }
38270 if (obj4) {
38271 {
38272 arg5 = (int)(SWIG_As_int(obj4));
38273 if (SWIG_arg_fail(5)) SWIG_fail;
38274 }
38275 }
38276 if (obj5) {
38277 {
38278 arg6 = (int)(SWIG_As_int(obj5));
38279 if (SWIG_arg_fail(6)) SWIG_fail;
38280 }
38281 }
38282 if (obj6) {
38283 arg7 = obj6;
38284 }
38285 {
38286 PyThreadState* __tstate = wxPyBeginAllowThreads();
38287 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
38288
38289 wxPyEndAllowThreads(__tstate);
38290 if (PyErr_Occurred()) SWIG_fail;
38291 }
38292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38293 return resultobj;
38294 fail:
38295 return NULL;
38296 }
38297
38298
38299 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
38300 PyObject *resultobj;
38301 wxSizer *arg1 = (wxSizer *) 0 ;
38302 PyObject *arg2 = (PyObject *) 0 ;
38303 int arg3 = (int) 0 ;
38304 int arg4 = (int) 0 ;
38305 int arg5 = (int) 0 ;
38306 PyObject *arg6 = (PyObject *) NULL ;
38307 wxSizerItem *result;
38308 PyObject * obj0 = 0 ;
38309 PyObject * obj1 = 0 ;
38310 PyObject * obj2 = 0 ;
38311 PyObject * obj3 = 0 ;
38312 PyObject * obj4 = 0 ;
38313 PyObject * obj5 = 0 ;
38314 char *kwnames[] = {
38315 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38316 };
38317
38318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38320 if (SWIG_arg_fail(1)) SWIG_fail;
38321 arg2 = obj1;
38322 if (obj2) {
38323 {
38324 arg3 = (int)(SWIG_As_int(obj2));
38325 if (SWIG_arg_fail(3)) SWIG_fail;
38326 }
38327 }
38328 if (obj3) {
38329 {
38330 arg4 = (int)(SWIG_As_int(obj3));
38331 if (SWIG_arg_fail(4)) SWIG_fail;
38332 }
38333 }
38334 if (obj4) {
38335 {
38336 arg5 = (int)(SWIG_As_int(obj4));
38337 if (SWIG_arg_fail(5)) SWIG_fail;
38338 }
38339 }
38340 if (obj5) {
38341 arg6 = obj5;
38342 }
38343 {
38344 PyThreadState* __tstate = wxPyBeginAllowThreads();
38345 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
38346
38347 wxPyEndAllowThreads(__tstate);
38348 if (PyErr_Occurred()) SWIG_fail;
38349 }
38350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38351 return resultobj;
38352 fail:
38353 return NULL;
38354 }
38355
38356
38357 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
38358 PyObject *resultobj;
38359 wxSizer *arg1 = (wxSizer *) 0 ;
38360 PyObject *arg2 = (PyObject *) 0 ;
38361 bool result;
38362 PyObject * obj0 = 0 ;
38363 PyObject * obj1 = 0 ;
38364 char *kwnames[] = {
38365 (char *) "self",(char *) "item", NULL
38366 };
38367
38368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
38369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38370 if (SWIG_arg_fail(1)) SWIG_fail;
38371 arg2 = obj1;
38372 {
38373 PyThreadState* __tstate = wxPyBeginAllowThreads();
38374 result = (bool)wxSizer_Remove(arg1,arg2);
38375
38376 wxPyEndAllowThreads(__tstate);
38377 if (PyErr_Occurred()) SWIG_fail;
38378 }
38379 {
38380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38381 }
38382 return resultobj;
38383 fail:
38384 return NULL;
38385 }
38386
38387
38388 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
38389 PyObject *resultobj;
38390 wxSizer *arg1 = (wxSizer *) 0 ;
38391 PyObject *arg2 = (PyObject *) 0 ;
38392 bool result;
38393 PyObject * obj0 = 0 ;
38394 PyObject * obj1 = 0 ;
38395 char *kwnames[] = {
38396 (char *) "self",(char *) "item", NULL
38397 };
38398
38399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
38400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38401 if (SWIG_arg_fail(1)) SWIG_fail;
38402 arg2 = obj1;
38403 {
38404 PyThreadState* __tstate = wxPyBeginAllowThreads();
38405 result = (bool)wxSizer_Detach(arg1,arg2);
38406
38407 wxPyEndAllowThreads(__tstate);
38408 if (PyErr_Occurred()) SWIG_fail;
38409 }
38410 {
38411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38412 }
38413 return resultobj;
38414 fail:
38415 return NULL;
38416 }
38417
38418
38419 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
38420 PyObject *resultobj;
38421 wxSizer *arg1 = (wxSizer *) 0 ;
38422 PyObject *arg2 = (PyObject *) 0 ;
38423 wxSizerItem *result;
38424 PyObject * obj0 = 0 ;
38425 PyObject * obj1 = 0 ;
38426 char *kwnames[] = {
38427 (char *) "self",(char *) "item", NULL
38428 };
38429
38430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
38431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38432 if (SWIG_arg_fail(1)) SWIG_fail;
38433 arg2 = obj1;
38434 {
38435 PyThreadState* __tstate = wxPyBeginAllowThreads();
38436 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
38437
38438 wxPyEndAllowThreads(__tstate);
38439 if (PyErr_Occurred()) SWIG_fail;
38440 }
38441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38442 return resultobj;
38443 fail:
38444 return NULL;
38445 }
38446
38447
38448 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38449 PyObject *resultobj;
38450 wxSizer *arg1 = (wxSizer *) 0 ;
38451 PyObject *arg2 = (PyObject *) 0 ;
38452 wxSize *arg3 = 0 ;
38453 wxSize temp3 ;
38454 PyObject * obj0 = 0 ;
38455 PyObject * obj1 = 0 ;
38456 PyObject * obj2 = 0 ;
38457 char *kwnames[] = {
38458 (char *) "self",(char *) "item",(char *) "size", NULL
38459 };
38460
38461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38463 if (SWIG_arg_fail(1)) SWIG_fail;
38464 arg2 = obj1;
38465 {
38466 arg3 = &temp3;
38467 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
38468 }
38469 {
38470 PyThreadState* __tstate = wxPyBeginAllowThreads();
38471 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
38472
38473 wxPyEndAllowThreads(__tstate);
38474 if (PyErr_Occurred()) SWIG_fail;
38475 }
38476 Py_INCREF(Py_None); resultobj = Py_None;
38477 return resultobj;
38478 fail:
38479 return NULL;
38480 }
38481
38482
38483 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
38484 PyObject *resultobj;
38485 wxSizer *arg1 = (wxSizer *) 0 ;
38486 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38487 wxSizerItem *result;
38488 PyObject * obj0 = 0 ;
38489 PyObject * obj1 = 0 ;
38490 char *kwnames[] = {
38491 (char *) "self",(char *) "item", NULL
38492 };
38493
38494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
38495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38496 if (SWIG_arg_fail(1)) SWIG_fail;
38497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38498 if (SWIG_arg_fail(2)) SWIG_fail;
38499 {
38500 PyThreadState* __tstate = wxPyBeginAllowThreads();
38501 result = (wxSizerItem *)(arg1)->Add(arg2);
38502
38503 wxPyEndAllowThreads(__tstate);
38504 if (PyErr_Occurred()) SWIG_fail;
38505 }
38506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38507 return resultobj;
38508 fail:
38509 return NULL;
38510 }
38511
38512
38513 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
38514 PyObject *resultobj;
38515 wxSizer *arg1 = (wxSizer *) 0 ;
38516 size_t arg2 ;
38517 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
38518 wxSizerItem *result;
38519 PyObject * obj0 = 0 ;
38520 PyObject * obj1 = 0 ;
38521 PyObject * obj2 = 0 ;
38522 char *kwnames[] = {
38523 (char *) "self",(char *) "index",(char *) "item", NULL
38524 };
38525
38526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
38527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38528 if (SWIG_arg_fail(1)) SWIG_fail;
38529 {
38530 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
38531 if (SWIG_arg_fail(2)) SWIG_fail;
38532 }
38533 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38534 if (SWIG_arg_fail(3)) SWIG_fail;
38535 {
38536 PyThreadState* __tstate = wxPyBeginAllowThreads();
38537 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
38538
38539 wxPyEndAllowThreads(__tstate);
38540 if (PyErr_Occurred()) SWIG_fail;
38541 }
38542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38543 return resultobj;
38544 fail:
38545 return NULL;
38546 }
38547
38548
38549 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
38550 PyObject *resultobj;
38551 wxSizer *arg1 = (wxSizer *) 0 ;
38552 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38553 wxSizerItem *result;
38554 PyObject * obj0 = 0 ;
38555 PyObject * obj1 = 0 ;
38556 char *kwnames[] = {
38557 (char *) "self",(char *) "item", NULL
38558 };
38559
38560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
38561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38562 if (SWIG_arg_fail(1)) SWIG_fail;
38563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38564 if (SWIG_arg_fail(2)) SWIG_fail;
38565 {
38566 PyThreadState* __tstate = wxPyBeginAllowThreads();
38567 result = (wxSizerItem *)(arg1)->Prepend(arg2);
38568
38569 wxPyEndAllowThreads(__tstate);
38570 if (PyErr_Occurred()) SWIG_fail;
38571 }
38572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38573 return resultobj;
38574 fail:
38575 return NULL;
38576 }
38577
38578
38579 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38580 PyObject *resultobj;
38581 wxSizer *arg1 = (wxSizer *) 0 ;
38582 int arg2 ;
38583 int arg3 ;
38584 int arg4 ;
38585 int arg5 ;
38586 PyObject * obj0 = 0 ;
38587 PyObject * obj1 = 0 ;
38588 PyObject * obj2 = 0 ;
38589 PyObject * obj3 = 0 ;
38590 PyObject * obj4 = 0 ;
38591 char *kwnames[] = {
38592 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
38593 };
38594
38595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38597 if (SWIG_arg_fail(1)) SWIG_fail;
38598 {
38599 arg2 = (int)(SWIG_As_int(obj1));
38600 if (SWIG_arg_fail(2)) SWIG_fail;
38601 }
38602 {
38603 arg3 = (int)(SWIG_As_int(obj2));
38604 if (SWIG_arg_fail(3)) SWIG_fail;
38605 }
38606 {
38607 arg4 = (int)(SWIG_As_int(obj3));
38608 if (SWIG_arg_fail(4)) SWIG_fail;
38609 }
38610 {
38611 arg5 = (int)(SWIG_As_int(obj4));
38612 if (SWIG_arg_fail(5)) SWIG_fail;
38613 }
38614 {
38615 PyThreadState* __tstate = wxPyBeginAllowThreads();
38616 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
38617
38618 wxPyEndAllowThreads(__tstate);
38619 if (PyErr_Occurred()) SWIG_fail;
38620 }
38621 Py_INCREF(Py_None); resultobj = Py_None;
38622 return resultobj;
38623 fail:
38624 return NULL;
38625 }
38626
38627
38628 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38629 PyObject *resultobj;
38630 wxSizer *arg1 = (wxSizer *) 0 ;
38631 wxSize *arg2 = 0 ;
38632 wxSize temp2 ;
38633 PyObject * obj0 = 0 ;
38634 PyObject * obj1 = 0 ;
38635 char *kwnames[] = {
38636 (char *) "self",(char *) "size", NULL
38637 };
38638
38639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
38640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38641 if (SWIG_arg_fail(1)) SWIG_fail;
38642 {
38643 arg2 = &temp2;
38644 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38645 }
38646 {
38647 PyThreadState* __tstate = wxPyBeginAllowThreads();
38648 (arg1)->SetMinSize((wxSize const &)*arg2);
38649
38650 wxPyEndAllowThreads(__tstate);
38651 if (PyErr_Occurred()) SWIG_fail;
38652 }
38653 Py_INCREF(Py_None); resultobj = Py_None;
38654 return resultobj;
38655 fail:
38656 return NULL;
38657 }
38658
38659
38660 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38661 PyObject *resultobj;
38662 wxSizer *arg1 = (wxSizer *) 0 ;
38663 wxSize result;
38664 PyObject * obj0 = 0 ;
38665 char *kwnames[] = {
38666 (char *) "self", NULL
38667 };
38668
38669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
38670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38671 if (SWIG_arg_fail(1)) SWIG_fail;
38672 {
38673 PyThreadState* __tstate = wxPyBeginAllowThreads();
38674 result = (arg1)->GetSize();
38675
38676 wxPyEndAllowThreads(__tstate);
38677 if (PyErr_Occurred()) SWIG_fail;
38678 }
38679 {
38680 wxSize * resultptr;
38681 resultptr = new wxSize((wxSize &)(result));
38682 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38683 }
38684 return resultobj;
38685 fail:
38686 return NULL;
38687 }
38688
38689
38690 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38691 PyObject *resultobj;
38692 wxSizer *arg1 = (wxSizer *) 0 ;
38693 wxPoint result;
38694 PyObject * obj0 = 0 ;
38695 char *kwnames[] = {
38696 (char *) "self", NULL
38697 };
38698
38699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
38700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38701 if (SWIG_arg_fail(1)) SWIG_fail;
38702 {
38703 PyThreadState* __tstate = wxPyBeginAllowThreads();
38704 result = (arg1)->GetPosition();
38705
38706 wxPyEndAllowThreads(__tstate);
38707 if (PyErr_Occurred()) SWIG_fail;
38708 }
38709 {
38710 wxPoint * resultptr;
38711 resultptr = new wxPoint((wxPoint &)(result));
38712 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38713 }
38714 return resultobj;
38715 fail:
38716 return NULL;
38717 }
38718
38719
38720 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38721 PyObject *resultobj;
38722 wxSizer *arg1 = (wxSizer *) 0 ;
38723 wxSize result;
38724 PyObject * obj0 = 0 ;
38725 char *kwnames[] = {
38726 (char *) "self", NULL
38727 };
38728
38729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
38730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38731 if (SWIG_arg_fail(1)) SWIG_fail;
38732 {
38733 PyThreadState* __tstate = wxPyBeginAllowThreads();
38734 result = (arg1)->GetMinSize();
38735
38736 wxPyEndAllowThreads(__tstate);
38737 if (PyErr_Occurred()) SWIG_fail;
38738 }
38739 {
38740 wxSize * resultptr;
38741 resultptr = new wxSize((wxSize &)(result));
38742 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38743 }
38744 return resultobj;
38745 fail:
38746 return NULL;
38747 }
38748
38749
38750 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
38751 PyObject *resultobj;
38752 wxSizer *arg1 = (wxSizer *) 0 ;
38753 PyObject * obj0 = 0 ;
38754 char *kwnames[] = {
38755 (char *) "self", NULL
38756 };
38757
38758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
38759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38760 if (SWIG_arg_fail(1)) SWIG_fail;
38761 {
38762 PyThreadState* __tstate = wxPyBeginAllowThreads();
38763 (arg1)->RecalcSizes();
38764
38765 wxPyEndAllowThreads(__tstate);
38766 if (PyErr_Occurred()) SWIG_fail;
38767 }
38768 Py_INCREF(Py_None); resultobj = Py_None;
38769 return resultobj;
38770 fail:
38771 return NULL;
38772 }
38773
38774
38775 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38776 PyObject *resultobj;
38777 wxSizer *arg1 = (wxSizer *) 0 ;
38778 wxSize result;
38779 PyObject * obj0 = 0 ;
38780 char *kwnames[] = {
38781 (char *) "self", NULL
38782 };
38783
38784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
38785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38786 if (SWIG_arg_fail(1)) SWIG_fail;
38787 {
38788 PyThreadState* __tstate = wxPyBeginAllowThreads();
38789 result = (arg1)->CalcMin();
38790
38791 wxPyEndAllowThreads(__tstate);
38792 if (PyErr_Occurred()) SWIG_fail;
38793 }
38794 {
38795 wxSize * resultptr;
38796 resultptr = new wxSize((wxSize &)(result));
38797 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38798 }
38799 return resultobj;
38800 fail:
38801 return NULL;
38802 }
38803
38804
38805 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
38806 PyObject *resultobj;
38807 wxSizer *arg1 = (wxSizer *) 0 ;
38808 PyObject * obj0 = 0 ;
38809 char *kwnames[] = {
38810 (char *) "self", NULL
38811 };
38812
38813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
38814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38815 if (SWIG_arg_fail(1)) SWIG_fail;
38816 {
38817 PyThreadState* __tstate = wxPyBeginAllowThreads();
38818 (arg1)->Layout();
38819
38820 wxPyEndAllowThreads(__tstate);
38821 if (PyErr_Occurred()) SWIG_fail;
38822 }
38823 Py_INCREF(Py_None); resultobj = Py_None;
38824 return resultobj;
38825 fail:
38826 return NULL;
38827 }
38828
38829
38830 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
38831 PyObject *resultobj;
38832 wxSizer *arg1 = (wxSizer *) 0 ;
38833 wxWindow *arg2 = (wxWindow *) 0 ;
38834 wxSize result;
38835 PyObject * obj0 = 0 ;
38836 PyObject * obj1 = 0 ;
38837 char *kwnames[] = {
38838 (char *) "self",(char *) "window", NULL
38839 };
38840
38841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
38842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38843 if (SWIG_arg_fail(1)) SWIG_fail;
38844 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38845 if (SWIG_arg_fail(2)) SWIG_fail;
38846 {
38847 PyThreadState* __tstate = wxPyBeginAllowThreads();
38848 result = (arg1)->Fit(arg2);
38849
38850 wxPyEndAllowThreads(__tstate);
38851 if (PyErr_Occurred()) SWIG_fail;
38852 }
38853 {
38854 wxSize * resultptr;
38855 resultptr = new wxSize((wxSize &)(result));
38856 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38857 }
38858 return resultobj;
38859 fail:
38860 return NULL;
38861 }
38862
38863
38864 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
38865 PyObject *resultobj;
38866 wxSizer *arg1 = (wxSizer *) 0 ;
38867 wxWindow *arg2 = (wxWindow *) 0 ;
38868 PyObject * obj0 = 0 ;
38869 PyObject * obj1 = 0 ;
38870 char *kwnames[] = {
38871 (char *) "self",(char *) "window", NULL
38872 };
38873
38874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
38875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38876 if (SWIG_arg_fail(1)) SWIG_fail;
38877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38878 if (SWIG_arg_fail(2)) SWIG_fail;
38879 {
38880 PyThreadState* __tstate = wxPyBeginAllowThreads();
38881 (arg1)->FitInside(arg2);
38882
38883 wxPyEndAllowThreads(__tstate);
38884 if (PyErr_Occurred()) SWIG_fail;
38885 }
38886 Py_INCREF(Py_None); resultobj = Py_None;
38887 return resultobj;
38888 fail:
38889 return NULL;
38890 }
38891
38892
38893 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
38894 PyObject *resultobj;
38895 wxSizer *arg1 = (wxSizer *) 0 ;
38896 wxWindow *arg2 = (wxWindow *) 0 ;
38897 PyObject * obj0 = 0 ;
38898 PyObject * obj1 = 0 ;
38899 char *kwnames[] = {
38900 (char *) "self",(char *) "window", NULL
38901 };
38902
38903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
38904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38905 if (SWIG_arg_fail(1)) SWIG_fail;
38906 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38907 if (SWIG_arg_fail(2)) SWIG_fail;
38908 {
38909 PyThreadState* __tstate = wxPyBeginAllowThreads();
38910 (arg1)->SetSizeHints(arg2);
38911
38912 wxPyEndAllowThreads(__tstate);
38913 if (PyErr_Occurred()) SWIG_fail;
38914 }
38915 Py_INCREF(Py_None); resultobj = Py_None;
38916 return resultobj;
38917 fail:
38918 return NULL;
38919 }
38920
38921
38922 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
38923 PyObject *resultobj;
38924 wxSizer *arg1 = (wxSizer *) 0 ;
38925 wxWindow *arg2 = (wxWindow *) 0 ;
38926 PyObject * obj0 = 0 ;
38927 PyObject * obj1 = 0 ;
38928 char *kwnames[] = {
38929 (char *) "self",(char *) "window", NULL
38930 };
38931
38932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
38933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38934 if (SWIG_arg_fail(1)) SWIG_fail;
38935 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38936 if (SWIG_arg_fail(2)) SWIG_fail;
38937 {
38938 PyThreadState* __tstate = wxPyBeginAllowThreads();
38939 (arg1)->SetVirtualSizeHints(arg2);
38940
38941 wxPyEndAllowThreads(__tstate);
38942 if (PyErr_Occurred()) SWIG_fail;
38943 }
38944 Py_INCREF(Py_None); resultobj = Py_None;
38945 return resultobj;
38946 fail:
38947 return NULL;
38948 }
38949
38950
38951 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38952 PyObject *resultobj;
38953 wxSizer *arg1 = (wxSizer *) 0 ;
38954 bool arg2 = (bool) false ;
38955 PyObject * obj0 = 0 ;
38956 PyObject * obj1 = 0 ;
38957 char *kwnames[] = {
38958 (char *) "self",(char *) "deleteWindows", NULL
38959 };
38960
38961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
38962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38963 if (SWIG_arg_fail(1)) SWIG_fail;
38964 if (obj1) {
38965 {
38966 arg2 = (bool)(SWIG_As_bool(obj1));
38967 if (SWIG_arg_fail(2)) SWIG_fail;
38968 }
38969 }
38970 {
38971 PyThreadState* __tstate = wxPyBeginAllowThreads();
38972 (arg1)->Clear(arg2);
38973
38974 wxPyEndAllowThreads(__tstate);
38975 if (PyErr_Occurred()) SWIG_fail;
38976 }
38977 Py_INCREF(Py_None); resultobj = Py_None;
38978 return resultobj;
38979 fail:
38980 return NULL;
38981 }
38982
38983
38984 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38985 PyObject *resultobj;
38986 wxSizer *arg1 = (wxSizer *) 0 ;
38987 PyObject * obj0 = 0 ;
38988 char *kwnames[] = {
38989 (char *) "self", NULL
38990 };
38991
38992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
38993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38994 if (SWIG_arg_fail(1)) SWIG_fail;
38995 {
38996 PyThreadState* __tstate = wxPyBeginAllowThreads();
38997 (arg1)->DeleteWindows();
38998
38999 wxPyEndAllowThreads(__tstate);
39000 if (PyErr_Occurred()) SWIG_fail;
39001 }
39002 Py_INCREF(Py_None); resultobj = Py_None;
39003 return resultobj;
39004 fail:
39005 return NULL;
39006 }
39007
39008
39009 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39010 PyObject *resultobj;
39011 wxSizer *arg1 = (wxSizer *) 0 ;
39012 PyObject *result;
39013 PyObject * obj0 = 0 ;
39014 char *kwnames[] = {
39015 (char *) "self", NULL
39016 };
39017
39018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39020 if (SWIG_arg_fail(1)) SWIG_fail;
39021 {
39022 PyThreadState* __tstate = wxPyBeginAllowThreads();
39023 result = (PyObject *)wxSizer_GetChildren(arg1);
39024
39025 wxPyEndAllowThreads(__tstate);
39026 if (PyErr_Occurred()) SWIG_fail;
39027 }
39028 resultobj = result;
39029 return resultobj;
39030 fail:
39031 return NULL;
39032 }
39033
39034
39035 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39036 PyObject *resultobj;
39037 wxSizer *arg1 = (wxSizer *) 0 ;
39038 PyObject *arg2 = (PyObject *) 0 ;
39039 bool arg3 = (bool) true ;
39040 bool arg4 = (bool) false ;
39041 bool result;
39042 PyObject * obj0 = 0 ;
39043 PyObject * obj1 = 0 ;
39044 PyObject * obj2 = 0 ;
39045 PyObject * obj3 = 0 ;
39046 char *kwnames[] = {
39047 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39048 };
39049
39050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39052 if (SWIG_arg_fail(1)) SWIG_fail;
39053 arg2 = obj1;
39054 if (obj2) {
39055 {
39056 arg3 = (bool)(SWIG_As_bool(obj2));
39057 if (SWIG_arg_fail(3)) SWIG_fail;
39058 }
39059 }
39060 if (obj3) {
39061 {
39062 arg4 = (bool)(SWIG_As_bool(obj3));
39063 if (SWIG_arg_fail(4)) SWIG_fail;
39064 }
39065 }
39066 {
39067 PyThreadState* __tstate = wxPyBeginAllowThreads();
39068 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39069
39070 wxPyEndAllowThreads(__tstate);
39071 if (PyErr_Occurred()) SWIG_fail;
39072 }
39073 {
39074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39075 }
39076 return resultobj;
39077 fail:
39078 return NULL;
39079 }
39080
39081
39082 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39083 PyObject *resultobj;
39084 wxSizer *arg1 = (wxSizer *) 0 ;
39085 PyObject *arg2 = (PyObject *) 0 ;
39086 bool result;
39087 PyObject * obj0 = 0 ;
39088 PyObject * obj1 = 0 ;
39089 char *kwnames[] = {
39090 (char *) "self",(char *) "item", NULL
39091 };
39092
39093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39095 if (SWIG_arg_fail(1)) SWIG_fail;
39096 arg2 = obj1;
39097 {
39098 PyThreadState* __tstate = wxPyBeginAllowThreads();
39099 result = (bool)wxSizer_IsShown(arg1,arg2);
39100
39101 wxPyEndAllowThreads(__tstate);
39102 if (PyErr_Occurred()) SWIG_fail;
39103 }
39104 {
39105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39106 }
39107 return resultobj;
39108 fail:
39109 return NULL;
39110 }
39111
39112
39113 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39114 PyObject *resultobj;
39115 wxSizer *arg1 = (wxSizer *) 0 ;
39116 bool arg2 ;
39117 PyObject * obj0 = 0 ;
39118 PyObject * obj1 = 0 ;
39119 char *kwnames[] = {
39120 (char *) "self",(char *) "show", NULL
39121 };
39122
39123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39125 if (SWIG_arg_fail(1)) SWIG_fail;
39126 {
39127 arg2 = (bool)(SWIG_As_bool(obj1));
39128 if (SWIG_arg_fail(2)) SWIG_fail;
39129 }
39130 {
39131 PyThreadState* __tstate = wxPyBeginAllowThreads();
39132 (arg1)->ShowItems(arg2);
39133
39134 wxPyEndAllowThreads(__tstate);
39135 if (PyErr_Occurred()) SWIG_fail;
39136 }
39137 Py_INCREF(Py_None); resultobj = Py_None;
39138 return resultobj;
39139 fail:
39140 return NULL;
39141 }
39142
39143
39144 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39145 PyObject *obj;
39146 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39147 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39148 Py_INCREF(obj);
39149 return Py_BuildValue((char *)"");
39150 }
39151 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39152 PyObject *resultobj;
39153 wxPySizer *result;
39154 char *kwnames[] = {
39155 NULL
39156 };
39157
39158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39159 {
39160 PyThreadState* __tstate = wxPyBeginAllowThreads();
39161 result = (wxPySizer *)new wxPySizer();
39162
39163 wxPyEndAllowThreads(__tstate);
39164 if (PyErr_Occurred()) SWIG_fail;
39165 }
39166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39167 return resultobj;
39168 fail:
39169 return NULL;
39170 }
39171
39172
39173 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39174 PyObject *resultobj;
39175 wxPySizer *arg1 = (wxPySizer *) 0 ;
39176 PyObject *arg2 = (PyObject *) 0 ;
39177 PyObject *arg3 = (PyObject *) 0 ;
39178 PyObject * obj0 = 0 ;
39179 PyObject * obj1 = 0 ;
39180 PyObject * obj2 = 0 ;
39181 char *kwnames[] = {
39182 (char *) "self",(char *) "self",(char *) "_class", NULL
39183 };
39184
39185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
39186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
39187 if (SWIG_arg_fail(1)) SWIG_fail;
39188 arg2 = obj1;
39189 arg3 = obj2;
39190 {
39191 PyThreadState* __tstate = wxPyBeginAllowThreads();
39192 (arg1)->_setCallbackInfo(arg2,arg3);
39193
39194 wxPyEndAllowThreads(__tstate);
39195 if (PyErr_Occurred()) SWIG_fail;
39196 }
39197 Py_INCREF(Py_None); resultobj = Py_None;
39198 return resultobj;
39199 fail:
39200 return NULL;
39201 }
39202
39203
39204 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
39205 PyObject *obj;
39206 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39207 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
39208 Py_INCREF(obj);
39209 return Py_BuildValue((char *)"");
39210 }
39211 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39212 PyObject *resultobj;
39213 int arg1 = (int) wxHORIZONTAL ;
39214 wxBoxSizer *result;
39215 PyObject * obj0 = 0 ;
39216 char *kwnames[] = {
39217 (char *) "orient", NULL
39218 };
39219
39220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
39221 if (obj0) {
39222 {
39223 arg1 = (int)(SWIG_As_int(obj0));
39224 if (SWIG_arg_fail(1)) SWIG_fail;
39225 }
39226 }
39227 {
39228 PyThreadState* __tstate = wxPyBeginAllowThreads();
39229 result = (wxBoxSizer *)new wxBoxSizer(arg1);
39230
39231 wxPyEndAllowThreads(__tstate);
39232 if (PyErr_Occurred()) SWIG_fail;
39233 }
39234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
39235 return resultobj;
39236 fail:
39237 return NULL;
39238 }
39239
39240
39241 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39242 PyObject *resultobj;
39243 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39244 int result;
39245 PyObject * obj0 = 0 ;
39246 char *kwnames[] = {
39247 (char *) "self", NULL
39248 };
39249
39250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
39251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39252 if (SWIG_arg_fail(1)) SWIG_fail;
39253 {
39254 PyThreadState* __tstate = wxPyBeginAllowThreads();
39255 result = (int)(arg1)->GetOrientation();
39256
39257 wxPyEndAllowThreads(__tstate);
39258 if (PyErr_Occurred()) SWIG_fail;
39259 }
39260 {
39261 resultobj = SWIG_From_int((int)(result));
39262 }
39263 return resultobj;
39264 fail:
39265 return NULL;
39266 }
39267
39268
39269 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39270 PyObject *resultobj;
39271 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39272 int arg2 ;
39273 PyObject * obj0 = 0 ;
39274 PyObject * obj1 = 0 ;
39275 char *kwnames[] = {
39276 (char *) "self",(char *) "orient", NULL
39277 };
39278
39279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
39280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39281 if (SWIG_arg_fail(1)) SWIG_fail;
39282 {
39283 arg2 = (int)(SWIG_As_int(obj1));
39284 if (SWIG_arg_fail(2)) SWIG_fail;
39285 }
39286 {
39287 PyThreadState* __tstate = wxPyBeginAllowThreads();
39288 (arg1)->SetOrientation(arg2);
39289
39290 wxPyEndAllowThreads(__tstate);
39291 if (PyErr_Occurred()) SWIG_fail;
39292 }
39293 Py_INCREF(Py_None); resultobj = Py_None;
39294 return resultobj;
39295 fail:
39296 return NULL;
39297 }
39298
39299
39300 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
39301 PyObject *obj;
39302 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39303 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
39304 Py_INCREF(obj);
39305 return Py_BuildValue((char *)"");
39306 }
39307 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39308 PyObject *resultobj;
39309 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
39310 int arg2 = (int) wxHORIZONTAL ;
39311 wxStaticBoxSizer *result;
39312 PyObject * obj0 = 0 ;
39313 PyObject * obj1 = 0 ;
39314 char *kwnames[] = {
39315 (char *) "box",(char *) "orient", NULL
39316 };
39317
39318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
39319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
39320 if (SWIG_arg_fail(1)) SWIG_fail;
39321 if (obj1) {
39322 {
39323 arg2 = (int)(SWIG_As_int(obj1));
39324 if (SWIG_arg_fail(2)) SWIG_fail;
39325 }
39326 }
39327 {
39328 PyThreadState* __tstate = wxPyBeginAllowThreads();
39329 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
39330
39331 wxPyEndAllowThreads(__tstate);
39332 if (PyErr_Occurred()) SWIG_fail;
39333 }
39334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
39335 return resultobj;
39336 fail:
39337 return NULL;
39338 }
39339
39340
39341 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
39342 PyObject *resultobj;
39343 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
39344 wxStaticBox *result;
39345 PyObject * obj0 = 0 ;
39346 char *kwnames[] = {
39347 (char *) "self", NULL
39348 };
39349
39350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
39351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39352 if (SWIG_arg_fail(1)) SWIG_fail;
39353 {
39354 PyThreadState* __tstate = wxPyBeginAllowThreads();
39355 result = (wxStaticBox *)(arg1)->GetStaticBox();
39356
39357 wxPyEndAllowThreads(__tstate);
39358 if (PyErr_Occurred()) SWIG_fail;
39359 }
39360 {
39361 resultobj = wxPyMake_wxObject(result, 0);
39362 }
39363 return resultobj;
39364 fail:
39365 return NULL;
39366 }
39367
39368
39369 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
39370 PyObject *obj;
39371 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39372 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
39373 Py_INCREF(obj);
39374 return Py_BuildValue((char *)"");
39375 }
39376 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39377 PyObject *resultobj;
39378 int arg1 = (int) 1 ;
39379 int arg2 = (int) 0 ;
39380 int arg3 = (int) 0 ;
39381 int arg4 = (int) 0 ;
39382 wxGridSizer *result;
39383 PyObject * obj0 = 0 ;
39384 PyObject * obj1 = 0 ;
39385 PyObject * obj2 = 0 ;
39386 PyObject * obj3 = 0 ;
39387 char *kwnames[] = {
39388 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39389 };
39390
39391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39392 if (obj0) {
39393 {
39394 arg1 = (int)(SWIG_As_int(obj0));
39395 if (SWIG_arg_fail(1)) SWIG_fail;
39396 }
39397 }
39398 if (obj1) {
39399 {
39400 arg2 = (int)(SWIG_As_int(obj1));
39401 if (SWIG_arg_fail(2)) SWIG_fail;
39402 }
39403 }
39404 if (obj2) {
39405 {
39406 arg3 = (int)(SWIG_As_int(obj2));
39407 if (SWIG_arg_fail(3)) SWIG_fail;
39408 }
39409 }
39410 if (obj3) {
39411 {
39412 arg4 = (int)(SWIG_As_int(obj3));
39413 if (SWIG_arg_fail(4)) SWIG_fail;
39414 }
39415 }
39416 {
39417 PyThreadState* __tstate = wxPyBeginAllowThreads();
39418 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
39419
39420 wxPyEndAllowThreads(__tstate);
39421 if (PyErr_Occurred()) SWIG_fail;
39422 }
39423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
39424 return resultobj;
39425 fail:
39426 return NULL;
39427 }
39428
39429
39430 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39431 PyObject *resultobj;
39432 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39433 int arg2 ;
39434 PyObject * obj0 = 0 ;
39435 PyObject * obj1 = 0 ;
39436 char *kwnames[] = {
39437 (char *) "self",(char *) "cols", NULL
39438 };
39439
39440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
39441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39442 if (SWIG_arg_fail(1)) SWIG_fail;
39443 {
39444 arg2 = (int)(SWIG_As_int(obj1));
39445 if (SWIG_arg_fail(2)) SWIG_fail;
39446 }
39447 {
39448 PyThreadState* __tstate = wxPyBeginAllowThreads();
39449 (arg1)->SetCols(arg2);
39450
39451 wxPyEndAllowThreads(__tstate);
39452 if (PyErr_Occurred()) SWIG_fail;
39453 }
39454 Py_INCREF(Py_None); resultobj = Py_None;
39455 return resultobj;
39456 fail:
39457 return NULL;
39458 }
39459
39460
39461 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39462 PyObject *resultobj;
39463 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39464 int arg2 ;
39465 PyObject * obj0 = 0 ;
39466 PyObject * obj1 = 0 ;
39467 char *kwnames[] = {
39468 (char *) "self",(char *) "rows", NULL
39469 };
39470
39471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
39472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39473 if (SWIG_arg_fail(1)) SWIG_fail;
39474 {
39475 arg2 = (int)(SWIG_As_int(obj1));
39476 if (SWIG_arg_fail(2)) SWIG_fail;
39477 }
39478 {
39479 PyThreadState* __tstate = wxPyBeginAllowThreads();
39480 (arg1)->SetRows(arg2);
39481
39482 wxPyEndAllowThreads(__tstate);
39483 if (PyErr_Occurred()) SWIG_fail;
39484 }
39485 Py_INCREF(Py_None); resultobj = Py_None;
39486 return resultobj;
39487 fail:
39488 return NULL;
39489 }
39490
39491
39492 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39493 PyObject *resultobj;
39494 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39495 int arg2 ;
39496 PyObject * obj0 = 0 ;
39497 PyObject * obj1 = 0 ;
39498 char *kwnames[] = {
39499 (char *) "self",(char *) "gap", NULL
39500 };
39501
39502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
39503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39504 if (SWIG_arg_fail(1)) SWIG_fail;
39505 {
39506 arg2 = (int)(SWIG_As_int(obj1));
39507 if (SWIG_arg_fail(2)) SWIG_fail;
39508 }
39509 {
39510 PyThreadState* __tstate = wxPyBeginAllowThreads();
39511 (arg1)->SetVGap(arg2);
39512
39513 wxPyEndAllowThreads(__tstate);
39514 if (PyErr_Occurred()) SWIG_fail;
39515 }
39516 Py_INCREF(Py_None); resultobj = Py_None;
39517 return resultobj;
39518 fail:
39519 return NULL;
39520 }
39521
39522
39523 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39524 PyObject *resultobj;
39525 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39526 int arg2 ;
39527 PyObject * obj0 = 0 ;
39528 PyObject * obj1 = 0 ;
39529 char *kwnames[] = {
39530 (char *) "self",(char *) "gap", NULL
39531 };
39532
39533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
39534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39535 if (SWIG_arg_fail(1)) SWIG_fail;
39536 {
39537 arg2 = (int)(SWIG_As_int(obj1));
39538 if (SWIG_arg_fail(2)) SWIG_fail;
39539 }
39540 {
39541 PyThreadState* __tstate = wxPyBeginAllowThreads();
39542 (arg1)->SetHGap(arg2);
39543
39544 wxPyEndAllowThreads(__tstate);
39545 if (PyErr_Occurred()) SWIG_fail;
39546 }
39547 Py_INCREF(Py_None); resultobj = Py_None;
39548 return resultobj;
39549 fail:
39550 return NULL;
39551 }
39552
39553
39554 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39555 PyObject *resultobj;
39556 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39557 int result;
39558 PyObject * obj0 = 0 ;
39559 char *kwnames[] = {
39560 (char *) "self", NULL
39561 };
39562
39563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
39564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39565 if (SWIG_arg_fail(1)) SWIG_fail;
39566 {
39567 PyThreadState* __tstate = wxPyBeginAllowThreads();
39568 result = (int)(arg1)->GetCols();
39569
39570 wxPyEndAllowThreads(__tstate);
39571 if (PyErr_Occurred()) SWIG_fail;
39572 }
39573 {
39574 resultobj = SWIG_From_int((int)(result));
39575 }
39576 return resultobj;
39577 fail:
39578 return NULL;
39579 }
39580
39581
39582 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39583 PyObject *resultobj;
39584 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39585 int result;
39586 PyObject * obj0 = 0 ;
39587 char *kwnames[] = {
39588 (char *) "self", NULL
39589 };
39590
39591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
39592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39593 if (SWIG_arg_fail(1)) SWIG_fail;
39594 {
39595 PyThreadState* __tstate = wxPyBeginAllowThreads();
39596 result = (int)(arg1)->GetRows();
39597
39598 wxPyEndAllowThreads(__tstate);
39599 if (PyErr_Occurred()) SWIG_fail;
39600 }
39601 {
39602 resultobj = SWIG_From_int((int)(result));
39603 }
39604 return resultobj;
39605 fail:
39606 return NULL;
39607 }
39608
39609
39610 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39611 PyObject *resultobj;
39612 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39613 int result;
39614 PyObject * obj0 = 0 ;
39615 char *kwnames[] = {
39616 (char *) "self", NULL
39617 };
39618
39619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
39620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39621 if (SWIG_arg_fail(1)) SWIG_fail;
39622 {
39623 PyThreadState* __tstate = wxPyBeginAllowThreads();
39624 result = (int)(arg1)->GetVGap();
39625
39626 wxPyEndAllowThreads(__tstate);
39627 if (PyErr_Occurred()) SWIG_fail;
39628 }
39629 {
39630 resultobj = SWIG_From_int((int)(result));
39631 }
39632 return resultobj;
39633 fail:
39634 return NULL;
39635 }
39636
39637
39638 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39639 PyObject *resultobj;
39640 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39641 int result;
39642 PyObject * obj0 = 0 ;
39643 char *kwnames[] = {
39644 (char *) "self", NULL
39645 };
39646
39647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
39648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39649 if (SWIG_arg_fail(1)) SWIG_fail;
39650 {
39651 PyThreadState* __tstate = wxPyBeginAllowThreads();
39652 result = (int)(arg1)->GetHGap();
39653
39654 wxPyEndAllowThreads(__tstate);
39655 if (PyErr_Occurred()) SWIG_fail;
39656 }
39657 {
39658 resultobj = SWIG_From_int((int)(result));
39659 }
39660 return resultobj;
39661 fail:
39662 return NULL;
39663 }
39664
39665
39666 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
39667 PyObject *obj;
39668 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39669 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
39670 Py_INCREF(obj);
39671 return Py_BuildValue((char *)"");
39672 }
39673 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39674 PyObject *resultobj;
39675 int arg1 = (int) 1 ;
39676 int arg2 = (int) 0 ;
39677 int arg3 = (int) 0 ;
39678 int arg4 = (int) 0 ;
39679 wxFlexGridSizer *result;
39680 PyObject * obj0 = 0 ;
39681 PyObject * obj1 = 0 ;
39682 PyObject * obj2 = 0 ;
39683 PyObject * obj3 = 0 ;
39684 char *kwnames[] = {
39685 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39686 };
39687
39688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39689 if (obj0) {
39690 {
39691 arg1 = (int)(SWIG_As_int(obj0));
39692 if (SWIG_arg_fail(1)) SWIG_fail;
39693 }
39694 }
39695 if (obj1) {
39696 {
39697 arg2 = (int)(SWIG_As_int(obj1));
39698 if (SWIG_arg_fail(2)) SWIG_fail;
39699 }
39700 }
39701 if (obj2) {
39702 {
39703 arg3 = (int)(SWIG_As_int(obj2));
39704 if (SWIG_arg_fail(3)) SWIG_fail;
39705 }
39706 }
39707 if (obj3) {
39708 {
39709 arg4 = (int)(SWIG_As_int(obj3));
39710 if (SWIG_arg_fail(4)) SWIG_fail;
39711 }
39712 }
39713 {
39714 PyThreadState* __tstate = wxPyBeginAllowThreads();
39715 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
39716
39717 wxPyEndAllowThreads(__tstate);
39718 if (PyErr_Occurred()) SWIG_fail;
39719 }
39720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
39721 return resultobj;
39722 fail:
39723 return NULL;
39724 }
39725
39726
39727 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39728 PyObject *resultobj;
39729 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39730 size_t arg2 ;
39731 int arg3 = (int) 0 ;
39732 PyObject * obj0 = 0 ;
39733 PyObject * obj1 = 0 ;
39734 PyObject * obj2 = 0 ;
39735 char *kwnames[] = {
39736 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39737 };
39738
39739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
39740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39741 if (SWIG_arg_fail(1)) SWIG_fail;
39742 {
39743 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39744 if (SWIG_arg_fail(2)) SWIG_fail;
39745 }
39746 if (obj2) {
39747 {
39748 arg3 = (int)(SWIG_As_int(obj2));
39749 if (SWIG_arg_fail(3)) SWIG_fail;
39750 }
39751 }
39752 {
39753 PyThreadState* __tstate = wxPyBeginAllowThreads();
39754 (arg1)->AddGrowableRow(arg2,arg3);
39755
39756 wxPyEndAllowThreads(__tstate);
39757 if (PyErr_Occurred()) SWIG_fail;
39758 }
39759 Py_INCREF(Py_None); resultobj = Py_None;
39760 return resultobj;
39761 fail:
39762 return NULL;
39763 }
39764
39765
39766 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39767 PyObject *resultobj;
39768 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39769 size_t arg2 ;
39770 PyObject * obj0 = 0 ;
39771 PyObject * obj1 = 0 ;
39772 char *kwnames[] = {
39773 (char *) "self",(char *) "idx", NULL
39774 };
39775
39776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
39777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39778 if (SWIG_arg_fail(1)) SWIG_fail;
39779 {
39780 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39781 if (SWIG_arg_fail(2)) SWIG_fail;
39782 }
39783 {
39784 PyThreadState* __tstate = wxPyBeginAllowThreads();
39785 (arg1)->RemoveGrowableRow(arg2);
39786
39787 wxPyEndAllowThreads(__tstate);
39788 if (PyErr_Occurred()) SWIG_fail;
39789 }
39790 Py_INCREF(Py_None); resultobj = Py_None;
39791 return resultobj;
39792 fail:
39793 return NULL;
39794 }
39795
39796
39797 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
39798 PyObject *resultobj;
39799 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39800 size_t arg2 ;
39801 int arg3 = (int) 0 ;
39802 PyObject * obj0 = 0 ;
39803 PyObject * obj1 = 0 ;
39804 PyObject * obj2 = 0 ;
39805 char *kwnames[] = {
39806 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39807 };
39808
39809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
39810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39811 if (SWIG_arg_fail(1)) SWIG_fail;
39812 {
39813 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39814 if (SWIG_arg_fail(2)) SWIG_fail;
39815 }
39816 if (obj2) {
39817 {
39818 arg3 = (int)(SWIG_As_int(obj2));
39819 if (SWIG_arg_fail(3)) SWIG_fail;
39820 }
39821 }
39822 {
39823 PyThreadState* __tstate = wxPyBeginAllowThreads();
39824 (arg1)->AddGrowableCol(arg2,arg3);
39825
39826 wxPyEndAllowThreads(__tstate);
39827 if (PyErr_Occurred()) SWIG_fail;
39828 }
39829 Py_INCREF(Py_None); resultobj = Py_None;
39830 return resultobj;
39831 fail:
39832 return NULL;
39833 }
39834
39835
39836 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
39837 PyObject *resultobj;
39838 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39839 size_t arg2 ;
39840 PyObject * obj0 = 0 ;
39841 PyObject * obj1 = 0 ;
39842 char *kwnames[] = {
39843 (char *) "self",(char *) "idx", NULL
39844 };
39845
39846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
39847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39848 if (SWIG_arg_fail(1)) SWIG_fail;
39849 {
39850 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39851 if (SWIG_arg_fail(2)) SWIG_fail;
39852 }
39853 {
39854 PyThreadState* __tstate = wxPyBeginAllowThreads();
39855 (arg1)->RemoveGrowableCol(arg2);
39856
39857 wxPyEndAllowThreads(__tstate);
39858 if (PyErr_Occurred()) SWIG_fail;
39859 }
39860 Py_INCREF(Py_None); resultobj = Py_None;
39861 return resultobj;
39862 fail:
39863 return NULL;
39864 }
39865
39866
39867 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
39868 PyObject *resultobj;
39869 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39870 int arg2 ;
39871 PyObject * obj0 = 0 ;
39872 PyObject * obj1 = 0 ;
39873 char *kwnames[] = {
39874 (char *) "self",(char *) "direction", NULL
39875 };
39876
39877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
39878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39879 if (SWIG_arg_fail(1)) SWIG_fail;
39880 {
39881 arg2 = (int)(SWIG_As_int(obj1));
39882 if (SWIG_arg_fail(2)) SWIG_fail;
39883 }
39884 {
39885 PyThreadState* __tstate = wxPyBeginAllowThreads();
39886 (arg1)->SetFlexibleDirection(arg2);
39887
39888 wxPyEndAllowThreads(__tstate);
39889 if (PyErr_Occurred()) SWIG_fail;
39890 }
39891 Py_INCREF(Py_None); resultobj = Py_None;
39892 return resultobj;
39893 fail:
39894 return NULL;
39895 }
39896
39897
39898 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
39899 PyObject *resultobj;
39900 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39901 int result;
39902 PyObject * obj0 = 0 ;
39903 char *kwnames[] = {
39904 (char *) "self", NULL
39905 };
39906
39907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
39908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39909 if (SWIG_arg_fail(1)) SWIG_fail;
39910 {
39911 PyThreadState* __tstate = wxPyBeginAllowThreads();
39912 result = (int)(arg1)->GetFlexibleDirection();
39913
39914 wxPyEndAllowThreads(__tstate);
39915 if (PyErr_Occurred()) SWIG_fail;
39916 }
39917 {
39918 resultobj = SWIG_From_int((int)(result));
39919 }
39920 return resultobj;
39921 fail:
39922 return NULL;
39923 }
39924
39925
39926 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
39927 PyObject *resultobj;
39928 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39929 wxFlexSizerGrowMode arg2 ;
39930 PyObject * obj0 = 0 ;
39931 PyObject * obj1 = 0 ;
39932 char *kwnames[] = {
39933 (char *) "self",(char *) "mode", NULL
39934 };
39935
39936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
39937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39938 if (SWIG_arg_fail(1)) SWIG_fail;
39939 {
39940 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
39941 if (SWIG_arg_fail(2)) SWIG_fail;
39942 }
39943 {
39944 PyThreadState* __tstate = wxPyBeginAllowThreads();
39945 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
39946
39947 wxPyEndAllowThreads(__tstate);
39948 if (PyErr_Occurred()) SWIG_fail;
39949 }
39950 Py_INCREF(Py_None); resultobj = Py_None;
39951 return resultobj;
39952 fail:
39953 return NULL;
39954 }
39955
39956
39957 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
39958 PyObject *resultobj;
39959 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39960 wxFlexSizerGrowMode result;
39961 PyObject * obj0 = 0 ;
39962 char *kwnames[] = {
39963 (char *) "self", NULL
39964 };
39965
39966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
39967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39968 if (SWIG_arg_fail(1)) SWIG_fail;
39969 {
39970 PyThreadState* __tstate = wxPyBeginAllowThreads();
39971 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
39972
39973 wxPyEndAllowThreads(__tstate);
39974 if (PyErr_Occurred()) SWIG_fail;
39975 }
39976 resultobj = SWIG_From_int((result));
39977 return resultobj;
39978 fail:
39979 return NULL;
39980 }
39981
39982
39983 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
39984 PyObject *resultobj;
39985 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39986 wxArrayInt *result;
39987 PyObject * obj0 = 0 ;
39988 char *kwnames[] = {
39989 (char *) "self", NULL
39990 };
39991
39992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
39993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39994 if (SWIG_arg_fail(1)) SWIG_fail;
39995 {
39996 PyThreadState* __tstate = wxPyBeginAllowThreads();
39997 {
39998 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
39999 result = (wxArrayInt *) &_result_ref;
40000 }
40001
40002 wxPyEndAllowThreads(__tstate);
40003 if (PyErr_Occurred()) SWIG_fail;
40004 }
40005 {
40006 resultobj = PyList_New(0);
40007 size_t idx;
40008 for (idx = 0; idx < result->GetCount(); idx += 1) {
40009 PyObject* val = PyInt_FromLong( result->Item(idx) );
40010 PyList_Append(resultobj, val);
40011 Py_DECREF(val);
40012 }
40013 }
40014 return resultobj;
40015 fail:
40016 return NULL;
40017 }
40018
40019
40020 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40021 PyObject *resultobj;
40022 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40023 wxArrayInt *result;
40024 PyObject * obj0 = 0 ;
40025 char *kwnames[] = {
40026 (char *) "self", NULL
40027 };
40028
40029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40031 if (SWIG_arg_fail(1)) SWIG_fail;
40032 {
40033 PyThreadState* __tstate = wxPyBeginAllowThreads();
40034 {
40035 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40036 result = (wxArrayInt *) &_result_ref;
40037 }
40038
40039 wxPyEndAllowThreads(__tstate);
40040 if (PyErr_Occurred()) SWIG_fail;
40041 }
40042 {
40043 resultobj = PyList_New(0);
40044 size_t idx;
40045 for (idx = 0; idx < result->GetCount(); idx += 1) {
40046 PyObject* val = PyInt_FromLong( result->Item(idx) );
40047 PyList_Append(resultobj, val);
40048 Py_DECREF(val);
40049 }
40050 }
40051 return resultobj;
40052 fail:
40053 return NULL;
40054 }
40055
40056
40057 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40058 PyObject *obj;
40059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40060 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40061 Py_INCREF(obj);
40062 return Py_BuildValue((char *)"");
40063 }
40064 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40065 PyObject *resultobj;
40066 wxStdDialogButtonSizer *result;
40067 char *kwnames[] = {
40068 NULL
40069 };
40070
40071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40072 {
40073 PyThreadState* __tstate = wxPyBeginAllowThreads();
40074 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40075
40076 wxPyEndAllowThreads(__tstate);
40077 if (PyErr_Occurred()) SWIG_fail;
40078 }
40079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40080 return resultobj;
40081 fail:
40082 return NULL;
40083 }
40084
40085
40086 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40087 PyObject *resultobj;
40088 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40089 wxButton *arg2 = (wxButton *) 0 ;
40090 PyObject * obj0 = 0 ;
40091 PyObject * obj1 = 0 ;
40092 char *kwnames[] = {
40093 (char *) "self",(char *) "button", NULL
40094 };
40095
40096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40098 if (SWIG_arg_fail(1)) SWIG_fail;
40099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40100 if (SWIG_arg_fail(2)) SWIG_fail;
40101 {
40102 PyThreadState* __tstate = wxPyBeginAllowThreads();
40103 (arg1)->AddButton(arg2);
40104
40105 wxPyEndAllowThreads(__tstate);
40106 if (PyErr_Occurred()) SWIG_fail;
40107 }
40108 Py_INCREF(Py_None); resultobj = Py_None;
40109 return resultobj;
40110 fail:
40111 return NULL;
40112 }
40113
40114
40115 static PyObject *_wrap_StdDialogButtonSizer_Finalise(PyObject *, PyObject *args, PyObject *kwargs) {
40116 PyObject *resultobj;
40117 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40118 PyObject * obj0 = 0 ;
40119 char *kwnames[] = {
40120 (char *) "self", NULL
40121 };
40122
40123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Finalise",kwnames,&obj0)) goto fail;
40124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40125 if (SWIG_arg_fail(1)) SWIG_fail;
40126 {
40127 PyThreadState* __tstate = wxPyBeginAllowThreads();
40128 (arg1)->Finalise();
40129
40130 wxPyEndAllowThreads(__tstate);
40131 if (PyErr_Occurred()) SWIG_fail;
40132 }
40133 Py_INCREF(Py_None); resultobj = Py_None;
40134 return resultobj;
40135 fail:
40136 return NULL;
40137 }
40138
40139
40140 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40141 PyObject *resultobj;
40142 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40143 wxButton *arg2 = (wxButton *) 0 ;
40144 PyObject * obj0 = 0 ;
40145 PyObject * obj1 = 0 ;
40146 char *kwnames[] = {
40147 (char *) "self",(char *) "button", NULL
40148 };
40149
40150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
40151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40152 if (SWIG_arg_fail(1)) SWIG_fail;
40153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40154 if (SWIG_arg_fail(2)) SWIG_fail;
40155 {
40156 PyThreadState* __tstate = wxPyBeginAllowThreads();
40157 (arg1)->SetAffirmativeButton(arg2);
40158
40159 wxPyEndAllowThreads(__tstate);
40160 if (PyErr_Occurred()) SWIG_fail;
40161 }
40162 Py_INCREF(Py_None); resultobj = Py_None;
40163 return resultobj;
40164 fail:
40165 return NULL;
40166 }
40167
40168
40169 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40170 PyObject *resultobj;
40171 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40172 wxButton *arg2 = (wxButton *) 0 ;
40173 PyObject * obj0 = 0 ;
40174 PyObject * obj1 = 0 ;
40175 char *kwnames[] = {
40176 (char *) "self",(char *) "button", NULL
40177 };
40178
40179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
40180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40181 if (SWIG_arg_fail(1)) SWIG_fail;
40182 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40183 if (SWIG_arg_fail(2)) SWIG_fail;
40184 {
40185 PyThreadState* __tstate = wxPyBeginAllowThreads();
40186 (arg1)->SetNegativeButton(arg2);
40187
40188 wxPyEndAllowThreads(__tstate);
40189 if (PyErr_Occurred()) SWIG_fail;
40190 }
40191 Py_INCREF(Py_None); resultobj = Py_None;
40192 return resultobj;
40193 fail:
40194 return NULL;
40195 }
40196
40197
40198 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40199 PyObject *resultobj;
40200 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40201 wxButton *arg2 = (wxButton *) 0 ;
40202 PyObject * obj0 = 0 ;
40203 PyObject * obj1 = 0 ;
40204 char *kwnames[] = {
40205 (char *) "self",(char *) "button", NULL
40206 };
40207
40208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
40209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40210 if (SWIG_arg_fail(1)) SWIG_fail;
40211 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40212 if (SWIG_arg_fail(2)) SWIG_fail;
40213 {
40214 PyThreadState* __tstate = wxPyBeginAllowThreads();
40215 (arg1)->SetCancelButton(arg2);
40216
40217 wxPyEndAllowThreads(__tstate);
40218 if (PyErr_Occurred()) SWIG_fail;
40219 }
40220 Py_INCREF(Py_None); resultobj = Py_None;
40221 return resultobj;
40222 fail:
40223 return NULL;
40224 }
40225
40226
40227 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40228 PyObject *resultobj;
40229 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40230 wxButton *result;
40231 PyObject * obj0 = 0 ;
40232 char *kwnames[] = {
40233 (char *) "self", NULL
40234 };
40235
40236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
40237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40238 if (SWIG_arg_fail(1)) SWIG_fail;
40239 {
40240 PyThreadState* __tstate = wxPyBeginAllowThreads();
40241 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
40242
40243 wxPyEndAllowThreads(__tstate);
40244 if (PyErr_Occurred()) SWIG_fail;
40245 }
40246 {
40247 resultobj = wxPyMake_wxObject(result, 0);
40248 }
40249 return resultobj;
40250 fail:
40251 return NULL;
40252 }
40253
40254
40255 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
40256 PyObject *resultobj;
40257 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40258 wxButton *result;
40259 PyObject * obj0 = 0 ;
40260 char *kwnames[] = {
40261 (char *) "self", NULL
40262 };
40263
40264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
40265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40266 if (SWIG_arg_fail(1)) SWIG_fail;
40267 {
40268 PyThreadState* __tstate = wxPyBeginAllowThreads();
40269 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
40270
40271 wxPyEndAllowThreads(__tstate);
40272 if (PyErr_Occurred()) SWIG_fail;
40273 }
40274 {
40275 resultobj = wxPyMake_wxObject(result, 0);
40276 }
40277 return resultobj;
40278 fail:
40279 return NULL;
40280 }
40281
40282
40283 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40284 PyObject *resultobj;
40285 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40286 wxButton *result;
40287 PyObject * obj0 = 0 ;
40288 char *kwnames[] = {
40289 (char *) "self", NULL
40290 };
40291
40292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
40293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40294 if (SWIG_arg_fail(1)) SWIG_fail;
40295 {
40296 PyThreadState* __tstate = wxPyBeginAllowThreads();
40297 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
40298
40299 wxPyEndAllowThreads(__tstate);
40300 if (PyErr_Occurred()) SWIG_fail;
40301 }
40302 {
40303 resultobj = wxPyMake_wxObject(result, 0);
40304 }
40305 return resultobj;
40306 fail:
40307 return NULL;
40308 }
40309
40310
40311 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40312 PyObject *resultobj;
40313 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40314 wxButton *result;
40315 PyObject * obj0 = 0 ;
40316 char *kwnames[] = {
40317 (char *) "self", NULL
40318 };
40319
40320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
40321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40322 if (SWIG_arg_fail(1)) SWIG_fail;
40323 {
40324 PyThreadState* __tstate = wxPyBeginAllowThreads();
40325 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
40326
40327 wxPyEndAllowThreads(__tstate);
40328 if (PyErr_Occurred()) SWIG_fail;
40329 }
40330 {
40331 resultobj = wxPyMake_wxObject(result, 0);
40332 }
40333 return resultobj;
40334 fail:
40335 return NULL;
40336 }
40337
40338
40339 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
40340 PyObject *resultobj;
40341 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40342 wxButton *result;
40343 PyObject * obj0 = 0 ;
40344 char *kwnames[] = {
40345 (char *) "self", NULL
40346 };
40347
40348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
40349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40350 if (SWIG_arg_fail(1)) SWIG_fail;
40351 {
40352 PyThreadState* __tstate = wxPyBeginAllowThreads();
40353 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
40354
40355 wxPyEndAllowThreads(__tstate);
40356 if (PyErr_Occurred()) SWIG_fail;
40357 }
40358 {
40359 resultobj = wxPyMake_wxObject(result, 0);
40360 }
40361 return resultobj;
40362 fail:
40363 return NULL;
40364 }
40365
40366
40367 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
40368 PyObject *obj;
40369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40370 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
40371 Py_INCREF(obj);
40372 return Py_BuildValue((char *)"");
40373 }
40374 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40375 PyObject *resultobj;
40376 int arg1 = (int) 0 ;
40377 int arg2 = (int) 0 ;
40378 wxGBPosition *result;
40379 PyObject * obj0 = 0 ;
40380 PyObject * obj1 = 0 ;
40381 char *kwnames[] = {
40382 (char *) "row",(char *) "col", NULL
40383 };
40384
40385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
40386 if (obj0) {
40387 {
40388 arg1 = (int)(SWIG_As_int(obj0));
40389 if (SWIG_arg_fail(1)) SWIG_fail;
40390 }
40391 }
40392 if (obj1) {
40393 {
40394 arg2 = (int)(SWIG_As_int(obj1));
40395 if (SWIG_arg_fail(2)) SWIG_fail;
40396 }
40397 }
40398 {
40399 PyThreadState* __tstate = wxPyBeginAllowThreads();
40400 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
40401
40402 wxPyEndAllowThreads(__tstate);
40403 if (PyErr_Occurred()) SWIG_fail;
40404 }
40405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
40406 return resultobj;
40407 fail:
40408 return NULL;
40409 }
40410
40411
40412 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40413 PyObject *resultobj;
40414 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40415 int result;
40416 PyObject * obj0 = 0 ;
40417 char *kwnames[] = {
40418 (char *) "self", NULL
40419 };
40420
40421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
40422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40423 if (SWIG_arg_fail(1)) SWIG_fail;
40424 {
40425 PyThreadState* __tstate = wxPyBeginAllowThreads();
40426 result = (int)((wxGBPosition const *)arg1)->GetRow();
40427
40428 wxPyEndAllowThreads(__tstate);
40429 if (PyErr_Occurred()) SWIG_fail;
40430 }
40431 {
40432 resultobj = SWIG_From_int((int)(result));
40433 }
40434 return resultobj;
40435 fail:
40436 return NULL;
40437 }
40438
40439
40440 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40441 PyObject *resultobj;
40442 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40443 int result;
40444 PyObject * obj0 = 0 ;
40445 char *kwnames[] = {
40446 (char *) "self", NULL
40447 };
40448
40449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
40450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40451 if (SWIG_arg_fail(1)) SWIG_fail;
40452 {
40453 PyThreadState* __tstate = wxPyBeginAllowThreads();
40454 result = (int)((wxGBPosition const *)arg1)->GetCol();
40455
40456 wxPyEndAllowThreads(__tstate);
40457 if (PyErr_Occurred()) SWIG_fail;
40458 }
40459 {
40460 resultobj = SWIG_From_int((int)(result));
40461 }
40462 return resultobj;
40463 fail:
40464 return NULL;
40465 }
40466
40467
40468 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40469 PyObject *resultobj;
40470 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40471 int arg2 ;
40472 PyObject * obj0 = 0 ;
40473 PyObject * obj1 = 0 ;
40474 char *kwnames[] = {
40475 (char *) "self",(char *) "row", NULL
40476 };
40477
40478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
40479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40480 if (SWIG_arg_fail(1)) SWIG_fail;
40481 {
40482 arg2 = (int)(SWIG_As_int(obj1));
40483 if (SWIG_arg_fail(2)) SWIG_fail;
40484 }
40485 {
40486 PyThreadState* __tstate = wxPyBeginAllowThreads();
40487 (arg1)->SetRow(arg2);
40488
40489 wxPyEndAllowThreads(__tstate);
40490 if (PyErr_Occurred()) SWIG_fail;
40491 }
40492 Py_INCREF(Py_None); resultobj = Py_None;
40493 return resultobj;
40494 fail:
40495 return NULL;
40496 }
40497
40498
40499 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40500 PyObject *resultobj;
40501 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40502 int arg2 ;
40503 PyObject * obj0 = 0 ;
40504 PyObject * obj1 = 0 ;
40505 char *kwnames[] = {
40506 (char *) "self",(char *) "col", NULL
40507 };
40508
40509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
40510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40511 if (SWIG_arg_fail(1)) SWIG_fail;
40512 {
40513 arg2 = (int)(SWIG_As_int(obj1));
40514 if (SWIG_arg_fail(2)) SWIG_fail;
40515 }
40516 {
40517 PyThreadState* __tstate = wxPyBeginAllowThreads();
40518 (arg1)->SetCol(arg2);
40519
40520 wxPyEndAllowThreads(__tstate);
40521 if (PyErr_Occurred()) SWIG_fail;
40522 }
40523 Py_INCREF(Py_None); resultobj = Py_None;
40524 return resultobj;
40525 fail:
40526 return NULL;
40527 }
40528
40529
40530 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40531 PyObject *resultobj;
40532 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40533 wxGBPosition *arg2 = 0 ;
40534 bool result;
40535 wxGBPosition temp2 ;
40536 PyObject * obj0 = 0 ;
40537 PyObject * obj1 = 0 ;
40538 char *kwnames[] = {
40539 (char *) "self",(char *) "other", NULL
40540 };
40541
40542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
40543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40544 if (SWIG_arg_fail(1)) SWIG_fail;
40545 {
40546 arg2 = &temp2;
40547 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40548 }
40549 {
40550 PyThreadState* __tstate = wxPyBeginAllowThreads();
40551 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
40552
40553 wxPyEndAllowThreads(__tstate);
40554 if (PyErr_Occurred()) SWIG_fail;
40555 }
40556 {
40557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40558 }
40559 return resultobj;
40560 fail:
40561 return NULL;
40562 }
40563
40564
40565 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40566 PyObject *resultobj;
40567 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40568 wxGBPosition *arg2 = 0 ;
40569 bool result;
40570 wxGBPosition temp2 ;
40571 PyObject * obj0 = 0 ;
40572 PyObject * obj1 = 0 ;
40573 char *kwnames[] = {
40574 (char *) "self",(char *) "other", NULL
40575 };
40576
40577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
40578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40579 if (SWIG_arg_fail(1)) SWIG_fail;
40580 {
40581 arg2 = &temp2;
40582 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40583 }
40584 {
40585 PyThreadState* __tstate = wxPyBeginAllowThreads();
40586 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
40587
40588 wxPyEndAllowThreads(__tstate);
40589 if (PyErr_Occurred()) SWIG_fail;
40590 }
40591 {
40592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40593 }
40594 return resultobj;
40595 fail:
40596 return NULL;
40597 }
40598
40599
40600 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40601 PyObject *resultobj;
40602 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40603 int arg2 = (int) 0 ;
40604 int arg3 = (int) 0 ;
40605 PyObject * obj0 = 0 ;
40606 PyObject * obj1 = 0 ;
40607 PyObject * obj2 = 0 ;
40608 char *kwnames[] = {
40609 (char *) "self",(char *) "row",(char *) "col", NULL
40610 };
40611
40612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40614 if (SWIG_arg_fail(1)) SWIG_fail;
40615 if (obj1) {
40616 {
40617 arg2 = (int)(SWIG_As_int(obj1));
40618 if (SWIG_arg_fail(2)) SWIG_fail;
40619 }
40620 }
40621 if (obj2) {
40622 {
40623 arg3 = (int)(SWIG_As_int(obj2));
40624 if (SWIG_arg_fail(3)) SWIG_fail;
40625 }
40626 }
40627 {
40628 PyThreadState* __tstate = wxPyBeginAllowThreads();
40629 wxGBPosition_Set(arg1,arg2,arg3);
40630
40631 wxPyEndAllowThreads(__tstate);
40632 if (PyErr_Occurred()) SWIG_fail;
40633 }
40634 Py_INCREF(Py_None); resultobj = Py_None;
40635 return resultobj;
40636 fail:
40637 return NULL;
40638 }
40639
40640
40641 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40642 PyObject *resultobj;
40643 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40644 PyObject *result;
40645 PyObject * obj0 = 0 ;
40646 char *kwnames[] = {
40647 (char *) "self", NULL
40648 };
40649
40650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
40651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40652 if (SWIG_arg_fail(1)) SWIG_fail;
40653 {
40654 PyThreadState* __tstate = wxPyBeginAllowThreads();
40655 result = (PyObject *)wxGBPosition_Get(arg1);
40656
40657 wxPyEndAllowThreads(__tstate);
40658 if (PyErr_Occurred()) SWIG_fail;
40659 }
40660 resultobj = result;
40661 return resultobj;
40662 fail:
40663 return NULL;
40664 }
40665
40666
40667 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
40668 PyObject *obj;
40669 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40670 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
40671 Py_INCREF(obj);
40672 return Py_BuildValue((char *)"");
40673 }
40674 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
40675 PyObject *resultobj;
40676 int arg1 = (int) 1 ;
40677 int arg2 = (int) 1 ;
40678 wxGBSpan *result;
40679 PyObject * obj0 = 0 ;
40680 PyObject * obj1 = 0 ;
40681 char *kwnames[] = {
40682 (char *) "rowspan",(char *) "colspan", NULL
40683 };
40684
40685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
40686 if (obj0) {
40687 {
40688 arg1 = (int)(SWIG_As_int(obj0));
40689 if (SWIG_arg_fail(1)) SWIG_fail;
40690 }
40691 }
40692 if (obj1) {
40693 {
40694 arg2 = (int)(SWIG_As_int(obj1));
40695 if (SWIG_arg_fail(2)) SWIG_fail;
40696 }
40697 }
40698 {
40699 PyThreadState* __tstate = wxPyBeginAllowThreads();
40700 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
40701
40702 wxPyEndAllowThreads(__tstate);
40703 if (PyErr_Occurred()) SWIG_fail;
40704 }
40705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
40706 return resultobj;
40707 fail:
40708 return NULL;
40709 }
40710
40711
40712 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40713 PyObject *resultobj;
40714 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40715 int result;
40716 PyObject * obj0 = 0 ;
40717 char *kwnames[] = {
40718 (char *) "self", NULL
40719 };
40720
40721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
40722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40723 if (SWIG_arg_fail(1)) SWIG_fail;
40724 {
40725 PyThreadState* __tstate = wxPyBeginAllowThreads();
40726 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
40727
40728 wxPyEndAllowThreads(__tstate);
40729 if (PyErr_Occurred()) SWIG_fail;
40730 }
40731 {
40732 resultobj = SWIG_From_int((int)(result));
40733 }
40734 return resultobj;
40735 fail:
40736 return NULL;
40737 }
40738
40739
40740 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40741 PyObject *resultobj;
40742 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40743 int result;
40744 PyObject * obj0 = 0 ;
40745 char *kwnames[] = {
40746 (char *) "self", NULL
40747 };
40748
40749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
40750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40751 if (SWIG_arg_fail(1)) SWIG_fail;
40752 {
40753 PyThreadState* __tstate = wxPyBeginAllowThreads();
40754 result = (int)((wxGBSpan const *)arg1)->GetColspan();
40755
40756 wxPyEndAllowThreads(__tstate);
40757 if (PyErr_Occurred()) SWIG_fail;
40758 }
40759 {
40760 resultobj = SWIG_From_int((int)(result));
40761 }
40762 return resultobj;
40763 fail:
40764 return NULL;
40765 }
40766
40767
40768 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40769 PyObject *resultobj;
40770 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40771 int arg2 ;
40772 PyObject * obj0 = 0 ;
40773 PyObject * obj1 = 0 ;
40774 char *kwnames[] = {
40775 (char *) "self",(char *) "rowspan", NULL
40776 };
40777
40778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
40779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40780 if (SWIG_arg_fail(1)) SWIG_fail;
40781 {
40782 arg2 = (int)(SWIG_As_int(obj1));
40783 if (SWIG_arg_fail(2)) SWIG_fail;
40784 }
40785 {
40786 PyThreadState* __tstate = wxPyBeginAllowThreads();
40787 (arg1)->SetRowspan(arg2);
40788
40789 wxPyEndAllowThreads(__tstate);
40790 if (PyErr_Occurred()) SWIG_fail;
40791 }
40792 Py_INCREF(Py_None); resultobj = Py_None;
40793 return resultobj;
40794 fail:
40795 return NULL;
40796 }
40797
40798
40799 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40800 PyObject *resultobj;
40801 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40802 int arg2 ;
40803 PyObject * obj0 = 0 ;
40804 PyObject * obj1 = 0 ;
40805 char *kwnames[] = {
40806 (char *) "self",(char *) "colspan", NULL
40807 };
40808
40809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
40810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40811 if (SWIG_arg_fail(1)) SWIG_fail;
40812 {
40813 arg2 = (int)(SWIG_As_int(obj1));
40814 if (SWIG_arg_fail(2)) SWIG_fail;
40815 }
40816 {
40817 PyThreadState* __tstate = wxPyBeginAllowThreads();
40818 (arg1)->SetColspan(arg2);
40819
40820 wxPyEndAllowThreads(__tstate);
40821 if (PyErr_Occurred()) SWIG_fail;
40822 }
40823 Py_INCREF(Py_None); resultobj = Py_None;
40824 return resultobj;
40825 fail:
40826 return NULL;
40827 }
40828
40829
40830 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40831 PyObject *resultobj;
40832 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40833 wxGBSpan *arg2 = 0 ;
40834 bool result;
40835 wxGBSpan temp2 ;
40836 PyObject * obj0 = 0 ;
40837 PyObject * obj1 = 0 ;
40838 char *kwnames[] = {
40839 (char *) "self",(char *) "other", NULL
40840 };
40841
40842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
40843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40844 if (SWIG_arg_fail(1)) SWIG_fail;
40845 {
40846 arg2 = &temp2;
40847 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40848 }
40849 {
40850 PyThreadState* __tstate = wxPyBeginAllowThreads();
40851 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
40852
40853 wxPyEndAllowThreads(__tstate);
40854 if (PyErr_Occurred()) SWIG_fail;
40855 }
40856 {
40857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40858 }
40859 return resultobj;
40860 fail:
40861 return NULL;
40862 }
40863
40864
40865 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40866 PyObject *resultobj;
40867 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40868 wxGBSpan *arg2 = 0 ;
40869 bool result;
40870 wxGBSpan temp2 ;
40871 PyObject * obj0 = 0 ;
40872 PyObject * obj1 = 0 ;
40873 char *kwnames[] = {
40874 (char *) "self",(char *) "other", NULL
40875 };
40876
40877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
40878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40879 if (SWIG_arg_fail(1)) SWIG_fail;
40880 {
40881 arg2 = &temp2;
40882 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40883 }
40884 {
40885 PyThreadState* __tstate = wxPyBeginAllowThreads();
40886 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
40887
40888 wxPyEndAllowThreads(__tstate);
40889 if (PyErr_Occurred()) SWIG_fail;
40890 }
40891 {
40892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40893 }
40894 return resultobj;
40895 fail:
40896 return NULL;
40897 }
40898
40899
40900 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40901 PyObject *resultobj;
40902 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40903 int arg2 = (int) 1 ;
40904 int arg3 = (int) 1 ;
40905 PyObject * obj0 = 0 ;
40906 PyObject * obj1 = 0 ;
40907 PyObject * obj2 = 0 ;
40908 char *kwnames[] = {
40909 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
40910 };
40911
40912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40914 if (SWIG_arg_fail(1)) SWIG_fail;
40915 if (obj1) {
40916 {
40917 arg2 = (int)(SWIG_As_int(obj1));
40918 if (SWIG_arg_fail(2)) SWIG_fail;
40919 }
40920 }
40921 if (obj2) {
40922 {
40923 arg3 = (int)(SWIG_As_int(obj2));
40924 if (SWIG_arg_fail(3)) SWIG_fail;
40925 }
40926 }
40927 {
40928 PyThreadState* __tstate = wxPyBeginAllowThreads();
40929 wxGBSpan_Set(arg1,arg2,arg3);
40930
40931 wxPyEndAllowThreads(__tstate);
40932 if (PyErr_Occurred()) SWIG_fail;
40933 }
40934 Py_INCREF(Py_None); resultobj = Py_None;
40935 return resultobj;
40936 fail:
40937 return NULL;
40938 }
40939
40940
40941 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40942 PyObject *resultobj;
40943 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40944 PyObject *result;
40945 PyObject * obj0 = 0 ;
40946 char *kwnames[] = {
40947 (char *) "self", NULL
40948 };
40949
40950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
40951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40952 if (SWIG_arg_fail(1)) SWIG_fail;
40953 {
40954 PyThreadState* __tstate = wxPyBeginAllowThreads();
40955 result = (PyObject *)wxGBSpan_Get(arg1);
40956
40957 wxPyEndAllowThreads(__tstate);
40958 if (PyErr_Occurred()) SWIG_fail;
40959 }
40960 resultobj = result;
40961 return resultobj;
40962 fail:
40963 return NULL;
40964 }
40965
40966
40967 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
40968 PyObject *obj;
40969 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40970 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
40971 Py_INCREF(obj);
40972 return Py_BuildValue((char *)"");
40973 }
40974 static int _wrap_DefaultSpan_set(PyObject *) {
40975 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
40976 return 1;
40977 }
40978
40979
40980 static PyObject *_wrap_DefaultSpan_get(void) {
40981 PyObject *pyobj;
40982
40983 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
40984 return pyobj;
40985 }
40986
40987
40988 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
40989 PyObject *resultobj;
40990 wxGBSizerItem *result;
40991 char *kwnames[] = {
40992 NULL
40993 };
40994
40995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
40996 {
40997 PyThreadState* __tstate = wxPyBeginAllowThreads();
40998 result = (wxGBSizerItem *)new wxGBSizerItem();
40999
41000 wxPyEndAllowThreads(__tstate);
41001 if (PyErr_Occurred()) SWIG_fail;
41002 }
41003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41004 return resultobj;
41005 fail:
41006 return NULL;
41007 }
41008
41009
41010 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41011 PyObject *resultobj;
41012 wxWindow *arg1 = (wxWindow *) 0 ;
41013 wxGBPosition *arg2 = 0 ;
41014 wxGBSpan *arg3 = 0 ;
41015 int arg4 ;
41016 int arg5 ;
41017 PyObject *arg6 = (PyObject *) NULL ;
41018 wxGBSizerItem *result;
41019 wxGBPosition temp2 ;
41020 wxGBSpan temp3 ;
41021 PyObject * obj0 = 0 ;
41022 PyObject * obj1 = 0 ;
41023 PyObject * obj2 = 0 ;
41024 PyObject * obj3 = 0 ;
41025 PyObject * obj4 = 0 ;
41026 PyObject * obj5 = 0 ;
41027 char *kwnames[] = {
41028 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41029 };
41030
41031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41033 if (SWIG_arg_fail(1)) SWIG_fail;
41034 {
41035 arg2 = &temp2;
41036 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41037 }
41038 {
41039 arg3 = &temp3;
41040 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41041 }
41042 {
41043 arg4 = (int)(SWIG_As_int(obj3));
41044 if (SWIG_arg_fail(4)) SWIG_fail;
41045 }
41046 {
41047 arg5 = (int)(SWIG_As_int(obj4));
41048 if (SWIG_arg_fail(5)) SWIG_fail;
41049 }
41050 if (obj5) {
41051 arg6 = obj5;
41052 }
41053 {
41054 PyThreadState* __tstate = wxPyBeginAllowThreads();
41055 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41056
41057 wxPyEndAllowThreads(__tstate);
41058 if (PyErr_Occurred()) SWIG_fail;
41059 }
41060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41061 return resultobj;
41062 fail:
41063 return NULL;
41064 }
41065
41066
41067 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41068 PyObject *resultobj;
41069 wxSizer *arg1 = (wxSizer *) 0 ;
41070 wxGBPosition *arg2 = 0 ;
41071 wxGBSpan *arg3 = 0 ;
41072 int arg4 ;
41073 int arg5 ;
41074 PyObject *arg6 = (PyObject *) NULL ;
41075 wxGBSizerItem *result;
41076 wxGBPosition temp2 ;
41077 wxGBSpan temp3 ;
41078 PyObject * obj0 = 0 ;
41079 PyObject * obj1 = 0 ;
41080 PyObject * obj2 = 0 ;
41081 PyObject * obj3 = 0 ;
41082 PyObject * obj4 = 0 ;
41083 PyObject * obj5 = 0 ;
41084 char *kwnames[] = {
41085 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41086 };
41087
41088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41090 if (SWIG_arg_fail(1)) SWIG_fail;
41091 {
41092 arg2 = &temp2;
41093 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41094 }
41095 {
41096 arg3 = &temp3;
41097 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41098 }
41099 {
41100 arg4 = (int)(SWIG_As_int(obj3));
41101 if (SWIG_arg_fail(4)) SWIG_fail;
41102 }
41103 {
41104 arg5 = (int)(SWIG_As_int(obj4));
41105 if (SWIG_arg_fail(5)) SWIG_fail;
41106 }
41107 if (obj5) {
41108 arg6 = obj5;
41109 }
41110 {
41111 PyThreadState* __tstate = wxPyBeginAllowThreads();
41112 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41113
41114 wxPyEndAllowThreads(__tstate);
41115 if (PyErr_Occurred()) SWIG_fail;
41116 }
41117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41118 return resultobj;
41119 fail:
41120 return NULL;
41121 }
41122
41123
41124 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41125 PyObject *resultobj;
41126 int arg1 ;
41127 int arg2 ;
41128 wxGBPosition *arg3 = 0 ;
41129 wxGBSpan *arg4 = 0 ;
41130 int arg5 ;
41131 int arg6 ;
41132 PyObject *arg7 = (PyObject *) NULL ;
41133 wxGBSizerItem *result;
41134 wxGBPosition temp3 ;
41135 wxGBSpan temp4 ;
41136 PyObject * obj0 = 0 ;
41137 PyObject * obj1 = 0 ;
41138 PyObject * obj2 = 0 ;
41139 PyObject * obj3 = 0 ;
41140 PyObject * obj4 = 0 ;
41141 PyObject * obj5 = 0 ;
41142 PyObject * obj6 = 0 ;
41143 char *kwnames[] = {
41144 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41145 };
41146
41147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41148 {
41149 arg1 = (int)(SWIG_As_int(obj0));
41150 if (SWIG_arg_fail(1)) SWIG_fail;
41151 }
41152 {
41153 arg2 = (int)(SWIG_As_int(obj1));
41154 if (SWIG_arg_fail(2)) SWIG_fail;
41155 }
41156 {
41157 arg3 = &temp3;
41158 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41159 }
41160 {
41161 arg4 = &temp4;
41162 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41163 }
41164 {
41165 arg5 = (int)(SWIG_As_int(obj4));
41166 if (SWIG_arg_fail(5)) SWIG_fail;
41167 }
41168 {
41169 arg6 = (int)(SWIG_As_int(obj5));
41170 if (SWIG_arg_fail(6)) SWIG_fail;
41171 }
41172 if (obj6) {
41173 arg7 = obj6;
41174 }
41175 {
41176 PyThreadState* __tstate = wxPyBeginAllowThreads();
41177 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41178
41179 wxPyEndAllowThreads(__tstate);
41180 if (PyErr_Occurred()) SWIG_fail;
41181 }
41182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41183 return resultobj;
41184 fail:
41185 return NULL;
41186 }
41187
41188
41189 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41190 PyObject *resultobj;
41191 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41192 wxGBPosition result;
41193 PyObject * obj0 = 0 ;
41194 char *kwnames[] = {
41195 (char *) "self", NULL
41196 };
41197
41198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
41199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41200 if (SWIG_arg_fail(1)) SWIG_fail;
41201 {
41202 PyThreadState* __tstate = wxPyBeginAllowThreads();
41203 result = ((wxGBSizerItem const *)arg1)->GetPos();
41204
41205 wxPyEndAllowThreads(__tstate);
41206 if (PyErr_Occurred()) SWIG_fail;
41207 }
41208 {
41209 wxGBPosition * resultptr;
41210 resultptr = new wxGBPosition((wxGBPosition &)(result));
41211 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41212 }
41213 return resultobj;
41214 fail:
41215 return NULL;
41216 }
41217
41218
41219 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41220 PyObject *resultobj;
41221 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41222 wxGBSpan result;
41223 PyObject * obj0 = 0 ;
41224 char *kwnames[] = {
41225 (char *) "self", NULL
41226 };
41227
41228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
41229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41230 if (SWIG_arg_fail(1)) SWIG_fail;
41231 {
41232 PyThreadState* __tstate = wxPyBeginAllowThreads();
41233 result = ((wxGBSizerItem const *)arg1)->GetSpan();
41234
41235 wxPyEndAllowThreads(__tstate);
41236 if (PyErr_Occurred()) SWIG_fail;
41237 }
41238 {
41239 wxGBSpan * resultptr;
41240 resultptr = new wxGBSpan((wxGBSpan &)(result));
41241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41242 }
41243 return resultobj;
41244 fail:
41245 return NULL;
41246 }
41247
41248
41249 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41250 PyObject *resultobj;
41251 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41252 wxGBPosition *arg2 = 0 ;
41253 bool result;
41254 wxGBPosition temp2 ;
41255 PyObject * obj0 = 0 ;
41256 PyObject * obj1 = 0 ;
41257 char *kwnames[] = {
41258 (char *) "self",(char *) "pos", NULL
41259 };
41260
41261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
41262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41263 if (SWIG_arg_fail(1)) SWIG_fail;
41264 {
41265 arg2 = &temp2;
41266 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41267 }
41268 {
41269 PyThreadState* __tstate = wxPyBeginAllowThreads();
41270 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
41271
41272 wxPyEndAllowThreads(__tstate);
41273 if (PyErr_Occurred()) SWIG_fail;
41274 }
41275 {
41276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41277 }
41278 return resultobj;
41279 fail:
41280 return NULL;
41281 }
41282
41283
41284 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41285 PyObject *resultobj;
41286 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41287 wxGBSpan *arg2 = 0 ;
41288 bool result;
41289 wxGBSpan temp2 ;
41290 PyObject * obj0 = 0 ;
41291 PyObject * obj1 = 0 ;
41292 char *kwnames[] = {
41293 (char *) "self",(char *) "span", NULL
41294 };
41295
41296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
41297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41298 if (SWIG_arg_fail(1)) SWIG_fail;
41299 {
41300 arg2 = &temp2;
41301 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41302 }
41303 {
41304 PyThreadState* __tstate = wxPyBeginAllowThreads();
41305 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
41306
41307 wxPyEndAllowThreads(__tstate);
41308 if (PyErr_Occurred()) SWIG_fail;
41309 }
41310 {
41311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41312 }
41313 return resultobj;
41314 fail:
41315 return NULL;
41316 }
41317
41318
41319 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
41320 PyObject *resultobj;
41321 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41322 wxGBSizerItem *arg2 = 0 ;
41323 bool result;
41324 PyObject * obj0 = 0 ;
41325 PyObject * obj1 = 0 ;
41326 char *kwnames[] = {
41327 (char *) "self",(char *) "other", NULL
41328 };
41329
41330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
41331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41332 if (SWIG_arg_fail(1)) SWIG_fail;
41333 {
41334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41335 if (SWIG_arg_fail(2)) SWIG_fail;
41336 if (arg2 == NULL) {
41337 SWIG_null_ref("wxGBSizerItem");
41338 }
41339 if (SWIG_arg_fail(2)) SWIG_fail;
41340 }
41341 {
41342 PyThreadState* __tstate = wxPyBeginAllowThreads();
41343 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
41344
41345 wxPyEndAllowThreads(__tstate);
41346 if (PyErr_Occurred()) SWIG_fail;
41347 }
41348 {
41349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41350 }
41351 return resultobj;
41352 fail:
41353 return NULL;
41354 }
41355
41356
41357 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
41358 PyObject *resultobj;
41359 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41360 wxGBPosition *arg2 = 0 ;
41361 wxGBSpan *arg3 = 0 ;
41362 bool result;
41363 wxGBPosition temp2 ;
41364 wxGBSpan temp3 ;
41365 PyObject * obj0 = 0 ;
41366 PyObject * obj1 = 0 ;
41367 PyObject * obj2 = 0 ;
41368 char *kwnames[] = {
41369 (char *) "self",(char *) "pos",(char *) "span", NULL
41370 };
41371
41372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
41373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41374 if (SWIG_arg_fail(1)) SWIG_fail;
41375 {
41376 arg2 = &temp2;
41377 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41378 }
41379 {
41380 arg3 = &temp3;
41381 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41382 }
41383 {
41384 PyThreadState* __tstate = wxPyBeginAllowThreads();
41385 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
41386
41387 wxPyEndAllowThreads(__tstate);
41388 if (PyErr_Occurred()) SWIG_fail;
41389 }
41390 {
41391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41392 }
41393 return resultobj;
41394 fail:
41395 return NULL;
41396 }
41397
41398
41399 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
41400 PyObject *resultobj;
41401 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41402 wxGBPosition result;
41403 PyObject * obj0 = 0 ;
41404 char *kwnames[] = {
41405 (char *) "self", NULL
41406 };
41407
41408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
41409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41410 if (SWIG_arg_fail(1)) SWIG_fail;
41411 {
41412 PyThreadState* __tstate = wxPyBeginAllowThreads();
41413 result = wxGBSizerItem_GetEndPos(arg1);
41414
41415 wxPyEndAllowThreads(__tstate);
41416 if (PyErr_Occurred()) SWIG_fail;
41417 }
41418 {
41419 wxGBPosition * resultptr;
41420 resultptr = new wxGBPosition((wxGBPosition &)(result));
41421 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41422 }
41423 return resultobj;
41424 fail:
41425 return NULL;
41426 }
41427
41428
41429 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41430 PyObject *resultobj;
41431 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41432 wxGridBagSizer *result;
41433 PyObject * obj0 = 0 ;
41434 char *kwnames[] = {
41435 (char *) "self", NULL
41436 };
41437
41438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
41439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41440 if (SWIG_arg_fail(1)) SWIG_fail;
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
41444
41445 wxPyEndAllowThreads(__tstate);
41446 if (PyErr_Occurred()) SWIG_fail;
41447 }
41448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
41449 return resultobj;
41450 fail:
41451 return NULL;
41452 }
41453
41454
41455 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41456 PyObject *resultobj;
41457 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41458 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
41459 PyObject * obj0 = 0 ;
41460 PyObject * obj1 = 0 ;
41461 char *kwnames[] = {
41462 (char *) "self",(char *) "sizer", NULL
41463 };
41464
41465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
41466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41467 if (SWIG_arg_fail(1)) SWIG_fail;
41468 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41469 if (SWIG_arg_fail(2)) SWIG_fail;
41470 {
41471 PyThreadState* __tstate = wxPyBeginAllowThreads();
41472 (arg1)->SetGBSizer(arg2);
41473
41474 wxPyEndAllowThreads(__tstate);
41475 if (PyErr_Occurred()) SWIG_fail;
41476 }
41477 Py_INCREF(Py_None); resultobj = Py_None;
41478 return resultobj;
41479 fail:
41480 return NULL;
41481 }
41482
41483
41484 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
41485 PyObject *obj;
41486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41487 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
41488 Py_INCREF(obj);
41489 return Py_BuildValue((char *)"");
41490 }
41491 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41492 PyObject *resultobj;
41493 int arg1 = (int) 0 ;
41494 int arg2 = (int) 0 ;
41495 wxGridBagSizer *result;
41496 PyObject * obj0 = 0 ;
41497 PyObject * obj1 = 0 ;
41498 char *kwnames[] = {
41499 (char *) "vgap",(char *) "hgap", NULL
41500 };
41501
41502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
41503 if (obj0) {
41504 {
41505 arg1 = (int)(SWIG_As_int(obj0));
41506 if (SWIG_arg_fail(1)) SWIG_fail;
41507 }
41508 }
41509 if (obj1) {
41510 {
41511 arg2 = (int)(SWIG_As_int(obj1));
41512 if (SWIG_arg_fail(2)) SWIG_fail;
41513 }
41514 }
41515 {
41516 PyThreadState* __tstate = wxPyBeginAllowThreads();
41517 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
41518
41519 wxPyEndAllowThreads(__tstate);
41520 if (PyErr_Occurred()) SWIG_fail;
41521 }
41522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
41523 return resultobj;
41524 fail:
41525 return NULL;
41526 }
41527
41528
41529 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
41530 PyObject *resultobj;
41531 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41532 PyObject *arg2 = (PyObject *) 0 ;
41533 wxGBPosition *arg3 = 0 ;
41534 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
41535 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
41536 int arg5 = (int) 0 ;
41537 int arg6 = (int) 0 ;
41538 PyObject *arg7 = (PyObject *) NULL ;
41539 wxGBSizerItem *result;
41540 wxGBPosition temp3 ;
41541 wxGBSpan temp4 ;
41542 PyObject * obj0 = 0 ;
41543 PyObject * obj1 = 0 ;
41544 PyObject * obj2 = 0 ;
41545 PyObject * obj3 = 0 ;
41546 PyObject * obj4 = 0 ;
41547 PyObject * obj5 = 0 ;
41548 PyObject * obj6 = 0 ;
41549 char *kwnames[] = {
41550 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41551 };
41552
41553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41555 if (SWIG_arg_fail(1)) SWIG_fail;
41556 arg2 = obj1;
41557 {
41558 arg3 = &temp3;
41559 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41560 }
41561 if (obj3) {
41562 {
41563 arg4 = &temp4;
41564 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41565 }
41566 }
41567 if (obj4) {
41568 {
41569 arg5 = (int)(SWIG_As_int(obj4));
41570 if (SWIG_arg_fail(5)) SWIG_fail;
41571 }
41572 }
41573 if (obj5) {
41574 {
41575 arg6 = (int)(SWIG_As_int(obj5));
41576 if (SWIG_arg_fail(6)) SWIG_fail;
41577 }
41578 }
41579 if (obj6) {
41580 arg7 = obj6;
41581 }
41582 {
41583 PyThreadState* __tstate = wxPyBeginAllowThreads();
41584 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41585
41586 wxPyEndAllowThreads(__tstate);
41587 if (PyErr_Occurred()) SWIG_fail;
41588 }
41589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41590 return resultobj;
41591 fail:
41592 return NULL;
41593 }
41594
41595
41596 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
41597 PyObject *resultobj;
41598 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41599 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
41600 wxGBSizerItem *result;
41601 PyObject * obj0 = 0 ;
41602 PyObject * obj1 = 0 ;
41603 char *kwnames[] = {
41604 (char *) "self",(char *) "item", NULL
41605 };
41606
41607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
41608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41609 if (SWIG_arg_fail(1)) SWIG_fail;
41610 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41611 if (SWIG_arg_fail(2)) SWIG_fail;
41612 {
41613 PyThreadState* __tstate = wxPyBeginAllowThreads();
41614 result = (wxGBSizerItem *)(arg1)->Add(arg2);
41615
41616 wxPyEndAllowThreads(__tstate);
41617 if (PyErr_Occurred()) SWIG_fail;
41618 }
41619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41620 return resultobj;
41621 fail:
41622 return NULL;
41623 }
41624
41625
41626 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41627 PyObject *resultobj;
41628 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41629 int arg2 ;
41630 int arg3 ;
41631 wxSize result;
41632 PyObject * obj0 = 0 ;
41633 PyObject * obj1 = 0 ;
41634 PyObject * obj2 = 0 ;
41635 char *kwnames[] = {
41636 (char *) "self",(char *) "row",(char *) "col", NULL
41637 };
41638
41639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
41640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41641 if (SWIG_arg_fail(1)) SWIG_fail;
41642 {
41643 arg2 = (int)(SWIG_As_int(obj1));
41644 if (SWIG_arg_fail(2)) SWIG_fail;
41645 }
41646 {
41647 arg3 = (int)(SWIG_As_int(obj2));
41648 if (SWIG_arg_fail(3)) SWIG_fail;
41649 }
41650 {
41651 PyThreadState* __tstate = wxPyBeginAllowThreads();
41652 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
41653
41654 wxPyEndAllowThreads(__tstate);
41655 if (PyErr_Occurred()) SWIG_fail;
41656 }
41657 {
41658 wxSize * resultptr;
41659 resultptr = new wxSize((wxSize &)(result));
41660 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41661 }
41662 return resultobj;
41663 fail:
41664 return NULL;
41665 }
41666
41667
41668 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41669 PyObject *resultobj;
41670 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41671 wxSize result;
41672 PyObject * obj0 = 0 ;
41673 char *kwnames[] = {
41674 (char *) "self", NULL
41675 };
41676
41677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
41678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41679 if (SWIG_arg_fail(1)) SWIG_fail;
41680 {
41681 PyThreadState* __tstate = wxPyBeginAllowThreads();
41682 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
41683
41684 wxPyEndAllowThreads(__tstate);
41685 if (PyErr_Occurred()) SWIG_fail;
41686 }
41687 {
41688 wxSize * resultptr;
41689 resultptr = new wxSize((wxSize &)(result));
41690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41691 }
41692 return resultobj;
41693 fail:
41694 return NULL;
41695 }
41696
41697
41698 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41699 PyObject *resultobj;
41700 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41701 wxSize *arg2 = 0 ;
41702 wxSize temp2 ;
41703 PyObject * obj0 = 0 ;
41704 PyObject * obj1 = 0 ;
41705 char *kwnames[] = {
41706 (char *) "self",(char *) "sz", NULL
41707 };
41708
41709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
41710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41711 if (SWIG_arg_fail(1)) SWIG_fail;
41712 {
41713 arg2 = &temp2;
41714 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
41715 }
41716 {
41717 PyThreadState* __tstate = wxPyBeginAllowThreads();
41718 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
41719
41720 wxPyEndAllowThreads(__tstate);
41721 if (PyErr_Occurred()) SWIG_fail;
41722 }
41723 Py_INCREF(Py_None); resultobj = Py_None;
41724 return resultobj;
41725 fail:
41726 return NULL;
41727 }
41728
41729
41730 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41731 PyObject *resultobj;
41732 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41733 wxWindow *arg2 = (wxWindow *) 0 ;
41734 wxGBPosition result;
41735 PyObject * obj0 = 0 ;
41736 PyObject * obj1 = 0 ;
41737
41738 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41740 if (SWIG_arg_fail(1)) SWIG_fail;
41741 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41742 if (SWIG_arg_fail(2)) SWIG_fail;
41743 {
41744 PyThreadState* __tstate = wxPyBeginAllowThreads();
41745 result = (arg1)->GetItemPosition(arg2);
41746
41747 wxPyEndAllowThreads(__tstate);
41748 if (PyErr_Occurred()) SWIG_fail;
41749 }
41750 {
41751 wxGBPosition * resultptr;
41752 resultptr = new wxGBPosition((wxGBPosition &)(result));
41753 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41754 }
41755 return resultobj;
41756 fail:
41757 return NULL;
41758 }
41759
41760
41761 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
41762 PyObject *resultobj;
41763 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41764 wxSizer *arg2 = (wxSizer *) 0 ;
41765 wxGBPosition result;
41766 PyObject * obj0 = 0 ;
41767 PyObject * obj1 = 0 ;
41768
41769 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41771 if (SWIG_arg_fail(1)) SWIG_fail;
41772 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41773 if (SWIG_arg_fail(2)) SWIG_fail;
41774 {
41775 PyThreadState* __tstate = wxPyBeginAllowThreads();
41776 result = (arg1)->GetItemPosition(arg2);
41777
41778 wxPyEndAllowThreads(__tstate);
41779 if (PyErr_Occurred()) SWIG_fail;
41780 }
41781 {
41782 wxGBPosition * resultptr;
41783 resultptr = new wxGBPosition((wxGBPosition &)(result));
41784 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41785 }
41786 return resultobj;
41787 fail:
41788 return NULL;
41789 }
41790
41791
41792 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
41793 PyObject *resultobj;
41794 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41795 size_t arg2 ;
41796 wxGBPosition result;
41797 PyObject * obj0 = 0 ;
41798 PyObject * obj1 = 0 ;
41799
41800 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41802 if (SWIG_arg_fail(1)) SWIG_fail;
41803 {
41804 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41805 if (SWIG_arg_fail(2)) SWIG_fail;
41806 }
41807 {
41808 PyThreadState* __tstate = wxPyBeginAllowThreads();
41809 result = (arg1)->GetItemPosition(arg2);
41810
41811 wxPyEndAllowThreads(__tstate);
41812 if (PyErr_Occurred()) SWIG_fail;
41813 }
41814 {
41815 wxGBPosition * resultptr;
41816 resultptr = new wxGBPosition((wxGBPosition &)(result));
41817 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41818 }
41819 return resultobj;
41820 fail:
41821 return NULL;
41822 }
41823
41824
41825 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
41826 int argc;
41827 PyObject *argv[3];
41828 int ii;
41829
41830 argc = PyObject_Length(args);
41831 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
41832 argv[ii] = PyTuple_GetItem(args,ii);
41833 }
41834 if (argc == 2) {
41835 int _v;
41836 {
41837 void *ptr;
41838 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41839 _v = 0;
41840 PyErr_Clear();
41841 } else {
41842 _v = 1;
41843 }
41844 }
41845 if (_v) {
41846 {
41847 void *ptr;
41848 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
41849 _v = 0;
41850 PyErr_Clear();
41851 } else {
41852 _v = 1;
41853 }
41854 }
41855 if (_v) {
41856 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
41857 }
41858 }
41859 }
41860 if (argc == 2) {
41861 int _v;
41862 {
41863 void *ptr;
41864 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41865 _v = 0;
41866 PyErr_Clear();
41867 } else {
41868 _v = 1;
41869 }
41870 }
41871 if (_v) {
41872 {
41873 void *ptr;
41874 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
41875 _v = 0;
41876 PyErr_Clear();
41877 } else {
41878 _v = 1;
41879 }
41880 }
41881 if (_v) {
41882 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
41883 }
41884 }
41885 }
41886 if (argc == 2) {
41887 int _v;
41888 {
41889 void *ptr;
41890 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41891 _v = 0;
41892 PyErr_Clear();
41893 } else {
41894 _v = 1;
41895 }
41896 }
41897 if (_v) {
41898 _v = SWIG_Check_unsigned_SS_long(argv[1]);
41899 if (_v) {
41900 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
41901 }
41902 }
41903 }
41904
41905 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
41906 return NULL;
41907 }
41908
41909
41910 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41911 PyObject *resultobj;
41912 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41913 wxWindow *arg2 = (wxWindow *) 0 ;
41914 wxGBPosition *arg3 = 0 ;
41915 bool result;
41916 wxGBPosition temp3 ;
41917 PyObject * obj0 = 0 ;
41918 PyObject * obj1 = 0 ;
41919 PyObject * obj2 = 0 ;
41920
41921 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41923 if (SWIG_arg_fail(1)) SWIG_fail;
41924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41925 if (SWIG_arg_fail(2)) SWIG_fail;
41926 {
41927 arg3 = &temp3;
41928 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41929 }
41930 {
41931 PyThreadState* __tstate = wxPyBeginAllowThreads();
41932 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41933
41934 wxPyEndAllowThreads(__tstate);
41935 if (PyErr_Occurred()) SWIG_fail;
41936 }
41937 {
41938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41939 }
41940 return resultobj;
41941 fail:
41942 return NULL;
41943 }
41944
41945
41946 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
41947 PyObject *resultobj;
41948 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41949 wxSizer *arg2 = (wxSizer *) 0 ;
41950 wxGBPosition *arg3 = 0 ;
41951 bool result;
41952 wxGBPosition temp3 ;
41953 PyObject * obj0 = 0 ;
41954 PyObject * obj1 = 0 ;
41955 PyObject * obj2 = 0 ;
41956
41957 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41959 if (SWIG_arg_fail(1)) SWIG_fail;
41960 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41961 if (SWIG_arg_fail(2)) SWIG_fail;
41962 {
41963 arg3 = &temp3;
41964 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41965 }
41966 {
41967 PyThreadState* __tstate = wxPyBeginAllowThreads();
41968 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41969
41970 wxPyEndAllowThreads(__tstate);
41971 if (PyErr_Occurred()) SWIG_fail;
41972 }
41973 {
41974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41975 }
41976 return resultobj;
41977 fail:
41978 return NULL;
41979 }
41980
41981
41982 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
41983 PyObject *resultobj;
41984 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41985 size_t arg2 ;
41986 wxGBPosition *arg3 = 0 ;
41987 bool result;
41988 wxGBPosition temp3 ;
41989 PyObject * obj0 = 0 ;
41990 PyObject * obj1 = 0 ;
41991 PyObject * obj2 = 0 ;
41992
41993 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41995 if (SWIG_arg_fail(1)) SWIG_fail;
41996 {
41997 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41998 if (SWIG_arg_fail(2)) SWIG_fail;
41999 }
42000 {
42001 arg3 = &temp3;
42002 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42003 }
42004 {
42005 PyThreadState* __tstate = wxPyBeginAllowThreads();
42006 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42007
42008 wxPyEndAllowThreads(__tstate);
42009 if (PyErr_Occurred()) SWIG_fail;
42010 }
42011 {
42012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42013 }
42014 return resultobj;
42015 fail:
42016 return NULL;
42017 }
42018
42019
42020 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42021 int argc;
42022 PyObject *argv[4];
42023 int ii;
42024
42025 argc = PyObject_Length(args);
42026 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42027 argv[ii] = PyTuple_GetItem(args,ii);
42028 }
42029 if (argc == 3) {
42030 int _v;
42031 {
42032 void *ptr;
42033 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42034 _v = 0;
42035 PyErr_Clear();
42036 } else {
42037 _v = 1;
42038 }
42039 }
42040 if (_v) {
42041 {
42042 void *ptr;
42043 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42044 _v = 0;
42045 PyErr_Clear();
42046 } else {
42047 _v = 1;
42048 }
42049 }
42050 if (_v) {
42051 {
42052 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42053 }
42054 if (_v) {
42055 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42056 }
42057 }
42058 }
42059 }
42060 if (argc == 3) {
42061 int _v;
42062 {
42063 void *ptr;
42064 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42065 _v = 0;
42066 PyErr_Clear();
42067 } else {
42068 _v = 1;
42069 }
42070 }
42071 if (_v) {
42072 {
42073 void *ptr;
42074 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42075 _v = 0;
42076 PyErr_Clear();
42077 } else {
42078 _v = 1;
42079 }
42080 }
42081 if (_v) {
42082 {
42083 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42084 }
42085 if (_v) {
42086 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42087 }
42088 }
42089 }
42090 }
42091 if (argc == 3) {
42092 int _v;
42093 {
42094 void *ptr;
42095 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42096 _v = 0;
42097 PyErr_Clear();
42098 } else {
42099 _v = 1;
42100 }
42101 }
42102 if (_v) {
42103 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42104 if (_v) {
42105 {
42106 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42107 }
42108 if (_v) {
42109 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42110 }
42111 }
42112 }
42113 }
42114
42115 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42116 return NULL;
42117 }
42118
42119
42120 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42121 PyObject *resultobj;
42122 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42123 wxWindow *arg2 = (wxWindow *) 0 ;
42124 wxGBSpan result;
42125 PyObject * obj0 = 0 ;
42126 PyObject * obj1 = 0 ;
42127
42128 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42130 if (SWIG_arg_fail(1)) SWIG_fail;
42131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42132 if (SWIG_arg_fail(2)) SWIG_fail;
42133 {
42134 PyThreadState* __tstate = wxPyBeginAllowThreads();
42135 result = (arg1)->GetItemSpan(arg2);
42136
42137 wxPyEndAllowThreads(__tstate);
42138 if (PyErr_Occurred()) SWIG_fail;
42139 }
42140 {
42141 wxGBSpan * resultptr;
42142 resultptr = new wxGBSpan((wxGBSpan &)(result));
42143 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42144 }
42145 return resultobj;
42146 fail:
42147 return NULL;
42148 }
42149
42150
42151 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42152 PyObject *resultobj;
42153 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42154 wxSizer *arg2 = (wxSizer *) 0 ;
42155 wxGBSpan result;
42156 PyObject * obj0 = 0 ;
42157 PyObject * obj1 = 0 ;
42158
42159 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42161 if (SWIG_arg_fail(1)) SWIG_fail;
42162 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42163 if (SWIG_arg_fail(2)) SWIG_fail;
42164 {
42165 PyThreadState* __tstate = wxPyBeginAllowThreads();
42166 result = (arg1)->GetItemSpan(arg2);
42167
42168 wxPyEndAllowThreads(__tstate);
42169 if (PyErr_Occurred()) SWIG_fail;
42170 }
42171 {
42172 wxGBSpan * resultptr;
42173 resultptr = new wxGBSpan((wxGBSpan &)(result));
42174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42175 }
42176 return resultobj;
42177 fail:
42178 return NULL;
42179 }
42180
42181
42182 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42183 PyObject *resultobj;
42184 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42185 size_t arg2 ;
42186 wxGBSpan result;
42187 PyObject * obj0 = 0 ;
42188 PyObject * obj1 = 0 ;
42189
42190 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42192 if (SWIG_arg_fail(1)) SWIG_fail;
42193 {
42194 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42195 if (SWIG_arg_fail(2)) SWIG_fail;
42196 }
42197 {
42198 PyThreadState* __tstate = wxPyBeginAllowThreads();
42199 result = (arg1)->GetItemSpan(arg2);
42200
42201 wxPyEndAllowThreads(__tstate);
42202 if (PyErr_Occurred()) SWIG_fail;
42203 }
42204 {
42205 wxGBSpan * resultptr;
42206 resultptr = new wxGBSpan((wxGBSpan &)(result));
42207 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42208 }
42209 return resultobj;
42210 fail:
42211 return NULL;
42212 }
42213
42214
42215 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
42216 int argc;
42217 PyObject *argv[3];
42218 int ii;
42219
42220 argc = PyObject_Length(args);
42221 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42222 argv[ii] = PyTuple_GetItem(args,ii);
42223 }
42224 if (argc == 2) {
42225 int _v;
42226 {
42227 void *ptr;
42228 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42229 _v = 0;
42230 PyErr_Clear();
42231 } else {
42232 _v = 1;
42233 }
42234 }
42235 if (_v) {
42236 {
42237 void *ptr;
42238 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42239 _v = 0;
42240 PyErr_Clear();
42241 } else {
42242 _v = 1;
42243 }
42244 }
42245 if (_v) {
42246 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
42247 }
42248 }
42249 }
42250 if (argc == 2) {
42251 int _v;
42252 {
42253 void *ptr;
42254 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42255 _v = 0;
42256 PyErr_Clear();
42257 } else {
42258 _v = 1;
42259 }
42260 }
42261 if (_v) {
42262 {
42263 void *ptr;
42264 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42265 _v = 0;
42266 PyErr_Clear();
42267 } else {
42268 _v = 1;
42269 }
42270 }
42271 if (_v) {
42272 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
42273 }
42274 }
42275 }
42276 if (argc == 2) {
42277 int _v;
42278 {
42279 void *ptr;
42280 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42281 _v = 0;
42282 PyErr_Clear();
42283 } else {
42284 _v = 1;
42285 }
42286 }
42287 if (_v) {
42288 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42289 if (_v) {
42290 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
42291 }
42292 }
42293 }
42294
42295 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
42296 return NULL;
42297 }
42298
42299
42300 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42301 PyObject *resultobj;
42302 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42303 wxWindow *arg2 = (wxWindow *) 0 ;
42304 wxGBSpan *arg3 = 0 ;
42305 bool result;
42306 wxGBSpan temp3 ;
42307 PyObject * obj0 = 0 ;
42308 PyObject * obj1 = 0 ;
42309 PyObject * obj2 = 0 ;
42310
42311 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42313 if (SWIG_arg_fail(1)) SWIG_fail;
42314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42315 if (SWIG_arg_fail(2)) SWIG_fail;
42316 {
42317 arg3 = &temp3;
42318 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42319 }
42320 {
42321 PyThreadState* __tstate = wxPyBeginAllowThreads();
42322 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42323
42324 wxPyEndAllowThreads(__tstate);
42325 if (PyErr_Occurred()) SWIG_fail;
42326 }
42327 {
42328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42329 }
42330 return resultobj;
42331 fail:
42332 return NULL;
42333 }
42334
42335
42336 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42337 PyObject *resultobj;
42338 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42339 wxSizer *arg2 = (wxSizer *) 0 ;
42340 wxGBSpan *arg3 = 0 ;
42341 bool result;
42342 wxGBSpan temp3 ;
42343 PyObject * obj0 = 0 ;
42344 PyObject * obj1 = 0 ;
42345 PyObject * obj2 = 0 ;
42346
42347 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42349 if (SWIG_arg_fail(1)) SWIG_fail;
42350 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42351 if (SWIG_arg_fail(2)) SWIG_fail;
42352 {
42353 arg3 = &temp3;
42354 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42355 }
42356 {
42357 PyThreadState* __tstate = wxPyBeginAllowThreads();
42358 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42359
42360 wxPyEndAllowThreads(__tstate);
42361 if (PyErr_Occurred()) SWIG_fail;
42362 }
42363 {
42364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42365 }
42366 return resultobj;
42367 fail:
42368 return NULL;
42369 }
42370
42371
42372 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42373 PyObject *resultobj;
42374 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42375 size_t arg2 ;
42376 wxGBSpan *arg3 = 0 ;
42377 bool result;
42378 wxGBSpan temp3 ;
42379 PyObject * obj0 = 0 ;
42380 PyObject * obj1 = 0 ;
42381 PyObject * obj2 = 0 ;
42382
42383 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42385 if (SWIG_arg_fail(1)) SWIG_fail;
42386 {
42387 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42388 if (SWIG_arg_fail(2)) SWIG_fail;
42389 }
42390 {
42391 arg3 = &temp3;
42392 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42393 }
42394 {
42395 PyThreadState* __tstate = wxPyBeginAllowThreads();
42396 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42397
42398 wxPyEndAllowThreads(__tstate);
42399 if (PyErr_Occurred()) SWIG_fail;
42400 }
42401 {
42402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42403 }
42404 return resultobj;
42405 fail:
42406 return NULL;
42407 }
42408
42409
42410 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
42411 int argc;
42412 PyObject *argv[4];
42413 int ii;
42414
42415 argc = PyObject_Length(args);
42416 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42417 argv[ii] = PyTuple_GetItem(args,ii);
42418 }
42419 if (argc == 3) {
42420 int _v;
42421 {
42422 void *ptr;
42423 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42424 _v = 0;
42425 PyErr_Clear();
42426 } else {
42427 _v = 1;
42428 }
42429 }
42430 if (_v) {
42431 {
42432 void *ptr;
42433 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42434 _v = 0;
42435 PyErr_Clear();
42436 } else {
42437 _v = 1;
42438 }
42439 }
42440 if (_v) {
42441 {
42442 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42443 }
42444 if (_v) {
42445 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
42446 }
42447 }
42448 }
42449 }
42450 if (argc == 3) {
42451 int _v;
42452 {
42453 void *ptr;
42454 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42455 _v = 0;
42456 PyErr_Clear();
42457 } else {
42458 _v = 1;
42459 }
42460 }
42461 if (_v) {
42462 {
42463 void *ptr;
42464 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42465 _v = 0;
42466 PyErr_Clear();
42467 } else {
42468 _v = 1;
42469 }
42470 }
42471 if (_v) {
42472 {
42473 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42474 }
42475 if (_v) {
42476 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
42477 }
42478 }
42479 }
42480 }
42481 if (argc == 3) {
42482 int _v;
42483 {
42484 void *ptr;
42485 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42486 _v = 0;
42487 PyErr_Clear();
42488 } else {
42489 _v = 1;
42490 }
42491 }
42492 if (_v) {
42493 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42494 if (_v) {
42495 {
42496 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42497 }
42498 if (_v) {
42499 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
42500 }
42501 }
42502 }
42503 }
42504
42505 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
42506 return NULL;
42507 }
42508
42509
42510 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
42511 PyObject *resultobj;
42512 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42513 wxWindow *arg2 = (wxWindow *) 0 ;
42514 wxGBSizerItem *result;
42515 PyObject * obj0 = 0 ;
42516 PyObject * obj1 = 0 ;
42517
42518 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42520 if (SWIG_arg_fail(1)) SWIG_fail;
42521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42522 if (SWIG_arg_fail(2)) SWIG_fail;
42523 {
42524 PyThreadState* __tstate = wxPyBeginAllowThreads();
42525 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42526
42527 wxPyEndAllowThreads(__tstate);
42528 if (PyErr_Occurred()) SWIG_fail;
42529 }
42530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42531 return resultobj;
42532 fail:
42533 return NULL;
42534 }
42535
42536
42537 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
42538 PyObject *resultobj;
42539 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42540 wxSizer *arg2 = (wxSizer *) 0 ;
42541 wxGBSizerItem *result;
42542 PyObject * obj0 = 0 ;
42543 PyObject * obj1 = 0 ;
42544
42545 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42547 if (SWIG_arg_fail(1)) SWIG_fail;
42548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42549 if (SWIG_arg_fail(2)) SWIG_fail;
42550 {
42551 PyThreadState* __tstate = wxPyBeginAllowThreads();
42552 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42553
42554 wxPyEndAllowThreads(__tstate);
42555 if (PyErr_Occurred()) SWIG_fail;
42556 }
42557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42558 return resultobj;
42559 fail:
42560 return NULL;
42561 }
42562
42563
42564 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
42565 int argc;
42566 PyObject *argv[3];
42567 int ii;
42568
42569 argc = PyObject_Length(args);
42570 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42571 argv[ii] = PyTuple_GetItem(args,ii);
42572 }
42573 if (argc == 2) {
42574 int _v;
42575 {
42576 void *ptr;
42577 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42578 _v = 0;
42579 PyErr_Clear();
42580 } else {
42581 _v = 1;
42582 }
42583 }
42584 if (_v) {
42585 {
42586 void *ptr;
42587 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42588 _v = 0;
42589 PyErr_Clear();
42590 } else {
42591 _v = 1;
42592 }
42593 }
42594 if (_v) {
42595 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
42596 }
42597 }
42598 }
42599 if (argc == 2) {
42600 int _v;
42601 {
42602 void *ptr;
42603 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42604 _v = 0;
42605 PyErr_Clear();
42606 } else {
42607 _v = 1;
42608 }
42609 }
42610 if (_v) {
42611 {
42612 void *ptr;
42613 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42614 _v = 0;
42615 PyErr_Clear();
42616 } else {
42617 _v = 1;
42618 }
42619 }
42620 if (_v) {
42621 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
42622 }
42623 }
42624 }
42625
42626 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
42627 return NULL;
42628 }
42629
42630
42631 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42632 PyObject *resultobj;
42633 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42634 wxGBPosition *arg2 = 0 ;
42635 wxGBSizerItem *result;
42636 wxGBPosition temp2 ;
42637 PyObject * obj0 = 0 ;
42638 PyObject * obj1 = 0 ;
42639 char *kwnames[] = {
42640 (char *) "self",(char *) "pos", NULL
42641 };
42642
42643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
42644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42645 if (SWIG_arg_fail(1)) SWIG_fail;
42646 {
42647 arg2 = &temp2;
42648 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42649 }
42650 {
42651 PyThreadState* __tstate = wxPyBeginAllowThreads();
42652 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
42653
42654 wxPyEndAllowThreads(__tstate);
42655 if (PyErr_Occurred()) SWIG_fail;
42656 }
42657 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42658 return resultobj;
42659 fail:
42660 return NULL;
42661 }
42662
42663
42664 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
42665 PyObject *resultobj;
42666 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42667 wxPoint *arg2 = 0 ;
42668 wxGBSizerItem *result;
42669 wxPoint temp2 ;
42670 PyObject * obj0 = 0 ;
42671 PyObject * obj1 = 0 ;
42672 char *kwnames[] = {
42673 (char *) "self",(char *) "pt", NULL
42674 };
42675
42676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
42677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42678 if (SWIG_arg_fail(1)) SWIG_fail;
42679 {
42680 arg2 = &temp2;
42681 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
42682 }
42683 {
42684 PyThreadState* __tstate = wxPyBeginAllowThreads();
42685 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
42686
42687 wxPyEndAllowThreads(__tstate);
42688 if (PyErr_Occurred()) SWIG_fail;
42689 }
42690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42691 return resultobj;
42692 fail:
42693 return NULL;
42694 }
42695
42696
42697 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
42698 PyObject *resultobj;
42699 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42700 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42701 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
42702 bool result;
42703 PyObject * obj0 = 0 ;
42704 PyObject * obj1 = 0 ;
42705 PyObject * obj2 = 0 ;
42706 char *kwnames[] = {
42707 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
42708 };
42709
42710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
42711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42712 if (SWIG_arg_fail(1)) SWIG_fail;
42713 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42714 if (SWIG_arg_fail(2)) SWIG_fail;
42715 if (obj2) {
42716 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42717 if (SWIG_arg_fail(3)) SWIG_fail;
42718 }
42719 {
42720 PyThreadState* __tstate = wxPyBeginAllowThreads();
42721 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
42722
42723 wxPyEndAllowThreads(__tstate);
42724 if (PyErr_Occurred()) SWIG_fail;
42725 }
42726 {
42727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42728 }
42729 return resultobj;
42730 fail:
42731 return NULL;
42732 }
42733
42734
42735 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
42736 PyObject *resultobj;
42737 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42738 wxGBPosition *arg2 = 0 ;
42739 wxGBSpan *arg3 = 0 ;
42740 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
42741 bool result;
42742 wxGBPosition temp2 ;
42743 wxGBSpan temp3 ;
42744 PyObject * obj0 = 0 ;
42745 PyObject * obj1 = 0 ;
42746 PyObject * obj2 = 0 ;
42747 PyObject * obj3 = 0 ;
42748 char *kwnames[] = {
42749 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
42750 };
42751
42752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42754 if (SWIG_arg_fail(1)) SWIG_fail;
42755 {
42756 arg2 = &temp2;
42757 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42758 }
42759 {
42760 arg3 = &temp3;
42761 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42762 }
42763 if (obj3) {
42764 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42765 if (SWIG_arg_fail(4)) SWIG_fail;
42766 }
42767 {
42768 PyThreadState* __tstate = wxPyBeginAllowThreads();
42769 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
42770
42771 wxPyEndAllowThreads(__tstate);
42772 if (PyErr_Occurred()) SWIG_fail;
42773 }
42774 {
42775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42776 }
42777 return resultobj;
42778 fail:
42779 return NULL;
42780 }
42781
42782
42783 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
42784 PyObject *obj;
42785 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42786 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
42787 Py_INCREF(obj);
42788 return Py_BuildValue((char *)"");
42789 }
42790 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42791 PyObject *resultobj;
42792 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42793 wxRelationship arg2 ;
42794 wxWindow *arg3 = (wxWindow *) 0 ;
42795 wxEdge arg4 ;
42796 int arg5 = (int) 0 ;
42797 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
42798 PyObject * obj0 = 0 ;
42799 PyObject * obj1 = 0 ;
42800 PyObject * obj2 = 0 ;
42801 PyObject * obj3 = 0 ;
42802 PyObject * obj4 = 0 ;
42803 PyObject * obj5 = 0 ;
42804 char *kwnames[] = {
42805 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
42806 };
42807
42808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42810 if (SWIG_arg_fail(1)) SWIG_fail;
42811 {
42812 arg2 = (wxRelationship)(SWIG_As_int(obj1));
42813 if (SWIG_arg_fail(2)) SWIG_fail;
42814 }
42815 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42816 if (SWIG_arg_fail(3)) SWIG_fail;
42817 {
42818 arg4 = (wxEdge)(SWIG_As_int(obj3));
42819 if (SWIG_arg_fail(4)) SWIG_fail;
42820 }
42821 if (obj4) {
42822 {
42823 arg5 = (int)(SWIG_As_int(obj4));
42824 if (SWIG_arg_fail(5)) SWIG_fail;
42825 }
42826 }
42827 if (obj5) {
42828 {
42829 arg6 = (int)(SWIG_As_int(obj5));
42830 if (SWIG_arg_fail(6)) SWIG_fail;
42831 }
42832 }
42833 {
42834 PyThreadState* __tstate = wxPyBeginAllowThreads();
42835 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
42836
42837 wxPyEndAllowThreads(__tstate);
42838 if (PyErr_Occurred()) SWIG_fail;
42839 }
42840 Py_INCREF(Py_None); resultobj = Py_None;
42841 return resultobj;
42842 fail:
42843 return NULL;
42844 }
42845
42846
42847 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
42848 PyObject *resultobj;
42849 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42850 wxWindow *arg2 = (wxWindow *) 0 ;
42851 int arg3 = (int) 0 ;
42852 PyObject * obj0 = 0 ;
42853 PyObject * obj1 = 0 ;
42854 PyObject * obj2 = 0 ;
42855 char *kwnames[] = {
42856 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42857 };
42858
42859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
42860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42861 if (SWIG_arg_fail(1)) SWIG_fail;
42862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42863 if (SWIG_arg_fail(2)) SWIG_fail;
42864 if (obj2) {
42865 {
42866 arg3 = (int)(SWIG_As_int(obj2));
42867 if (SWIG_arg_fail(3)) SWIG_fail;
42868 }
42869 }
42870 {
42871 PyThreadState* __tstate = wxPyBeginAllowThreads();
42872 (arg1)->LeftOf(arg2,arg3);
42873
42874 wxPyEndAllowThreads(__tstate);
42875 if (PyErr_Occurred()) SWIG_fail;
42876 }
42877 Py_INCREF(Py_None); resultobj = Py_None;
42878 return resultobj;
42879 fail:
42880 return NULL;
42881 }
42882
42883
42884 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
42885 PyObject *resultobj;
42886 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42887 wxWindow *arg2 = (wxWindow *) 0 ;
42888 int arg3 = (int) 0 ;
42889 PyObject * obj0 = 0 ;
42890 PyObject * obj1 = 0 ;
42891 PyObject * obj2 = 0 ;
42892 char *kwnames[] = {
42893 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42894 };
42895
42896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
42897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42898 if (SWIG_arg_fail(1)) SWIG_fail;
42899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42900 if (SWIG_arg_fail(2)) SWIG_fail;
42901 if (obj2) {
42902 {
42903 arg3 = (int)(SWIG_As_int(obj2));
42904 if (SWIG_arg_fail(3)) SWIG_fail;
42905 }
42906 }
42907 {
42908 PyThreadState* __tstate = wxPyBeginAllowThreads();
42909 (arg1)->RightOf(arg2,arg3);
42910
42911 wxPyEndAllowThreads(__tstate);
42912 if (PyErr_Occurred()) SWIG_fail;
42913 }
42914 Py_INCREF(Py_None); resultobj = Py_None;
42915 return resultobj;
42916 fail:
42917 return NULL;
42918 }
42919
42920
42921 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
42922 PyObject *resultobj;
42923 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42924 wxWindow *arg2 = (wxWindow *) 0 ;
42925 int arg3 = (int) 0 ;
42926 PyObject * obj0 = 0 ;
42927 PyObject * obj1 = 0 ;
42928 PyObject * obj2 = 0 ;
42929 char *kwnames[] = {
42930 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42931 };
42932
42933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
42934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42935 if (SWIG_arg_fail(1)) SWIG_fail;
42936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42937 if (SWIG_arg_fail(2)) SWIG_fail;
42938 if (obj2) {
42939 {
42940 arg3 = (int)(SWIG_As_int(obj2));
42941 if (SWIG_arg_fail(3)) SWIG_fail;
42942 }
42943 }
42944 {
42945 PyThreadState* __tstate = wxPyBeginAllowThreads();
42946 (arg1)->Above(arg2,arg3);
42947
42948 wxPyEndAllowThreads(__tstate);
42949 if (PyErr_Occurred()) SWIG_fail;
42950 }
42951 Py_INCREF(Py_None); resultobj = Py_None;
42952 return resultobj;
42953 fail:
42954 return NULL;
42955 }
42956
42957
42958 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
42959 PyObject *resultobj;
42960 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42961 wxWindow *arg2 = (wxWindow *) 0 ;
42962 int arg3 = (int) 0 ;
42963 PyObject * obj0 = 0 ;
42964 PyObject * obj1 = 0 ;
42965 PyObject * obj2 = 0 ;
42966 char *kwnames[] = {
42967 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42968 };
42969
42970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
42971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42972 if (SWIG_arg_fail(1)) SWIG_fail;
42973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42974 if (SWIG_arg_fail(2)) SWIG_fail;
42975 if (obj2) {
42976 {
42977 arg3 = (int)(SWIG_As_int(obj2));
42978 if (SWIG_arg_fail(3)) SWIG_fail;
42979 }
42980 }
42981 {
42982 PyThreadState* __tstate = wxPyBeginAllowThreads();
42983 (arg1)->Below(arg2,arg3);
42984
42985 wxPyEndAllowThreads(__tstate);
42986 if (PyErr_Occurred()) SWIG_fail;
42987 }
42988 Py_INCREF(Py_None); resultobj = Py_None;
42989 return resultobj;
42990 fail:
42991 return NULL;
42992 }
42993
42994
42995 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
42996 PyObject *resultobj;
42997 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42998 wxWindow *arg2 = (wxWindow *) 0 ;
42999 wxEdge arg3 ;
43000 int arg4 = (int) 0 ;
43001 PyObject * obj0 = 0 ;
43002 PyObject * obj1 = 0 ;
43003 PyObject * obj2 = 0 ;
43004 PyObject * obj3 = 0 ;
43005 char *kwnames[] = {
43006 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43007 };
43008
43009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43011 if (SWIG_arg_fail(1)) SWIG_fail;
43012 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43013 if (SWIG_arg_fail(2)) SWIG_fail;
43014 {
43015 arg3 = (wxEdge)(SWIG_As_int(obj2));
43016 if (SWIG_arg_fail(3)) SWIG_fail;
43017 }
43018 if (obj3) {
43019 {
43020 arg4 = (int)(SWIG_As_int(obj3));
43021 if (SWIG_arg_fail(4)) SWIG_fail;
43022 }
43023 }
43024 {
43025 PyThreadState* __tstate = wxPyBeginAllowThreads();
43026 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43027
43028 wxPyEndAllowThreads(__tstate);
43029 if (PyErr_Occurred()) SWIG_fail;
43030 }
43031 Py_INCREF(Py_None); resultobj = Py_None;
43032 return resultobj;
43033 fail:
43034 return NULL;
43035 }
43036
43037
43038 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43039 PyObject *resultobj;
43040 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43041 wxWindow *arg2 = (wxWindow *) 0 ;
43042 wxEdge arg3 ;
43043 int arg4 ;
43044 PyObject * obj0 = 0 ;
43045 PyObject * obj1 = 0 ;
43046 PyObject * obj2 = 0 ;
43047 PyObject * obj3 = 0 ;
43048 char *kwnames[] = {
43049 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43050 };
43051
43052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43054 if (SWIG_arg_fail(1)) SWIG_fail;
43055 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43056 if (SWIG_arg_fail(2)) SWIG_fail;
43057 {
43058 arg3 = (wxEdge)(SWIG_As_int(obj2));
43059 if (SWIG_arg_fail(3)) SWIG_fail;
43060 }
43061 {
43062 arg4 = (int)(SWIG_As_int(obj3));
43063 if (SWIG_arg_fail(4)) SWIG_fail;
43064 }
43065 {
43066 PyThreadState* __tstate = wxPyBeginAllowThreads();
43067 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43068
43069 wxPyEndAllowThreads(__tstate);
43070 if (PyErr_Occurred()) SWIG_fail;
43071 }
43072 Py_INCREF(Py_None); resultobj = Py_None;
43073 return resultobj;
43074 fail:
43075 return NULL;
43076 }
43077
43078
43079 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43080 PyObject *resultobj;
43081 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43082 int arg2 ;
43083 PyObject * obj0 = 0 ;
43084 PyObject * obj1 = 0 ;
43085 char *kwnames[] = {
43086 (char *) "self",(char *) "val", NULL
43087 };
43088
43089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43091 if (SWIG_arg_fail(1)) SWIG_fail;
43092 {
43093 arg2 = (int)(SWIG_As_int(obj1));
43094 if (SWIG_arg_fail(2)) SWIG_fail;
43095 }
43096 {
43097 PyThreadState* __tstate = wxPyBeginAllowThreads();
43098 (arg1)->Absolute(arg2);
43099
43100 wxPyEndAllowThreads(__tstate);
43101 if (PyErr_Occurred()) SWIG_fail;
43102 }
43103 Py_INCREF(Py_None); resultobj = Py_None;
43104 return resultobj;
43105 fail:
43106 return NULL;
43107 }
43108
43109
43110 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43111 PyObject *resultobj;
43112 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43113 PyObject * obj0 = 0 ;
43114 char *kwnames[] = {
43115 (char *) "self", NULL
43116 };
43117
43118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43120 if (SWIG_arg_fail(1)) SWIG_fail;
43121 {
43122 PyThreadState* __tstate = wxPyBeginAllowThreads();
43123 (arg1)->Unconstrained();
43124
43125 wxPyEndAllowThreads(__tstate);
43126 if (PyErr_Occurred()) SWIG_fail;
43127 }
43128 Py_INCREF(Py_None); resultobj = Py_None;
43129 return resultobj;
43130 fail:
43131 return NULL;
43132 }
43133
43134
43135 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43136 PyObject *resultobj;
43137 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43138 PyObject * obj0 = 0 ;
43139 char *kwnames[] = {
43140 (char *) "self", NULL
43141 };
43142
43143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43145 if (SWIG_arg_fail(1)) SWIG_fail;
43146 {
43147 PyThreadState* __tstate = wxPyBeginAllowThreads();
43148 (arg1)->AsIs();
43149
43150 wxPyEndAllowThreads(__tstate);
43151 if (PyErr_Occurred()) SWIG_fail;
43152 }
43153 Py_INCREF(Py_None); resultobj = Py_None;
43154 return resultobj;
43155 fail:
43156 return NULL;
43157 }
43158
43159
43160 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43161 PyObject *resultobj;
43162 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43163 wxWindow *result;
43164 PyObject * obj0 = 0 ;
43165 char *kwnames[] = {
43166 (char *) "self", NULL
43167 };
43168
43169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
43170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43171 if (SWIG_arg_fail(1)) SWIG_fail;
43172 {
43173 PyThreadState* __tstate = wxPyBeginAllowThreads();
43174 result = (wxWindow *)(arg1)->GetOtherWindow();
43175
43176 wxPyEndAllowThreads(__tstate);
43177 if (PyErr_Occurred()) SWIG_fail;
43178 }
43179 {
43180 resultobj = wxPyMake_wxObject(result, 0);
43181 }
43182 return resultobj;
43183 fail:
43184 return NULL;
43185 }
43186
43187
43188 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43189 PyObject *resultobj;
43190 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43191 wxEdge result;
43192 PyObject * obj0 = 0 ;
43193 char *kwnames[] = {
43194 (char *) "self", NULL
43195 };
43196
43197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
43198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43199 if (SWIG_arg_fail(1)) SWIG_fail;
43200 {
43201 PyThreadState* __tstate = wxPyBeginAllowThreads();
43202 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
43203
43204 wxPyEndAllowThreads(__tstate);
43205 if (PyErr_Occurred()) SWIG_fail;
43206 }
43207 resultobj = SWIG_From_int((result));
43208 return resultobj;
43209 fail:
43210 return NULL;
43211 }
43212
43213
43214 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43215 PyObject *resultobj;
43216 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43217 wxEdge arg2 ;
43218 PyObject * obj0 = 0 ;
43219 PyObject * obj1 = 0 ;
43220 char *kwnames[] = {
43221 (char *) "self",(char *) "which", NULL
43222 };
43223
43224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
43225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43226 if (SWIG_arg_fail(1)) SWIG_fail;
43227 {
43228 arg2 = (wxEdge)(SWIG_As_int(obj1));
43229 if (SWIG_arg_fail(2)) SWIG_fail;
43230 }
43231 {
43232 PyThreadState* __tstate = wxPyBeginAllowThreads();
43233 (arg1)->SetEdge((wxEdge )arg2);
43234
43235 wxPyEndAllowThreads(__tstate);
43236 if (PyErr_Occurred()) SWIG_fail;
43237 }
43238 Py_INCREF(Py_None); resultobj = Py_None;
43239 return resultobj;
43240 fail:
43241 return NULL;
43242 }
43243
43244
43245 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43246 PyObject *resultobj;
43247 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43248 int arg2 ;
43249 PyObject * obj0 = 0 ;
43250 PyObject * obj1 = 0 ;
43251 char *kwnames[] = {
43252 (char *) "self",(char *) "v", NULL
43253 };
43254
43255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
43256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43257 if (SWIG_arg_fail(1)) SWIG_fail;
43258 {
43259 arg2 = (int)(SWIG_As_int(obj1));
43260 if (SWIG_arg_fail(2)) SWIG_fail;
43261 }
43262 {
43263 PyThreadState* __tstate = wxPyBeginAllowThreads();
43264 (arg1)->SetValue(arg2);
43265
43266 wxPyEndAllowThreads(__tstate);
43267 if (PyErr_Occurred()) SWIG_fail;
43268 }
43269 Py_INCREF(Py_None); resultobj = Py_None;
43270 return resultobj;
43271 fail:
43272 return NULL;
43273 }
43274
43275
43276 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43277 PyObject *resultobj;
43278 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43279 int result;
43280 PyObject * obj0 = 0 ;
43281 char *kwnames[] = {
43282 (char *) "self", NULL
43283 };
43284
43285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
43286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43287 if (SWIG_arg_fail(1)) SWIG_fail;
43288 {
43289 PyThreadState* __tstate = wxPyBeginAllowThreads();
43290 result = (int)(arg1)->GetMargin();
43291
43292 wxPyEndAllowThreads(__tstate);
43293 if (PyErr_Occurred()) SWIG_fail;
43294 }
43295 {
43296 resultobj = SWIG_From_int((int)(result));
43297 }
43298 return resultobj;
43299 fail:
43300 return NULL;
43301 }
43302
43303
43304 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43305 PyObject *resultobj;
43306 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43307 int arg2 ;
43308 PyObject * obj0 = 0 ;
43309 PyObject * obj1 = 0 ;
43310 char *kwnames[] = {
43311 (char *) "self",(char *) "m", NULL
43312 };
43313
43314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
43315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43316 if (SWIG_arg_fail(1)) SWIG_fail;
43317 {
43318 arg2 = (int)(SWIG_As_int(obj1));
43319 if (SWIG_arg_fail(2)) SWIG_fail;
43320 }
43321 {
43322 PyThreadState* __tstate = wxPyBeginAllowThreads();
43323 (arg1)->SetMargin(arg2);
43324
43325 wxPyEndAllowThreads(__tstate);
43326 if (PyErr_Occurred()) SWIG_fail;
43327 }
43328 Py_INCREF(Py_None); resultobj = Py_None;
43329 return resultobj;
43330 fail:
43331 return NULL;
43332 }
43333
43334
43335 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43336 PyObject *resultobj;
43337 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43338 int result;
43339 PyObject * obj0 = 0 ;
43340 char *kwnames[] = {
43341 (char *) "self", NULL
43342 };
43343
43344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
43345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43346 if (SWIG_arg_fail(1)) SWIG_fail;
43347 {
43348 PyThreadState* __tstate = wxPyBeginAllowThreads();
43349 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
43350
43351 wxPyEndAllowThreads(__tstate);
43352 if (PyErr_Occurred()) SWIG_fail;
43353 }
43354 {
43355 resultobj = SWIG_From_int((int)(result));
43356 }
43357 return resultobj;
43358 fail:
43359 return NULL;
43360 }
43361
43362
43363 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
43364 PyObject *resultobj;
43365 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43366 int result;
43367 PyObject * obj0 = 0 ;
43368 char *kwnames[] = {
43369 (char *) "self", NULL
43370 };
43371
43372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
43373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43374 if (SWIG_arg_fail(1)) SWIG_fail;
43375 {
43376 PyThreadState* __tstate = wxPyBeginAllowThreads();
43377 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
43378
43379 wxPyEndAllowThreads(__tstate);
43380 if (PyErr_Occurred()) SWIG_fail;
43381 }
43382 {
43383 resultobj = SWIG_From_int((int)(result));
43384 }
43385 return resultobj;
43386 fail:
43387 return NULL;
43388 }
43389
43390
43391 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43392 PyObject *resultobj;
43393 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43394 int result;
43395 PyObject * obj0 = 0 ;
43396 char *kwnames[] = {
43397 (char *) "self", NULL
43398 };
43399
43400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
43401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43402 if (SWIG_arg_fail(1)) SWIG_fail;
43403 {
43404 PyThreadState* __tstate = wxPyBeginAllowThreads();
43405 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
43406
43407 wxPyEndAllowThreads(__tstate);
43408 if (PyErr_Occurred()) SWIG_fail;
43409 }
43410 {
43411 resultobj = SWIG_From_int((int)(result));
43412 }
43413 return resultobj;
43414 fail:
43415 return NULL;
43416 }
43417
43418
43419 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43420 PyObject *resultobj;
43421 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43422 bool result;
43423 PyObject * obj0 = 0 ;
43424 char *kwnames[] = {
43425 (char *) "self", NULL
43426 };
43427
43428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
43429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43430 if (SWIG_arg_fail(1)) SWIG_fail;
43431 {
43432 PyThreadState* __tstate = wxPyBeginAllowThreads();
43433 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
43434
43435 wxPyEndAllowThreads(__tstate);
43436 if (PyErr_Occurred()) SWIG_fail;
43437 }
43438 {
43439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43440 }
43441 return resultobj;
43442 fail:
43443 return NULL;
43444 }
43445
43446
43447 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43448 PyObject *resultobj;
43449 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43450 bool arg2 ;
43451 PyObject * obj0 = 0 ;
43452 PyObject * obj1 = 0 ;
43453 char *kwnames[] = {
43454 (char *) "self",(char *) "d", NULL
43455 };
43456
43457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
43458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43459 if (SWIG_arg_fail(1)) SWIG_fail;
43460 {
43461 arg2 = (bool)(SWIG_As_bool(obj1));
43462 if (SWIG_arg_fail(2)) SWIG_fail;
43463 }
43464 {
43465 PyThreadState* __tstate = wxPyBeginAllowThreads();
43466 (arg1)->SetDone(arg2);
43467
43468 wxPyEndAllowThreads(__tstate);
43469 if (PyErr_Occurred()) SWIG_fail;
43470 }
43471 Py_INCREF(Py_None); resultobj = Py_None;
43472 return resultobj;
43473 fail:
43474 return NULL;
43475 }
43476
43477
43478 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43479 PyObject *resultobj;
43480 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43481 wxRelationship result;
43482 PyObject * obj0 = 0 ;
43483 char *kwnames[] = {
43484 (char *) "self", NULL
43485 };
43486
43487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
43488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43489 if (SWIG_arg_fail(1)) SWIG_fail;
43490 {
43491 PyThreadState* __tstate = wxPyBeginAllowThreads();
43492 result = (wxRelationship)(arg1)->GetRelationship();
43493
43494 wxPyEndAllowThreads(__tstate);
43495 if (PyErr_Occurred()) SWIG_fail;
43496 }
43497 resultobj = SWIG_From_int((result));
43498 return resultobj;
43499 fail:
43500 return NULL;
43501 }
43502
43503
43504 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43505 PyObject *resultobj;
43506 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43507 wxRelationship arg2 ;
43508 PyObject * obj0 = 0 ;
43509 PyObject * obj1 = 0 ;
43510 char *kwnames[] = {
43511 (char *) "self",(char *) "r", NULL
43512 };
43513
43514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
43515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43516 if (SWIG_arg_fail(1)) SWIG_fail;
43517 {
43518 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43519 if (SWIG_arg_fail(2)) SWIG_fail;
43520 }
43521 {
43522 PyThreadState* __tstate = wxPyBeginAllowThreads();
43523 (arg1)->SetRelationship((wxRelationship )arg2);
43524
43525 wxPyEndAllowThreads(__tstate);
43526 if (PyErr_Occurred()) SWIG_fail;
43527 }
43528 Py_INCREF(Py_None); resultobj = Py_None;
43529 return resultobj;
43530 fail:
43531 return NULL;
43532 }
43533
43534
43535 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
43536 PyObject *resultobj;
43537 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43538 wxWindow *arg2 = (wxWindow *) 0 ;
43539 bool result;
43540 PyObject * obj0 = 0 ;
43541 PyObject * obj1 = 0 ;
43542 char *kwnames[] = {
43543 (char *) "self",(char *) "otherW", NULL
43544 };
43545
43546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
43547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43548 if (SWIG_arg_fail(1)) SWIG_fail;
43549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43550 if (SWIG_arg_fail(2)) SWIG_fail;
43551 {
43552 PyThreadState* __tstate = wxPyBeginAllowThreads();
43553 result = (bool)(arg1)->ResetIfWin(arg2);
43554
43555 wxPyEndAllowThreads(__tstate);
43556 if (PyErr_Occurred()) SWIG_fail;
43557 }
43558 {
43559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43560 }
43561 return resultobj;
43562 fail:
43563 return NULL;
43564 }
43565
43566
43567 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
43568 PyObject *resultobj;
43569 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43570 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
43571 wxWindow *arg3 = (wxWindow *) 0 ;
43572 bool result;
43573 PyObject * obj0 = 0 ;
43574 PyObject * obj1 = 0 ;
43575 PyObject * obj2 = 0 ;
43576 char *kwnames[] = {
43577 (char *) "self",(char *) "constraints",(char *) "win", NULL
43578 };
43579
43580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
43581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43582 if (SWIG_arg_fail(1)) SWIG_fail;
43583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43584 if (SWIG_arg_fail(2)) SWIG_fail;
43585 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43586 if (SWIG_arg_fail(3)) SWIG_fail;
43587 {
43588 PyThreadState* __tstate = wxPyBeginAllowThreads();
43589 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
43590
43591 wxPyEndAllowThreads(__tstate);
43592 if (PyErr_Occurred()) SWIG_fail;
43593 }
43594 {
43595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43596 }
43597 return resultobj;
43598 fail:
43599 return NULL;
43600 }
43601
43602
43603 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43604 PyObject *resultobj;
43605 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43606 wxEdge arg2 ;
43607 wxWindow *arg3 = (wxWindow *) 0 ;
43608 wxWindow *arg4 = (wxWindow *) 0 ;
43609 int result;
43610 PyObject * obj0 = 0 ;
43611 PyObject * obj1 = 0 ;
43612 PyObject * obj2 = 0 ;
43613 PyObject * obj3 = 0 ;
43614 char *kwnames[] = {
43615 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
43616 };
43617
43618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43620 if (SWIG_arg_fail(1)) SWIG_fail;
43621 {
43622 arg2 = (wxEdge)(SWIG_As_int(obj1));
43623 if (SWIG_arg_fail(2)) SWIG_fail;
43624 }
43625 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43626 if (SWIG_arg_fail(3)) SWIG_fail;
43627 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43628 if (SWIG_arg_fail(4)) SWIG_fail;
43629 {
43630 PyThreadState* __tstate = wxPyBeginAllowThreads();
43631 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
43632
43633 wxPyEndAllowThreads(__tstate);
43634 if (PyErr_Occurred()) SWIG_fail;
43635 }
43636 {
43637 resultobj = SWIG_From_int((int)(result));
43638 }
43639 return resultobj;
43640 fail:
43641 return NULL;
43642 }
43643
43644
43645 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
43646 PyObject *obj;
43647 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43648 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
43649 Py_INCREF(obj);
43650 return Py_BuildValue((char *)"");
43651 }
43652 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
43653 PyObject *resultobj;
43654 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43655 wxIndividualLayoutConstraint *result;
43656 PyObject * obj0 = 0 ;
43657 char *kwnames[] = {
43658 (char *) "self", NULL
43659 };
43660
43661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
43662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43663 if (SWIG_arg_fail(1)) SWIG_fail;
43664 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
43665
43666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43667 return resultobj;
43668 fail:
43669 return NULL;
43670 }
43671
43672
43673 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
43674 PyObject *resultobj;
43675 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43676 wxIndividualLayoutConstraint *result;
43677 PyObject * obj0 = 0 ;
43678 char *kwnames[] = {
43679 (char *) "self", NULL
43680 };
43681
43682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
43683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43684 if (SWIG_arg_fail(1)) SWIG_fail;
43685 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
43686
43687 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43688 return resultobj;
43689 fail:
43690 return NULL;
43691 }
43692
43693
43694 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
43695 PyObject *resultobj;
43696 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43697 wxIndividualLayoutConstraint *result;
43698 PyObject * obj0 = 0 ;
43699 char *kwnames[] = {
43700 (char *) "self", NULL
43701 };
43702
43703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
43704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43705 if (SWIG_arg_fail(1)) SWIG_fail;
43706 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
43707
43708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43709 return resultobj;
43710 fail:
43711 return NULL;
43712 }
43713
43714
43715 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
43716 PyObject *resultobj;
43717 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43718 wxIndividualLayoutConstraint *result;
43719 PyObject * obj0 = 0 ;
43720 char *kwnames[] = {
43721 (char *) "self", NULL
43722 };
43723
43724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
43725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43726 if (SWIG_arg_fail(1)) SWIG_fail;
43727 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
43728
43729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43730 return resultobj;
43731 fail:
43732 return NULL;
43733 }
43734
43735
43736 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
43737 PyObject *resultobj;
43738 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43739 wxIndividualLayoutConstraint *result;
43740 PyObject * obj0 = 0 ;
43741 char *kwnames[] = {
43742 (char *) "self", NULL
43743 };
43744
43745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
43746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43747 if (SWIG_arg_fail(1)) SWIG_fail;
43748 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
43749
43750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43751 return resultobj;
43752 fail:
43753 return NULL;
43754 }
43755
43756
43757 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
43758 PyObject *resultobj;
43759 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43760 wxIndividualLayoutConstraint *result;
43761 PyObject * obj0 = 0 ;
43762 char *kwnames[] = {
43763 (char *) "self", NULL
43764 };
43765
43766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
43767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43768 if (SWIG_arg_fail(1)) SWIG_fail;
43769 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
43770
43771 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43772 return resultobj;
43773 fail:
43774 return NULL;
43775 }
43776
43777
43778 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
43779 PyObject *resultobj;
43780 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43781 wxIndividualLayoutConstraint *result;
43782 PyObject * obj0 = 0 ;
43783 char *kwnames[] = {
43784 (char *) "self", NULL
43785 };
43786
43787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
43788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43789 if (SWIG_arg_fail(1)) SWIG_fail;
43790 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
43791
43792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43793 return resultobj;
43794 fail:
43795 return NULL;
43796 }
43797
43798
43799 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
43800 PyObject *resultobj;
43801 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43802 wxIndividualLayoutConstraint *result;
43803 PyObject * obj0 = 0 ;
43804 char *kwnames[] = {
43805 (char *) "self", NULL
43806 };
43807
43808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
43809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43810 if (SWIG_arg_fail(1)) SWIG_fail;
43811 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
43812
43813 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43814 return resultobj;
43815 fail:
43816 return NULL;
43817 }
43818
43819
43820 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43821 PyObject *resultobj;
43822 wxLayoutConstraints *result;
43823 char *kwnames[] = {
43824 NULL
43825 };
43826
43827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
43828 {
43829 PyThreadState* __tstate = wxPyBeginAllowThreads();
43830 result = (wxLayoutConstraints *)new wxLayoutConstraints();
43831
43832 wxPyEndAllowThreads(__tstate);
43833 if (PyErr_Occurred()) SWIG_fail;
43834 }
43835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
43836 return resultobj;
43837 fail:
43838 return NULL;
43839 }
43840
43841
43842 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43843 PyObject *resultobj;
43844 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43845 wxWindow *arg2 = (wxWindow *) 0 ;
43846 int *arg3 = (int *) 0 ;
43847 bool result;
43848 int temp3 ;
43849 int res3 = 0 ;
43850 PyObject * obj0 = 0 ;
43851 PyObject * obj1 = 0 ;
43852 char *kwnames[] = {
43853 (char *) "self",(char *) "win", NULL
43854 };
43855
43856 arg3 = &temp3; res3 = SWIG_NEWOBJ;
43857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
43858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43859 if (SWIG_arg_fail(1)) SWIG_fail;
43860 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43861 if (SWIG_arg_fail(2)) SWIG_fail;
43862 {
43863 PyThreadState* __tstate = wxPyBeginAllowThreads();
43864 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
43865
43866 wxPyEndAllowThreads(__tstate);
43867 if (PyErr_Occurred()) SWIG_fail;
43868 }
43869 {
43870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43871 }
43872 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
43873 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
43874 return resultobj;
43875 fail:
43876 return NULL;
43877 }
43878
43879
43880 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
43881 PyObject *resultobj;
43882 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43883 bool result;
43884 PyObject * obj0 = 0 ;
43885 char *kwnames[] = {
43886 (char *) "self", NULL
43887 };
43888
43889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
43890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43891 if (SWIG_arg_fail(1)) SWIG_fail;
43892 {
43893 PyThreadState* __tstate = wxPyBeginAllowThreads();
43894 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
43895
43896 wxPyEndAllowThreads(__tstate);
43897 if (PyErr_Occurred()) SWIG_fail;
43898 }
43899 {
43900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43901 }
43902 return resultobj;
43903 fail:
43904 return NULL;
43905 }
43906
43907
43908 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
43909 PyObject *obj;
43910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43911 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
43912 Py_INCREF(obj);
43913 return Py_BuildValue((char *)"");
43914 }
43915 static PyMethodDef SwigMethods[] = {
43916 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
43917 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
43918 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
43919 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
43920 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
43921 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
43922 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
43923 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
43924 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
43925 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
43926 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
43927 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43928 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43929 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43930 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43931 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
43932 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
43933 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43934 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43935 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43936 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43937 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43938 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
43939 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
43940 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43941 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
43942 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43943 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43944 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43945 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43946 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43947 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43948 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43949 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43950 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43951 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43952 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43953 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43954 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
43955 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43956 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43957 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43958 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43959 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
43960 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
43961 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43962 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43963 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43964 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43965 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43966 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
43967 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43968 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43969 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
43970 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
43971 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
43972 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
43973 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
43974 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
43975 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
43976 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
43977 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
43978 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
43979 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43980 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43981 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43982 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43983 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43984 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43985 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
43986 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
43987 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43988 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43989 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
43990 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
43991 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43992 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
43993 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
43994 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
43995 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43996 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
43997 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
43998 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
43999 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44000 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44001 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44002 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44003 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44004 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44005 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44006 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44007 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44008 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44009 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44010 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44011 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44012 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44013 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44014 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44015 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44016 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44017 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44018 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44019 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44020 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44021 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44022 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44023 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44024 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44025 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44026 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44027 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44028 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44029 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44030 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44031 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44032 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44033 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44034 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44035 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44036 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44037 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44038 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44039 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44040 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44041 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44042 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44043 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44044 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44045 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44046 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44047 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44048 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44049 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44050 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44051 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44052 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44053 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44054 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44055 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44056 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44057 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44058 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44059 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44060 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44061 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44062 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44063 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44064 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44065 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44066 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44067 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44068 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44069 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44070 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44071 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44072 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44073 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44074 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44075 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44076 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44077 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44078 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44079 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44080 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44081 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44082 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44083 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44084 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44085 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44086 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44087 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44088 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44089 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44090 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44091 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44092 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44093 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44094 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44095 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44096 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44097 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44098 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44099 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44100 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44101 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44102 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44103 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44104 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44105 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44106 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44107 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44108 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44109 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44110 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44111 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44112 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44113 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44114 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44115 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44116 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44117 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44118 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44119 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44120 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44121 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44122 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44123 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44124 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44125 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44126 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44127 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44128 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44129 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44130 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44131 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44132 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44133 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44134 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44135 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44136 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44137 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44138 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44139 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44140 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44141 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44142 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44143 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44144 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44145 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44146 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44147 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44148 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44149 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44150 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44151 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44152 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44153 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44154 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44155 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44156 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44157 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44158 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44159 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44160 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44161 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
44162 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44163 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
44164 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44165 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
44166 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
44167 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44168 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44169 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44170 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44171 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44172 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
44173 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44174 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44175 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44176 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44177 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
44178 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
44179 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
44180 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
44181 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
44182 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44183 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44184 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44185 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44186 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44187 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44188 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
44189 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
44190 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44191 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44192 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
44193 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
44194 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
44195 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
44196 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
44197 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44198 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
44199 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44200 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44201 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44202 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44203 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
44204 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
44205 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44206 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44207 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44208 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44209 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
44210 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44211 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44212 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
44213 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44214 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
44215 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44216 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
44217 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44218 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
44219 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44220 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
44221 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44222 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
44223 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44224 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
44225 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44226 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
44227 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44228 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
44229 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44230 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
44231 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44232 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
44233 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44234 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
44235 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
44236 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
44237 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44238 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44239 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44240 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44241 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44242 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44243 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44244 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44245 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44246 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44247 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
44248 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
44249 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44250 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
44251 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44252 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
44253 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44254 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44255 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44256 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44257 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44258 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44259 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44260 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44261 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44262 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
44263 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
44264 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
44265 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44266 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44267 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44268 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
44269 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44270 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44271 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
44272 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44273 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44274 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
44275 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44276 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44277 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44278 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44279 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44280 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44281 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44282 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44283 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44284 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44285 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44286 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
44287 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44288 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44289 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
44290 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
44291 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
44292 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44293 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44294 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44295 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44296 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44297 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
44298 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44299 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44300 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44301 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44302 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44303 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
44304 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44305 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
44306 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
44307 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44308 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
44309 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
44310 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44311 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
44312 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44313 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44314 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44315 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44316 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44317 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44318 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
44319 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
44320 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
44321 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
44322 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
44323 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44324 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44325 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44326 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44327 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44328 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44329 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
44330 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
44331 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
44332 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
44333 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44334 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44335 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44336 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44337 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44338 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
44339 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
44340 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
44341 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
44342 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44343 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44344 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44345 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44346 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44347 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44348 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44349 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44350 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44351 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44352 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44353 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44354 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44355 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44356 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44357 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44358 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44359 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44360 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
44361 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
44362 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
44363 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
44364 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
44365 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
44366 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
44367 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44368 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44369 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44370 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44371 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44372 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44373 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
44374 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44375 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44376 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44377 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44378 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44379 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44380 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
44381 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44382 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44383 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44384 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44385 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44386 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44387 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44388 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44389 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44390 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44391 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44392 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44393 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44394 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44395 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44396 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44397 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44398 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44399 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44400 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44401 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44402 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44403 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44404 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44405 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44406 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44407 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
44408 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
44409 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
44410 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44411 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44412 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44413 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44414 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44415 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
44416 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
44417 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44418 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44419 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
44420 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44421 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44422 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44423 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44424 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44425 { (char *)"MoveEvent_m_pos_set", (PyCFunction) _wrap_MoveEvent_m_pos_set, METH_VARARGS | METH_KEYWORDS, NULL},
44426 { (char *)"MoveEvent_m_pos_get", (PyCFunction) _wrap_MoveEvent_m_pos_get, METH_VARARGS | METH_KEYWORDS, NULL},
44427 { (char *)"MoveEvent_m_rect_set", (PyCFunction) _wrap_MoveEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44428 { (char *)"MoveEvent_m_rect_get", (PyCFunction) _wrap_MoveEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44429 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
44430 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44431 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
44432 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44433 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
44434 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44435 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
44436 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
44437 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44438 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44439 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44440 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
44441 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44442 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44443 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
44444 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44445 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44446 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
44447 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44448 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
44449 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44450 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
44451 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
44452 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44453 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
44454 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44455 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44456 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44457 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44458 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44459 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44460 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44461 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
44462 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44463 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44464 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44465 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
44466 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44467 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
44468 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
44469 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44470 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
44471 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44472 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44473 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44474 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
44475 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44476 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44477 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44478 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44479 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
44480 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44481 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44482 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44483 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44484 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44485 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44486 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44487 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
44488 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
44489 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44490 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44491 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
44492 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44493 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
44494 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44495 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44496 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
44497 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44498 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
44499 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44500 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44501 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44502 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
44503 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44504 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44505 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44506 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
44507 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44508 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44509 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44510 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44511 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44512 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44513 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44514 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44515 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
44516 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44517 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44518 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
44519 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44520 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44521 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
44522 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44523 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44524 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44525 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
44526 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44527 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
44528 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
44529 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44530 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44531 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
44532 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
44533 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44534 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44535 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44536 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44537 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
44538 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44539 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44540 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44541 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44542 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
44543 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44544 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44545 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44546 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44547 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44548 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44549 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44550 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44551 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44552 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
44553 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44554 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44555 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44556 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44557 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44558 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44559 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44560 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44561 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44562 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44563 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44564 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
44565 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44566 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44567 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44568 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44569 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44570 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44571 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44572 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44573 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44574 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44575 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44576 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44577 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44578 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44579 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44580 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44581 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44582 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44583 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44584 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44585 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
44586 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
44587 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
44588 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44589 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44590 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
44591 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
44592 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44593 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44594 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
44595 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
44596 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44597 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44598 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44599 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44600 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
44601 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44602 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44603 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44604 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44605 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44606 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44607 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
44608 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44609 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44610 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44611 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44612 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44613 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
44614 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
44615 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44616 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44617 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44618 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
44619 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
44620 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44621 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44622 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
44623 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
44624 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44625 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44626 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44627 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44628 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
44629 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
44630 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44631 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44632 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
44633 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44634 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44635 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
44636 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44637 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44638 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44639 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44640 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44641 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44642 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44643 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44644 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44645 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44646 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44647 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44648 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44649 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44650 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
44651 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44652 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44653 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
44654 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
44655 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44656 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
44657 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
44658 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44659 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44660 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44661 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44662 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44663 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44664 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44665 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44666 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44667 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44668 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
44669 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44670 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44671 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44672 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44673 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44674 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44675 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
44676 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44677 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
44678 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
44679 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
44680 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44681 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44682 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44683 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44684 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44685 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44686 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44687 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44688 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44689 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44690 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44691 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44692 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44693 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44694 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44695 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44696 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44697 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44698 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
44699 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44700 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
44701 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44702 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44703 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44704 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44705 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44706 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
44707 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44708 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44709 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
44710 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44711 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44712 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44713 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
44714 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44715 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44716 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
44717 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44718 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44719 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44720 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
44721 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44722 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44723 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44724 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44725 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
44726 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
44727 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
44728 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
44729 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
44730 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44731 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44732 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44734 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44735 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44736 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44737 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44738 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44739 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44740 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44741 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44742 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44744 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44745 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44746 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44748 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44749 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
44750 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
44751 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44752 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
44754 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44756 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44757 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44758 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
44759 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
44761 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
44762 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
44764 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
44768 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44772 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
44785 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
44799 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
44839 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
44853 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
44856 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
44911 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
44938 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
44968 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
44976 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
44993 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
44994 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45031 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45061 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45064 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45068 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45071 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45081 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
45093 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"StdDialogButtonSizer_Finalise", (PyCFunction) _wrap_StdDialogButtonSizer_Finalise, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45105 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45115 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45125 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
45139 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
45146 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
45147 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
45148 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
45149 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
45150 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
45155 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
45182 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
45194 { NULL, NULL, 0, NULL }
45195 };
45196
45197
45198 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
45199
45200 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
45201 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
45202 }
45203 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
45204 return (void *)((wxSizer *) ((wxBoxSizer *) x));
45205 }
45206 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
45207 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
45208 }
45209 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
45210 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45211 }
45212 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
45213 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45214 }
45215 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
45216 return (void *)((wxSizer *) ((wxGridSizer *) x));
45217 }
45218 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
45219 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
45220 }
45221 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
45222 return (void *)((wxSizer *) ((wxPySizer *) x));
45223 }
45224 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
45225 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
45226 }
45227 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
45228 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45229 }
45230 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
45231 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
45232 }
45233 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
45234 return (void *)((wxEvent *) ((wxMenuEvent *) x));
45235 }
45236 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
45237 return (void *)((wxEvent *) ((wxCloseEvent *) x));
45238 }
45239 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
45240 return (void *)((wxEvent *) ((wxMouseEvent *) x));
45241 }
45242 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
45243 return (void *)((wxEvent *) ((wxEraseEvent *) x));
45244 }
45245 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
45246 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
45247 }
45248 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
45249 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
45250 }
45251 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
45252 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
45253 }
45254 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
45255 return (void *)((wxEvent *) ((wxPyEvent *) x));
45256 }
45257 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
45258 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
45259 }
45260 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
45261 return (void *)((wxEvent *) ((wxIdleEvent *) x));
45262 }
45263 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
45264 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
45265 }
45266 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
45267 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
45268 }
45269 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
45270 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
45271 }
45272 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
45273 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
45274 }
45275 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
45276 return (void *)((wxEvent *) ((wxActivateEvent *) x));
45277 }
45278 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
45279 return (void *)((wxEvent *) ((wxSizeEvent *) x));
45280 }
45281 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
45282 return (void *)((wxEvent *) ((wxMoveEvent *) x));
45283 }
45284 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
45285 return (void *)((wxEvent *) ((wxPaintEvent *) x));
45286 }
45287 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
45288 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
45289 }
45290 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
45291 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
45292 }
45293 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
45294 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
45295 }
45296 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
45297 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
45298 }
45299 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
45300 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45301 }
45302 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
45303 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
45304 }
45305 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
45306 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
45307 }
45308 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
45309 return (void *)((wxEvent *) ((wxFocusEvent *) x));
45310 }
45311 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
45312 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
45313 }
45314 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
45315 return (void *)((wxEvent *) ((wxShowEvent *) x));
45316 }
45317 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
45318 return (void *)((wxEvent *) ((wxCommandEvent *) x));
45319 }
45320 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
45321 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
45322 }
45323 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
45324 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45325 }
45326 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
45327 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
45328 }
45329 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
45330 return (void *)((wxEvent *) ((wxKeyEvent *) x));
45331 }
45332 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
45333 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
45334 }
45335 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
45336 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
45337 }
45338 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
45339 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
45340 }
45341 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
45342 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
45343 }
45344 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
45345 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
45346 }
45347 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
45348 return (void *)((wxControl *) ((wxControlWithItems *) x));
45349 }
45350 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
45351 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
45352 }
45353 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
45354 return (void *)((wxEvtHandler *) ((wxWindow *) x));
45355 }
45356 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
45357 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45358 }
45359 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
45360 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
45361 }
45362 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
45363 return (void *)((wxEvtHandler *) ((wxValidator *) x));
45364 }
45365 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
45366 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
45367 }
45368 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
45369 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
45370 }
45371 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
45372 return (void *)((wxEvtHandler *) ((wxMenu *) x));
45373 }
45374 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
45375 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
45376 }
45377 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
45378 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
45379 }
45380 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
45381 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
45382 }
45383 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
45384 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
45385 }
45386 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
45387 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
45388 }
45389 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
45390 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45391 }
45392 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
45393 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
45394 }
45395 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
45396 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
45397 }
45398 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
45399 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45400 }
45401 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
45402 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45403 }
45404 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
45405 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
45406 }
45407 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
45408 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
45409 }
45410 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
45411 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
45412 }
45413 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
45414 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
45415 }
45416 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
45417 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
45418 }
45419 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
45420 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
45421 }
45422 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
45423 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
45424 }
45425 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
45426 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
45427 }
45428 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
45429 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
45430 }
45431 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
45432 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
45433 }
45434 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
45435 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
45436 }
45437 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
45438 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
45439 }
45440 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
45441 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
45442 }
45443 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
45444 return (void *)((wxObject *) ((wxSizerItem *) x));
45445 }
45446 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
45447 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
45448 }
45449 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
45450 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
45451 }
45452 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
45453 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
45454 }
45455 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
45456 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
45457 }
45458 static void *_p_wxSizerTo_p_wxObject(void *x) {
45459 return (void *)((wxObject *) ((wxSizer *) x));
45460 }
45461 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
45462 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45463 }
45464 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
45465 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
45466 }
45467 static void *_p_wxEventTo_p_wxObject(void *x) {
45468 return (void *)((wxObject *) ((wxEvent *) x));
45469 }
45470 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
45471 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
45472 }
45473 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
45474 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
45475 }
45476 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
45477 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
45478 }
45479 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
45480 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
45481 }
45482 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
45483 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
45484 }
45485 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
45486 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
45487 }
45488 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
45489 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
45490 }
45491 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
45492 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45493 }
45494 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
45495 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
45496 }
45497 static void *_p_wxControlTo_p_wxObject(void *x) {
45498 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
45499 }
45500 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
45501 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
45502 }
45503 static void *_p_wxFSFileTo_p_wxObject(void *x) {
45504 return (void *)((wxObject *) ((wxFSFile *) x));
45505 }
45506 static void *_p_wxPySizerTo_p_wxObject(void *x) {
45507 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
45508 }
45509 static void *_p_wxPyEventTo_p_wxObject(void *x) {
45510 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
45511 }
45512 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
45513 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
45514 }
45515 static void *_p_wxShowEventTo_p_wxObject(void *x) {
45516 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
45517 }
45518 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
45519 return (void *)((wxObject *) ((wxMenuItem *) x));
45520 }
45521 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
45522 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
45523 }
45524 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
45525 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
45526 }
45527 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
45528 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
45529 }
45530 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
45531 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
45532 }
45533 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
45534 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
45535 }
45536 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
45537 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
45538 }
45539 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
45540 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
45541 }
45542 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
45543 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
45544 }
45545 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
45546 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
45547 }
45548 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
45549 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
45550 }
45551 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
45552 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
45553 }
45554 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
45555 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
45556 }
45557 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
45558 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
45559 }
45560 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
45561 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
45562 }
45563 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
45564 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45565 }
45566 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
45567 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45568 }
45569 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
45570 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
45571 }
45572 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
45573 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
45574 }
45575 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
45576 return (void *)((wxObject *) ((wxImageHandler *) x));
45577 }
45578 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
45579 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
45580 }
45581 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
45582 return (void *)((wxObject *) ((wxEvtHandler *) x));
45583 }
45584 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
45585 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45586 }
45587 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
45588 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
45589 }
45590 static void *_p_wxImageTo_p_wxObject(void *x) {
45591 return (void *)((wxObject *) ((wxImage *) x));
45592 }
45593 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
45594 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
45595 }
45596 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
45597 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45598 }
45599 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
45600 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
45601 }
45602 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
45603 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
45604 }
45605 static void *_p_wxWindowTo_p_wxObject(void *x) {
45606 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
45607 }
45608 static void *_p_wxMenuTo_p_wxObject(void *x) {
45609 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
45610 }
45611 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
45612 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
45613 }
45614 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
45615 return (void *)((wxObject *) ((wxFileSystem *) x));
45616 }
45617 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
45618 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
45619 }
45620 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
45621 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
45622 }
45623 static void *_p_wxPyAppTo_p_wxObject(void *x) {
45624 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
45625 }
45626 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
45627 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
45628 }
45629 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
45630 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
45631 }
45632 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
45633 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
45634 }
45635 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
45636 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
45637 }
45638 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
45639 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
45640 }
45641 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
45642 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
45643 }
45644 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
45645 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
45646 }
45647 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
45648 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
45649 }
45650 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
45651 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45652 }
45653 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
45654 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
45655 }
45656 static void *_p_wxValidatorTo_p_wxObject(void *x) {
45657 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
45658 }
45659 static void *_p_wxControlTo_p_wxWindow(void *x) {
45660 return (void *)((wxWindow *) ((wxControl *) x));
45661 }
45662 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
45663 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
45664 }
45665 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
45666 return (void *)((wxWindow *) ((wxMenuBar *) x));
45667 }
45668 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
45669 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
45670 }
45671 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
45672 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
45673 }
45674 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
45675 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
45676 }
45677 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
45678 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
45679 }
45680 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
45681 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45682 }
45683 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
45684 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
45685 }
45686 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
45687 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
45688 }
45689 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
45690 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
45691 }
45692 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
45693 return (void *)((wxValidator *) ((wxPyValidator *) x));
45694 }
45695 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}};
45696 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}};
45697 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}};
45698 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}};
45699 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}};
45700 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}};
45701 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}};
45702 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}};
45703 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}};
45704 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}};
45705 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}};
45706 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}};
45707 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}};
45708 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45709 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}};
45710 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}};
45711 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}};
45712 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}};
45713 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}};
45714 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}};
45715 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}};
45716 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}};
45717 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}};
45718 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}};
45719 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}};
45720 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}};
45721 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}};
45722 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}};
45723 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}};
45724 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}};
45725 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}};
45726 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}};
45727 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}};
45728 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}};
45729 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}};
45730 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}};
45731 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}};
45732 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}};
45733 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}};
45734 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}};
45735 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}};
45736 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}};
45737 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}};
45738 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}};
45739 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}};
45740 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}};
45741 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}};
45742 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}};
45743 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}};
45744 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}};
45745 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}};
45746 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}};
45747 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}};
45748 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}};
45749 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}};
45750 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}};
45751 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}};
45752 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}};
45753 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}};
45754 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}};
45755 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}};
45756 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}};
45757 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}};
45758 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}};
45759 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}};
45760 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}};
45761 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}};
45762 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}};
45763 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}};
45764 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}};
45765 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}};
45766 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}};
45767 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}};
45768 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}};
45769 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}};
45770 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}};
45771 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}};
45772 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}};
45773 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}};
45774 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}};
45775 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}};
45776 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}};
45777 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}};
45778 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}};
45779 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}};
45780 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}};
45781 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}};
45782 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}};
45783 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}};
45784 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}};
45785 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}};
45786 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}};
45787 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}};
45788 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_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_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}};
45789 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}};
45790 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}};
45791 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}};
45792 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}};
45793 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}};
45794 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}};
45795 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}};
45796 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}};
45797 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}};
45798 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}};
45799 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}};
45800 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}};
45801 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}};
45802 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}};
45803 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}};
45804 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}};
45805 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45806 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}};
45807 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}};
45808 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}};
45809 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}};
45810 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45811 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}};
45812 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}};
45813 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}};
45814 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}};
45815 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}};
45816 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}};
45817 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}};
45818 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}};
45819 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}};
45820 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}};
45821
45822 static swig_type_info *swig_types_initial[] = {
45823 _swigt__p_wxLayoutConstraints,
45824 _swigt__p_wxRealPoint,
45825 _swigt__p_wxSizerItem,
45826 _swigt__p_wxGBSizerItem,
45827 _swigt__p_wxScrollEvent,
45828 _swigt__p_wxEventLoop,
45829 _swigt__p_wxIndividualLayoutConstraint,
45830 _swigt__p_wxSizer,
45831 _swigt__p_wxBoxSizer,
45832 _swigt__p_wxStaticBoxSizer,
45833 _swigt__p_wxGridBagSizer,
45834 _swigt__p_wxAcceleratorEntry,
45835 _swigt__p_wxUpdateUIEvent,
45836 _swigt__p_wxEvent,
45837 _swigt__p_wxMenu,
45838 _swigt__p_wxGridSizer,
45839 _swigt__p_wxFlexGridSizer,
45840 _swigt__p_wxInitDialogEvent,
45841 _swigt__p_wxItemContainer,
45842 _swigt__p_wxNcPaintEvent,
45843 _swigt__p_wxPaintEvent,
45844 _swigt__p_wxSysColourChangedEvent,
45845 _swigt__p_wxMouseCaptureChangedEvent,
45846 _swigt__p_wxDisplayChangedEvent,
45847 _swigt__p_wxPaletteChangedEvent,
45848 _swigt__p_wxControl,
45849 _swigt__p_wxFont,
45850 _swigt__p_wxMenuBarBase,
45851 _swigt__p_wxSetCursorEvent,
45852 _swigt__p_wxFSFile,
45853 _swigt__p_wxCaret,
45854 _swigt__ptrdiff_t,
45855 _swigt__std__ptrdiff_t,
45856 _swigt__p_wxRegion,
45857 _swigt__p_wxPoint2D,
45858 _swigt__p_int,
45859 _swigt__p_wxSize,
45860 _swigt__p_wxDC,
45861 _swigt__p_wxPySizer,
45862 _swigt__p_wxVisualAttributes,
45863 _swigt__p_wxNotifyEvent,
45864 _swigt__p_wxPyEvent,
45865 _swigt__p_wxPropagationDisabler,
45866 _swigt__p_form_ops_t,
45867 _swigt__p_wxAppTraits,
45868 _swigt__p_wxArrayString,
45869 _swigt__p_wxShowEvent,
45870 _swigt__p_wxToolTip,
45871 _swigt__p_wxMoveEvent,
45872 _swigt__p_wxSizeEvent,
45873 _swigt__p_wxActivateEvent,
45874 _swigt__p_wxIconizeEvent,
45875 _swigt__p_wxMaximizeEvent,
45876 _swigt__p_wxQueryNewPaletteEvent,
45877 _swigt__p_wxWindowCreateEvent,
45878 _swigt__p_wxIdleEvent,
45879 _swigt__p_wxMenuItem,
45880 _swigt__p_wxStaticBox,
45881 _swigt__p_long,
45882 _swigt__p_wxDuplexMode,
45883 _swigt__p_wxTIFFHandler,
45884 _swigt__p_wxXPMHandler,
45885 _swigt__p_wxPNMHandler,
45886 _swigt__p_wxJPEGHandler,
45887 _swigt__p_wxPCXHandler,
45888 _swigt__p_wxGIFHandler,
45889 _swigt__p_wxPNGHandler,
45890 _swigt__p_wxANIHandler,
45891 _swigt__p_wxMemoryFSHandler,
45892 _swigt__p_wxZipFSHandler,
45893 _swigt__p_wxInternetFSHandler,
45894 _swigt__p_wxPyFileSystemHandler,
45895 _swigt__p_wxEvtHandler,
45896 _swigt__p_wxCURHandler,
45897 _swigt__p_wxICOHandler,
45898 _swigt__p_wxBMPHandler,
45899 _swigt__p_wxImageHandler,
45900 _swigt__p_wxFileSystemHandler,
45901 _swigt__p_wxRect,
45902 _swigt__p_wxButton,
45903 _swigt__p_wxGBSpan,
45904 _swigt__p_wxPropagateOnce,
45905 _swigt__p_wxAcceleratorTable,
45906 _swigt__p_wxStdDialogButtonSizer,
45907 _swigt__p_char,
45908 _swigt__p_wxGBPosition,
45909 _swigt__p_wxImage,
45910 _swigt__p_wxFrame,
45911 _swigt__p_wxScrollWinEvent,
45912 _swigt__p_wxPaperSize,
45913 _swigt__p_wxImageHistogram,
45914 _swigt__p_wxPoint,
45915 _swigt__p_wxCursor,
45916 _swigt__p_wxObject,
45917 _swigt__p_wxInputStream,
45918 _swigt__p_wxOutputStream,
45919 _swigt__p_wxPyInputStream,
45920 _swigt__p_wxDateTime,
45921 _swigt__p_wxKeyEvent,
45922 _swigt__p_wxNavigationKeyEvent,
45923 _swigt__p_wxWindowDestroyEvent,
45924 _swigt__p_unsigned_long,
45925 _swigt__p_wxWindow,
45926 _swigt__p_wxMenuBar,
45927 _swigt__p_wxFileSystem,
45928 _swigt__p_wxBitmap,
45929 _swigt__unsigned_int,
45930 _swigt__p_unsigned_int,
45931 _swigt__p_wxMenuEvent,
45932 _swigt__p_wxContextMenuEvent,
45933 _swigt__p_unsigned_char,
45934 _swigt__p_wxEraseEvent,
45935 _swigt__p_wxMouseEvent,
45936 _swigt__p_wxCloseEvent,
45937 _swigt__p_wxPyApp,
45938 _swigt__p_wxCommandEvent,
45939 _swigt__p_wxPyCommandEvent,
45940 _swigt__p_wxPyDropTarget,
45941 _swigt__p_wxQuantize,
45942 _swigt__p_wxChildFocusEvent,
45943 _swigt__p_wxFocusEvent,
45944 _swigt__p_wxDropFilesEvent,
45945 _swigt__p_wxControlWithItems,
45946 _swigt__p_wxColour,
45947 _swigt__p_wxValidator,
45948 _swigt__p_wxPyValidator,
45949 0
45950 };
45951
45952
45953 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
45954
45955 static swig_const_info swig_const_table[] = {
45956 {0, 0, 0, 0.0, 0, 0}};
45957
45958 #ifdef __cplusplus
45959 }
45960 #endif
45961
45962
45963 #ifdef __cplusplus
45964 extern "C" {
45965 #endif
45966
45967 /* Python-specific SWIG API */
45968 #define SWIG_newvarlink() SWIG_Python_newvarlink()
45969 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
45970 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
45971
45972 /* -----------------------------------------------------------------------------
45973 * global variable support code.
45974 * ----------------------------------------------------------------------------- */
45975
45976 typedef struct swig_globalvar {
45977 char *name; /* Name of global variable */
45978 PyObject *(*get_attr)(); /* Return the current value */
45979 int (*set_attr)(PyObject *); /* Set the value */
45980 struct swig_globalvar *next;
45981 } swig_globalvar;
45982
45983 typedef struct swig_varlinkobject {
45984 PyObject_HEAD
45985 swig_globalvar *vars;
45986 } swig_varlinkobject;
45987
45988 static PyObject *
45989 swig_varlink_repr(swig_varlinkobject *v) {
45990 v = v;
45991 return PyString_FromString("<Swig global variables>");
45992 }
45993
45994 static int
45995 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
45996 swig_globalvar *var;
45997 flags = flags;
45998 fprintf(fp,"Swig global variables { ");
45999 for (var = v->vars; var; var=var->next) {
46000 fprintf(fp,"%s", var->name);
46001 if (var->next) fprintf(fp,", ");
46002 }
46003 fprintf(fp," }\n");
46004 return 0;
46005 }
46006
46007 static PyObject *
46008 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46009 swig_globalvar *var = v->vars;
46010 while (var) {
46011 if (strcmp(var->name,n) == 0) {
46012 return (*var->get_attr)();
46013 }
46014 var = var->next;
46015 }
46016 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46017 return NULL;
46018 }
46019
46020 static int
46021 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46022 swig_globalvar *var = v->vars;
46023 while (var) {
46024 if (strcmp(var->name,n) == 0) {
46025 return (*var->set_attr)(p);
46026 }
46027 var = var->next;
46028 }
46029 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46030 return 1;
46031 }
46032
46033 static PyTypeObject varlinktype = {
46034 PyObject_HEAD_INIT(0)
46035 0, /* Number of items in variable part (ob_size) */
46036 (char *)"swigvarlink", /* Type name (tp_name) */
46037 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46038 0, /* Itemsize (tp_itemsize) */
46039 0, /* Deallocator (tp_dealloc) */
46040 (printfunc) swig_varlink_print, /* Print (tp_print) */
46041 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46042 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46043 0, /* tp_compare */
46044 (reprfunc) swig_varlink_repr, /* tp_repr */
46045 0, /* tp_as_number */
46046 0, /* tp_as_sequence */
46047 0, /* tp_as_mapping */
46048 0, /* tp_hash */
46049 0, /* tp_call */
46050 0, /* tp_str */
46051 0, /* tp_getattro */
46052 0, /* tp_setattro */
46053 0, /* tp_as_buffer */
46054 0, /* tp_flags */
46055 0, /* tp_doc */
46056 #if PY_VERSION_HEX >= 0x02000000
46057 0, /* tp_traverse */
46058 0, /* tp_clear */
46059 #endif
46060 #if PY_VERSION_HEX >= 0x02010000
46061 0, /* tp_richcompare */
46062 0, /* tp_weaklistoffset */
46063 #endif
46064 #if PY_VERSION_HEX >= 0x02020000
46065 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46066 #endif
46067 #if PY_VERSION_HEX >= 0x02030000
46068 0, /* tp_del */
46069 #endif
46070 #ifdef COUNT_ALLOCS
46071 0,0,0,0 /* tp_alloc -> tp_next */
46072 #endif
46073 };
46074
46075 /* Create a variable linking object for use later */
46076 static PyObject *
46077 SWIG_Python_newvarlink(void) {
46078 swig_varlinkobject *result = 0;
46079 result = PyMem_NEW(swig_varlinkobject,1);
46080 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
46081 result->ob_type = &varlinktype;
46082 result->vars = 0;
46083 result->ob_refcnt = 0;
46084 Py_XINCREF((PyObject *) result);
46085 return ((PyObject*) result);
46086 }
46087
46088 static void
46089 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
46090 swig_varlinkobject *v;
46091 swig_globalvar *gv;
46092 v= (swig_varlinkobject *) p;
46093 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46094 gv->name = (char *) malloc(strlen(name)+1);
46095 strcpy(gv->name,name);
46096 gv->get_attr = get_attr;
46097 gv->set_attr = set_attr;
46098 gv->next = v->vars;
46099 v->vars = gv;
46100 }
46101
46102 /* -----------------------------------------------------------------------------
46103 * constants/methods manipulation
46104 * ----------------------------------------------------------------------------- */
46105
46106 /* Install Constants */
46107 static void
46108 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46109 PyObject *obj = 0;
46110 size_t i;
46111 for (i = 0; constants[i].type; i++) {
46112 switch(constants[i].type) {
46113 case SWIG_PY_INT:
46114 obj = PyInt_FromLong(constants[i].lvalue);
46115 break;
46116 case SWIG_PY_FLOAT:
46117 obj = PyFloat_FromDouble(constants[i].dvalue);
46118 break;
46119 case SWIG_PY_STRING:
46120 if (constants[i].pvalue) {
46121 obj = PyString_FromString((char *) constants[i].pvalue);
46122 } else {
46123 Py_INCREF(Py_None);
46124 obj = Py_None;
46125 }
46126 break;
46127 case SWIG_PY_POINTER:
46128 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
46129 break;
46130 case SWIG_PY_BINARY:
46131 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
46132 break;
46133 default:
46134 obj = 0;
46135 break;
46136 }
46137 if (obj) {
46138 PyDict_SetItemString(d,constants[i].name,obj);
46139 Py_DECREF(obj);
46140 }
46141 }
46142 }
46143
46144 /* -----------------------------------------------------------------------------*/
46145 /* Fix SwigMethods to carry the callback ptrs when needed */
46146 /* -----------------------------------------------------------------------------*/
46147
46148 static void
46149 SWIG_Python_FixMethods(PyMethodDef *methods,
46150 swig_const_info *const_table,
46151 swig_type_info **types,
46152 swig_type_info **types_initial) {
46153 size_t i;
46154 for (i = 0; methods[i].ml_name; ++i) {
46155 char *c = methods[i].ml_doc;
46156 if (c && (c = strstr(c, "swig_ptr: "))) {
46157 int j;
46158 swig_const_info *ci = 0;
46159 char *name = c + 10;
46160 for (j = 0; const_table[j].type; j++) {
46161 if (strncmp(const_table[j].name, name,
46162 strlen(const_table[j].name)) == 0) {
46163 ci = &(const_table[j]);
46164 break;
46165 }
46166 }
46167 if (ci) {
46168 size_t shift = (ci->ptype) - types;
46169 swig_type_info *ty = types_initial[shift];
46170 size_t ldoc = (c - methods[i].ml_doc);
46171 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
46172 char *ndoc = (char*)malloc(ldoc + lptr + 10);
46173 char *buff = ndoc;
46174 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
46175 strncpy(buff, methods[i].ml_doc, ldoc);
46176 buff += ldoc;
46177 strncpy(buff, "swig_ptr: ", 10);
46178 buff += 10;
46179 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
46180 methods[i].ml_doc = ndoc;
46181 }
46182 }
46183 }
46184 }
46185
46186 /* -----------------------------------------------------------------------------*
46187 * Initialize type list
46188 * -----------------------------------------------------------------------------*/
46189
46190 #if PY_MAJOR_VERSION < 2
46191 /* PyModule_AddObject function was introduced in Python 2.0. The following function
46192 is copied out of Python/modsupport.c in python version 2.3.4 */
46193 static int
46194 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
46195 {
46196 PyObject *dict;
46197 if (!PyModule_Check(m)) {
46198 PyErr_SetString(PyExc_TypeError,
46199 "PyModule_AddObject() needs module as first arg");
46200 return -1;
46201 }
46202 if (!o) {
46203 PyErr_SetString(PyExc_TypeError,
46204 "PyModule_AddObject() needs non-NULL value");
46205 return -1;
46206 }
46207
46208 dict = PyModule_GetDict(m);
46209 if (dict == NULL) {
46210 /* Internal error -- modules must have a dict! */
46211 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
46212 PyModule_GetName(m));
46213 return -1;
46214 }
46215 if (PyDict_SetItemString(dict, name, o))
46216 return -1;
46217 Py_DECREF(o);
46218 return 0;
46219 }
46220 #endif
46221
46222 static swig_type_info **
46223 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
46224 static PyMethodDef swig_empty_runtime_method_table[] = {
46225 {
46226 NULL, NULL, 0, NULL
46227 }
46228 };/* Sentinel */
46229
46230 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
46231 swig_empty_runtime_method_table);
46232 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
46233 if (pointer && module) {
46234 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
46235 }
46236 return type_list_handle;
46237 }
46238
46239 static swig_type_info **
46240 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
46241 swig_type_info **type_pointer;
46242
46243 /* first check if module already created */
46244 type_pointer = SWIG_Python_GetTypeListHandle();
46245 if (type_pointer) {
46246 return type_pointer;
46247 } else {
46248 /* create a new module and variable */
46249 return SWIG_Python_SetTypeListHandle(type_list_handle);
46250 }
46251 }
46252
46253 #ifdef __cplusplus
46254 }
46255 #endif
46256
46257 /* -----------------------------------------------------------------------------*
46258 * Partial Init method
46259 * -----------------------------------------------------------------------------*/
46260
46261 #ifdef SWIG_LINK_RUNTIME
46262 #ifdef __cplusplus
46263 extern "C"
46264 #endif
46265 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
46266 #endif
46267
46268 #ifdef __cplusplus
46269 extern "C"
46270 #endif
46271 SWIGEXPORT(void) SWIG_init(void) {
46272 static PyObject *SWIG_globals = 0;
46273 static int typeinit = 0;
46274 PyObject *m, *d;
46275 int i;
46276 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
46277
46278 /* Fix SwigMethods to carry the callback ptrs when needed */
46279 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
46280
46281 m = Py_InitModule((char *) SWIG_name, SwigMethods);
46282 d = PyModule_GetDict(m);
46283
46284 if (!typeinit) {
46285 #ifdef SWIG_LINK_RUNTIME
46286 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
46287 #else
46288 # ifndef SWIG_STATIC_RUNTIME
46289 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
46290 # endif
46291 #endif
46292 for (i = 0; swig_types_initial[i]; i++) {
46293 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
46294 }
46295 typeinit = 1;
46296 }
46297 SWIG_InstallConstants(d,swig_const_table);
46298
46299
46300 #ifndef wxPyUSE_EXPORT
46301 // Make our API structure a CObject so other modules can import it
46302 // from this module.
46303 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
46304 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
46305 Py_XDECREF(cobj);
46306 #endif
46307
46308 {
46309 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
46310 }
46311 {
46312 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
46313 }
46314 {
46315 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
46316 }
46317 {
46318 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
46319 }
46320 {
46321 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
46322 }
46323 {
46324 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
46325 }
46326 {
46327 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
46328 }
46329 {
46330 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
46331 }
46332 {
46333 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
46334 }
46335 {
46336 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
46337 }
46338 {
46339 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
46340 }
46341 {
46342 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
46343 }
46344 {
46345 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
46346 }
46347 {
46348 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
46349 }
46350 {
46351 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
46352 }
46353 {
46354 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
46355 }
46356 {
46357 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
46358 }
46359 {
46360 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
46361 }
46362 {
46363 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
46364 }
46365 {
46366 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
46367 }
46368 {
46369 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
46370 }
46371 {
46372 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
46373 }
46374 {
46375 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
46376 }
46377 {
46378 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
46379 }
46380 {
46381 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
46382 }
46383 {
46384 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
46385 }
46386 {
46387 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
46388 }
46389 {
46390 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
46391 }
46392 {
46393 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
46394 }
46395 {
46396 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
46397 }
46398 {
46399 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
46400 }
46401 {
46402 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
46403 }
46404 {
46405 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
46406 }
46407 {
46408 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
46409 }
46410 {
46411 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
46412 }
46413 {
46414 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
46415 }
46416 {
46417 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
46418 }
46419 {
46420 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
46421 }
46422 {
46423 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
46424 }
46425 {
46426 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
46427 }
46428 {
46429 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
46430 }
46431 {
46432 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
46433 }
46434 {
46435 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
46436 }
46437 {
46438 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
46439 }
46440 {
46441 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
46442 }
46443 {
46444 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
46445 }
46446 {
46447 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
46448 }
46449 {
46450 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
46451 }
46452 {
46453 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
46454 }
46455 {
46456 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
46457 }
46458 {
46459 PyDict_SetItemString(d,"SL_HORIZONTAL", SWIG_From_int((int)(wxSL_HORIZONTAL)));
46460 }
46461 {
46462 PyDict_SetItemString(d,"SL_VERTICAL", SWIG_From_int((int)(wxSL_VERTICAL)));
46463 }
46464 {
46465 PyDict_SetItemString(d,"SL_AUTOTICKS", SWIG_From_int((int)(wxSL_AUTOTICKS)));
46466 }
46467 {
46468 PyDict_SetItemString(d,"SL_LABELS", SWIG_From_int((int)(wxSL_LABELS)));
46469 }
46470 {
46471 PyDict_SetItemString(d,"SL_LEFT", SWIG_From_int((int)(wxSL_LEFT)));
46472 }
46473 {
46474 PyDict_SetItemString(d,"SL_TOP", SWIG_From_int((int)(wxSL_TOP)));
46475 }
46476 {
46477 PyDict_SetItemString(d,"SL_RIGHT", SWIG_From_int((int)(wxSL_RIGHT)));
46478 }
46479 {
46480 PyDict_SetItemString(d,"SL_BOTTOM", SWIG_From_int((int)(wxSL_BOTTOM)));
46481 }
46482 {
46483 PyDict_SetItemString(d,"SL_BOTH", SWIG_From_int((int)(wxSL_BOTH)));
46484 }
46485 {
46486 PyDict_SetItemString(d,"SL_SELRANGE", SWIG_From_int((int)(wxSL_SELRANGE)));
46487 }
46488 {
46489 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
46490 }
46491 {
46492 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
46493 }
46494 {
46495 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
46496 }
46497 {
46498 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
46499 }
46500 {
46501 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
46502 }
46503 {
46504 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
46505 }
46506 {
46507 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
46508 }
46509 {
46510 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
46511 }
46512 {
46513 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
46514 }
46515 {
46516 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
46517 }
46518 {
46519 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
46520 }
46521 {
46522 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
46523 }
46524 {
46525 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
46526 }
46527 {
46528 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
46529 }
46530 {
46531 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
46532 }
46533 {
46534 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
46535 }
46536 {
46537 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
46538 }
46539 {
46540 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
46541 }
46542 {
46543 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
46544 }
46545 {
46546 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
46547 }
46548 {
46549 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
46550 }
46551 {
46552 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
46553 }
46554 {
46555 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
46556 }
46557 {
46558 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
46559 }
46560 {
46561 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
46562 }
46563 {
46564 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
46565 }
46566 {
46567 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
46568 }
46569 {
46570 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
46571 }
46572 {
46573 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
46574 }
46575 {
46576 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
46577 }
46578 {
46579 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
46580 }
46581 {
46582 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
46583 }
46584 {
46585 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
46586 }
46587 {
46588 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
46589 }
46590 {
46591 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
46592 }
46593 {
46594 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
46595 }
46596 {
46597 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
46598 }
46599 {
46600 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
46601 }
46602 {
46603 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
46604 }
46605 {
46606 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
46607 }
46608 {
46609 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
46610 }
46611 {
46612 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
46613 }
46614 {
46615 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
46616 }
46617 {
46618 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
46619 }
46620 {
46621 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
46622 }
46623 {
46624 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
46625 }
46626 {
46627 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
46628 }
46629 {
46630 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
46631 }
46632 {
46633 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
46634 }
46635 {
46636 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
46637 }
46638 {
46639 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
46640 }
46641 {
46642 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
46643 }
46644 {
46645 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
46646 }
46647 {
46648 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
46649 }
46650 {
46651 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
46652 }
46653 {
46654 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
46655 }
46656 {
46657 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
46658 }
46659 {
46660 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
46661 }
46662 {
46663 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
46664 }
46665 {
46666 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
46667 }
46668 {
46669 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
46670 }
46671 {
46672 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
46673 }
46674 {
46675 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
46676 }
46677 {
46678 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
46679 }
46680 {
46681 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
46682 }
46683 {
46684 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
46685 }
46686 {
46687 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
46688 }
46689 {
46690 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
46691 }
46692 {
46693 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
46694 }
46695 {
46696 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
46697 }
46698 {
46699 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
46700 }
46701 {
46702 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
46703 }
46704 {
46705 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
46706 }
46707 {
46708 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
46709 }
46710 {
46711 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
46712 }
46713 {
46714 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
46715 }
46716 {
46717 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
46718 }
46719 {
46720 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
46721 }
46722 {
46723 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
46724 }
46725 {
46726 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
46727 }
46728 {
46729 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
46730 }
46731 {
46732 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
46733 }
46734 {
46735 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
46736 }
46737 {
46738 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
46739 }
46740 {
46741 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
46742 }
46743 {
46744 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
46745 }
46746 {
46747 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
46748 }
46749 {
46750 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
46751 }
46752 {
46753 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
46754 }
46755 {
46756 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
46757 }
46758 {
46759 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
46760 }
46761 {
46762 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
46763 }
46764 {
46765 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
46766 }
46767 {
46768 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
46769 }
46770 {
46771 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
46772 }
46773 {
46774 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
46775 }
46776 {
46777 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
46778 }
46779 {
46780 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
46781 }
46782 {
46783 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
46784 }
46785 {
46786 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
46787 }
46788 {
46789 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
46790 }
46791 {
46792 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
46793 }
46794 {
46795 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
46796 }
46797 {
46798 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
46799 }
46800 {
46801 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
46802 }
46803 {
46804 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
46805 }
46806 {
46807 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
46808 }
46809 {
46810 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
46811 }
46812 {
46813 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
46814 }
46815 {
46816 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
46817 }
46818 {
46819 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
46820 }
46821 {
46822 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
46823 }
46824 {
46825 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
46826 }
46827 {
46828 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
46829 }
46830 {
46831 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
46832 }
46833 {
46834 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
46835 }
46836 {
46837 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
46838 }
46839 {
46840 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
46841 }
46842 {
46843 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
46844 }
46845 {
46846 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
46847 }
46848 {
46849 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
46850 }
46851 {
46852 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
46853 }
46854 {
46855 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
46856 }
46857 {
46858 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
46859 }
46860 {
46861 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
46862 }
46863 {
46864 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
46865 }
46866 {
46867 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
46868 }
46869 {
46870 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
46871 }
46872 {
46873 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
46874 }
46875 {
46876 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
46877 }
46878 {
46879 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
46880 }
46881 {
46882 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
46883 }
46884 {
46885 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
46886 }
46887 {
46888 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
46889 }
46890 {
46891 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
46892 }
46893 {
46894 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
46895 }
46896 {
46897 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
46898 }
46899 {
46900 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
46901 }
46902 {
46903 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
46904 }
46905 {
46906 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
46907 }
46908 {
46909 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
46910 }
46911 {
46912 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
46913 }
46914 {
46915 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
46916 }
46917 {
46918 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
46919 }
46920 {
46921 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
46922 }
46923 {
46924 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
46925 }
46926 {
46927 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
46928 }
46929 {
46930 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
46931 }
46932 {
46933 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
46934 }
46935 {
46936 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
46937 }
46938 {
46939 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
46940 }
46941 {
46942 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
46943 }
46944 {
46945 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
46946 }
46947 {
46948 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
46949 }
46950 {
46951 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
46952 }
46953 {
46954 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
46955 }
46956 {
46957 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
46958 }
46959 {
46960 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
46961 }
46962 {
46963 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
46964 }
46965 {
46966 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
46967 }
46968 {
46969 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
46970 }
46971 {
46972 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
46973 }
46974 {
46975 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
46976 }
46977 {
46978 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
46979 }
46980 {
46981 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
46982 }
46983 {
46984 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
46985 }
46986 {
46987 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
46988 }
46989 {
46990 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
46991 }
46992 {
46993 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
46994 }
46995 {
46996 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
46997 }
46998 {
46999 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47000 }
47001 {
47002 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47003 }
47004 {
47005 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47006 }
47007 {
47008 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47009 }
47010 {
47011 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47012 }
47013 {
47014 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47015 }
47016 {
47017 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47018 }
47019 {
47020 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47021 }
47022 {
47023 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47024 }
47025 {
47026 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47027 }
47028 {
47029 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47030 }
47031 {
47032 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47033 }
47034 {
47035 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47036 }
47037 {
47038 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47039 }
47040 {
47041 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47042 }
47043 {
47044 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47045 }
47046 {
47047 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47048 }
47049 {
47050 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47051 }
47052 {
47053 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47054 }
47055 {
47056 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47057 }
47058 {
47059 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47060 }
47061 {
47062 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47063 }
47064 {
47065 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47066 }
47067 {
47068 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47069 }
47070 {
47071 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47072 }
47073 {
47074 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47075 }
47076 {
47077 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47078 }
47079 {
47080 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47081 }
47082 {
47083 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47084 }
47085 {
47086 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47087 }
47088 {
47089 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47090 }
47091 {
47092 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47093 }
47094 {
47095 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47096 }
47097 {
47098 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47099 }
47100 {
47101 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
47102 }
47103 {
47104 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
47105 }
47106 {
47107 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
47108 }
47109 {
47110 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
47111 }
47112 {
47113 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
47114 }
47115 {
47116 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
47117 }
47118 {
47119 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47120 }
47121 {
47122 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47123 }
47124 {
47125 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47126 }
47127 {
47128 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47129 }
47130 {
47131 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47132 }
47133 {
47134 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47135 }
47136 {
47137 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47138 }
47139 {
47140 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47141 }
47142 {
47143 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47144 }
47145 {
47146 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47147 }
47148 {
47149 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
47150 }
47151 {
47152 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
47153 }
47154 {
47155 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
47156 }
47157 {
47158 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
47159 }
47160 {
47161 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
47162 }
47163 {
47164 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
47165 }
47166 {
47167 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
47168 }
47169 {
47170 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
47171 }
47172 {
47173 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
47174 }
47175 {
47176 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
47177 }
47178 {
47179 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
47180 }
47181 {
47182 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
47183 }
47184 {
47185 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
47186 }
47187 {
47188 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
47189 }
47190 {
47191 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
47192 }
47193 {
47194 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
47195 }
47196 {
47197 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
47198 }
47199 {
47200 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
47201 }
47202 {
47203 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
47204 }
47205 {
47206 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
47207 }
47208 {
47209 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
47210 }
47211 {
47212 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
47213 }
47214 {
47215 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
47216 }
47217 {
47218 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
47219 }
47220 {
47221 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
47222 }
47223 {
47224 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
47225 }
47226 {
47227 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
47228 }
47229 {
47230 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
47231 }
47232 {
47233 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
47234 }
47235 {
47236 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
47237 }
47238 {
47239 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
47240 }
47241 {
47242 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
47243 }
47244 {
47245 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
47246 }
47247 {
47248 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
47249 }
47250 {
47251 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
47252 }
47253 {
47254 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
47255 }
47256 {
47257 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
47258 }
47259 {
47260 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
47261 }
47262 {
47263 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
47264 }
47265 {
47266 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
47267 }
47268 {
47269 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
47270 }
47271 {
47272 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
47273 }
47274 {
47275 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
47276 }
47277 {
47278 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
47279 }
47280 {
47281 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
47282 }
47283 {
47284 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
47285 }
47286 {
47287 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
47288 }
47289 {
47290 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
47291 }
47292 {
47293 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
47294 }
47295 {
47296 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
47297 }
47298 {
47299 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
47300 }
47301 {
47302 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
47303 }
47304 {
47305 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
47306 }
47307 {
47308 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
47309 }
47310 {
47311 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
47312 }
47313 {
47314 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
47315 }
47316 {
47317 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
47318 }
47319 {
47320 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
47321 }
47322 {
47323 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
47324 }
47325 {
47326 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
47327 }
47328 {
47329 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
47330 }
47331 {
47332 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
47333 }
47334 {
47335 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
47336 }
47337 {
47338 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
47339 }
47340 {
47341 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
47342 }
47343 {
47344 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
47345 }
47346 {
47347 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
47348 }
47349 {
47350 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
47351 }
47352 {
47353 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
47354 }
47355 {
47356 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
47357 }
47358 {
47359 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
47360 }
47361 {
47362 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
47363 }
47364 {
47365 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
47366 }
47367 {
47368 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
47369 }
47370 {
47371 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
47372 }
47373 {
47374 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
47375 }
47376 {
47377 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
47378 }
47379 {
47380 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
47381 }
47382 {
47383 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
47384 }
47385 {
47386 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
47387 }
47388 {
47389 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
47390 }
47391 {
47392 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
47393 }
47394 {
47395 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
47396 }
47397 {
47398 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
47399 }
47400 {
47401 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
47402 }
47403 {
47404 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
47405 }
47406 {
47407 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
47408 }
47409 {
47410 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
47411 }
47412 {
47413 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
47414 }
47415 {
47416 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
47417 }
47418 {
47419 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
47420 }
47421 {
47422 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
47423 }
47424 {
47425 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
47426 }
47427 {
47428 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
47429 }
47430 {
47431 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
47432 }
47433 {
47434 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
47435 }
47436 {
47437 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
47438 }
47439 {
47440 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
47441 }
47442 {
47443 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
47444 }
47445 {
47446 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
47447 }
47448 {
47449 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
47450 }
47451 {
47452 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
47453 }
47454 {
47455 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
47456 }
47457 {
47458 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
47459 }
47460 {
47461 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
47462 }
47463 {
47464 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
47465 }
47466 {
47467 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
47468 }
47469 {
47470 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
47471 }
47472 {
47473 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
47474 }
47475 {
47476 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
47477 }
47478 {
47479 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
47480 }
47481 {
47482 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
47483 }
47484 {
47485 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
47486 }
47487 {
47488 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
47489 }
47490 {
47491 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
47492 }
47493 {
47494 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
47495 }
47496 {
47497 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
47498 }
47499 {
47500 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
47501 }
47502 {
47503 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
47504 }
47505 {
47506 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
47507 }
47508 {
47509 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
47510 }
47511 {
47512 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
47513 }
47514 {
47515 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
47516 }
47517 {
47518 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
47519 }
47520 {
47521 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
47522 }
47523 {
47524 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
47525 }
47526 {
47527 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
47528 }
47529 {
47530 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
47531 }
47532 {
47533 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
47534 }
47535 {
47536 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
47537 }
47538 {
47539 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
47540 }
47541 {
47542 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
47543 }
47544 {
47545 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
47546 }
47547 {
47548 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
47549 }
47550 {
47551 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
47552 }
47553 {
47554 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
47555 }
47556 {
47557 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
47558 }
47559 {
47560 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
47561 }
47562 {
47563 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
47564 }
47565 {
47566 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
47567 }
47568 {
47569 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
47570 }
47571 {
47572 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
47573 }
47574 {
47575 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
47576 }
47577 {
47578 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
47579 }
47580 {
47581 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
47582 }
47583 {
47584 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
47585 }
47586 {
47587 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
47588 }
47589 {
47590 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
47591 }
47592 {
47593 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
47594 }
47595 {
47596 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
47597 }
47598 {
47599 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
47600 }
47601 {
47602 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
47603 }
47604 {
47605 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
47606 }
47607 {
47608 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
47609 }
47610 {
47611 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
47612 }
47613 {
47614 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
47615 }
47616 {
47617 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
47618 }
47619 {
47620 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
47621 }
47622 {
47623 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
47624 }
47625 {
47626 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
47627 }
47628 {
47629 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
47630 }
47631 {
47632 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
47633 }
47634 {
47635 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
47636 }
47637 {
47638 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
47639 }
47640 {
47641 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
47642 }
47643 {
47644 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
47645 }
47646 {
47647 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
47648 }
47649 {
47650 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
47651 }
47652 {
47653 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
47654 }
47655 {
47656 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
47657 }
47658 {
47659 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
47660 }
47661 {
47662 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
47663 }
47664 {
47665 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
47666 }
47667 {
47668 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
47669 }
47670 {
47671 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
47672 }
47673 {
47674 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
47675 }
47676 {
47677 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
47678 }
47679 {
47680 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
47681 }
47682 {
47683 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
47684 }
47685 {
47686 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
47687 }
47688 {
47689 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
47690 }
47691 {
47692 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
47693 }
47694 {
47695 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
47696 }
47697 {
47698 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
47699 }
47700 {
47701 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
47702 }
47703 {
47704 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
47705 }
47706 {
47707 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
47708 }
47709 {
47710 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
47711 }
47712 {
47713 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
47714 }
47715 {
47716 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
47717 }
47718 {
47719 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
47720 }
47721 {
47722 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
47723 }
47724 {
47725 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
47726 }
47727 {
47728 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
47729 }
47730 {
47731 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
47732 }
47733 {
47734 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
47735 }
47736 {
47737 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
47738 }
47739 {
47740 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
47741 }
47742 {
47743 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
47744 }
47745 {
47746 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
47747 }
47748 {
47749 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
47750 }
47751 {
47752 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
47753 }
47754 {
47755 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
47756 }
47757 {
47758 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
47759 }
47760 {
47761 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
47762 }
47763 {
47764 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
47765 }
47766 {
47767 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
47768 }
47769 {
47770 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
47771 }
47772 {
47773 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
47774 }
47775 {
47776 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
47777 }
47778 {
47779 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
47780 }
47781 {
47782 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
47783 }
47784 {
47785 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
47786 }
47787 {
47788 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
47789 }
47790 {
47791 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
47792 }
47793 {
47794 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
47795 }
47796 {
47797 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
47798 }
47799 {
47800 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
47801 }
47802 {
47803 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
47804 }
47805 {
47806 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
47807 }
47808 {
47809 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
47810 }
47811 {
47812 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
47813 }
47814 {
47815 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
47816 }
47817 {
47818 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
47819 }
47820 {
47821 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
47822 }
47823 {
47824 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
47825 }
47826 {
47827 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
47828 }
47829 {
47830 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
47831 }
47832 {
47833 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
47834 }
47835 {
47836 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
47837 }
47838 {
47839 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
47840 }
47841 {
47842 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
47843 }
47844 {
47845 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
47846 }
47847 {
47848 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
47849 }
47850 {
47851 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
47852 }
47853 {
47854 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
47855 }
47856 {
47857 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
47858 }
47859 {
47860 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
47861 }
47862 {
47863 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
47864 }
47865 {
47866 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
47867 }
47868 {
47869 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
47870 }
47871 {
47872 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
47873 }
47874 {
47875 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
47876 }
47877 {
47878 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
47879 }
47880 {
47881 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
47882 }
47883 {
47884 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
47885 }
47886 {
47887 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
47888 }
47889 {
47890 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
47891 }
47892 {
47893 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
47894 }
47895 {
47896 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
47897 }
47898 {
47899 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
47900 }
47901 {
47902 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
47903 }
47904 {
47905 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
47906 }
47907 {
47908 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
47909 }
47910 {
47911 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
47912 }
47913 {
47914 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
47915 }
47916 {
47917 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
47918 }
47919 {
47920 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
47921 }
47922 {
47923 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
47924 }
47925 {
47926 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
47927 }
47928 {
47929 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
47930 }
47931 {
47932 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
47933 }
47934 {
47935 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
47936 }
47937 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
47938 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
47939 {
47940 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
47959 }
47960 {
47961 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
47962 }
47963 {
47964 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
47965 }
47966 {
47967 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
47968 }
47969 {
47970 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
47971 }
47972 {
47973 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
47974 }
47975 {
47976 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
47983 }
47984 {
47985 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
47986 }
47987 {
47988 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
47989 }
47990 {
47991 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
47992 }
47993 {
47994 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
47995 }
47996 {
47997 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48040 }
48041 {
48042 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48043 }
48044 {
48045 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48046 }
48047 {
48048 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48049 }
48050 {
48051 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48052 }
48053 {
48054 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48055 }
48056 {
48057 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48058 }
48059 {
48060 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48061 }
48062 {
48063 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48064 }
48065 {
48066 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48067 }
48068 {
48069 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48070 }
48071 {
48072 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48073 }
48074 {
48075 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48076 }
48077 {
48078 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48079 }
48080 {
48081 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48082 }
48083 {
48084 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48085 }
48086 {
48087 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48088 }
48089 {
48090 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48091 }
48092 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48093 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48094 {
48095 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
48102 }
48103
48104 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
48105
48106
48107 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
48108
48109 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
48110 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
48111 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
48112 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
48113 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
48114 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
48115 {
48116 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
48159 }
48160 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
48161 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
48162 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
48163 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
48164 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
48165 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
48166 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
48167 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
48168 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
48169 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
48170 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
48171 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
48172 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
48173 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
48174 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
48175 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
48176 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
48177 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
48178 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
48179 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
48180 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
48181 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
48182 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
48183 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
48184 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
48185 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
48186 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
48187 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
48188 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
48189 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
48190 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
48191 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
48192 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
48193 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
48194 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
48195 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
48196 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
48197 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
48198 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
48199 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
48200 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
48201 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
48202 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
48203 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
48204 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
48205 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
48206 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
48207 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
48208 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
48209 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
48210 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
48211 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
48212 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
48213 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
48214 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
48215 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
48216 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
48217 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
48218 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
48219 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
48220 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
48221 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
48222 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
48223 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
48224 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
48225 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
48226 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
48227 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
48228 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
48229 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
48230 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
48231 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
48232 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
48233 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
48234 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
48235 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
48236 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
48237 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
48238 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
48239 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
48240 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
48241 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
48242 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
48243 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
48244 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
48245 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
48246 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
48247 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
48248 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
48249 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
48250 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
48251 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
48252 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
48253 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
48254 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
48255 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
48256 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
48257 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
48258 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
48259 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
48260 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
48261 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
48262 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
48263 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
48264 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
48265 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
48266 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
48267 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
48268 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
48269 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
48270 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
48271 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
48272 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
48273 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
48274 {
48275 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
48327 }
48328 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
48329 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
48330 {
48331 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
48332 }
48333 {
48334 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
48335 }
48336 {
48337 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
48338 }
48339 {
48340 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
48341 }
48342 {
48343 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
48344 }
48345 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
48346 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
48347 {
48348 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
48349 }
48350 {
48351 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
48352 }
48353 {
48354 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
48355 }
48356 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
48357 {
48358 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
48359 }
48360 {
48361 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
48362 }
48363 {
48364 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
48365 }
48366 {
48367 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
48368 }
48369 {
48370 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
48371 }
48372 {
48373 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
48374 }
48375 {
48376 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
48377 }
48378 {
48379 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
48380 }
48381 {
48382 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
48383 }
48384 {
48385 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
48386 }
48387 {
48388 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
48389 }
48390 {
48391 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
48392 }
48393 {
48394 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
48395 }
48396 {
48397 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
48398 }
48399 {
48400 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
48401 }
48402 {
48403 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
48404 }
48405 {
48406 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
48407 }
48408 {
48409 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
48410 }
48411 {
48412 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
48413 }
48414
48415 // Initialize threading, some globals and such
48416 __wxPyPreStart(d);
48417
48418
48419 // Although these are defined in __version__ they need to be here too so
48420 // that an assert can be done to ensure that the wxPython and the wxWindows
48421 // versions match.
48422 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
48423 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
48424 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
48425
48426 }
48427
wxWidgets (Impactor)