]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
new configure flags
[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_buffer swig_types[14]
1356 #define SWIGTYPE_p_wxMenu swig_types[15]
1357 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1359 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1360 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1361 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1363 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1367 #define SWIGTYPE_p_wxControl swig_types[26]
1368 #define SWIGTYPE_p_wxFont swig_types[27]
1369 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1370 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1371 #define SWIGTYPE_p_wxFSFile swig_types[30]
1372 #define SWIGTYPE_p_wxCaret swig_types[31]
1373 #define SWIGTYPE_ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1375 #define SWIGTYPE_p_wxRegion swig_types[34]
1376 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1377 #define SWIGTYPE_p_int swig_types[36]
1378 #define SWIGTYPE_p_wxSize swig_types[37]
1379 #define SWIGTYPE_p_wxDC swig_types[38]
1380 #define SWIGTYPE_p_wxPySizer swig_types[39]
1381 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1382 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1384 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1387 #define SWIGTYPE_p_wxArrayString swig_types[46]
1388 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1389 #define SWIGTYPE_p_wxToolTip swig_types[48]
1390 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1391 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1392 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1393 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1395 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1396 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1397 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1398 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1399 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1400 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1401 #define SWIGTYPE_p_long swig_types[60]
1402 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1403 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1404 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1406 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1408 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1409 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1410 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1411 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1414 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1415 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1416 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1417 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1418 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1419 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1420 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1421 #define SWIGTYPE_p_wxRect swig_types[80]
1422 #define SWIGTYPE_p_wxButton swig_types[81]
1423 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1424 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1425 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1426 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1427 #define SWIGTYPE_p_char swig_types[86]
1428 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1429 #define SWIGTYPE_p_wxImage swig_types[88]
1430 #define SWIGTYPE_p_wxFrame swig_types[89]
1431 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1433 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1434 #define SWIGTYPE_p_wxPoint swig_types[93]
1435 #define SWIGTYPE_p_wxCursor swig_types[94]
1436 #define SWIGTYPE_p_wxObject swig_types[95]
1437 #define SWIGTYPE_p_wxInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1439 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1440 #define SWIGTYPE_p_wxDateTime swig_types[99]
1441 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1443 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1444 #define SWIGTYPE_p_unsigned_long swig_types[103]
1445 #define SWIGTYPE_p_wxWindow swig_types[104]
1446 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1447 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1448 #define SWIGTYPE_p_wxBitmap swig_types[107]
1449 #define SWIGTYPE_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_unsigned_int swig_types[109]
1451 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1453 #define SWIGTYPE_p_unsigned_char swig_types[112]
1454 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyApp swig_types[116]
1458 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1460 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1461 #define SWIGTYPE_p_wxQuantize swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1464 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1465 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1466 #define SWIGTYPE_p_wxColour swig_types[125]
1467 #define SWIGTYPE_p_wxValidator swig_types[126]
1468 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1469 static swig_type_info *swig_types[129];
1470
1471 /* -------- TYPES TABLE (END) -------- */
1472
1473
1474 /*-----------------------------------------------
1475 @(target):= _core_.so
1476 ------------------------------------------------*/
1477 #define SWIG_init init_core_
1478
1479 #define SWIG_name "_core_"
1480
1481 #include "wx/wxPython/wxPython_int.h"
1482 #include "wx/wxPython/pyclasses.h"
1483
1484
1485 #ifndef wxPyUSE_EXPORT
1486 // Helper functions for dealing with SWIG objects and such. These are
1487 // located here so they know about the SWIG types and functions declared
1488 // in the wrapper code.
1489
1490 #include <wx/hashmap.h>
1491 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1492
1493
1494 // Maintains a hashmap of className to swig_type_info pointers. Given the
1495 // name of a class either looks up the type info in the cache, or scans the
1496 // SWIG tables for it.
1497 extern PyObject* wxPyPtrTypeMap;
1498 static
1499 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1500
1501 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1502
1503 if (typeInfoCache == NULL)
1504 typeInfoCache = new wxPyTypeInfoHashMap;
1505
1506 wxString name(className);
1507 swig_type_info* swigType = (*typeInfoCache)[name];
1508
1509 if (! swigType) {
1510 // it wasn't in the cache, so look it up from SWIG
1511 name.Append(wxT(" *"));
1512 swigType = SWIG_TypeQuery(name.mb_str());
1513
1514 // if it still wasn't found, try looking for a mapped name
1515 if (!swigType) {
1516 PyObject* item;
1517 name = className;
1518
1519 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1520 (char*)(const char*)name.mbc_str())) != NULL) {
1521 name = wxString(PyString_AsString(item), *wxConvCurrent);
1522 name.Append(wxT(" *"));
1523 swigType = SWIG_TypeQuery(name.mb_str());
1524 }
1525 }
1526 if (swigType) {
1527 // and add it to the map if found
1528 (*typeInfoCache)[className] = swigType;
1529 }
1530 }
1531 return swigType;
1532 }
1533
1534
1535 // Check if a class name is a type known to SWIG
1536 bool wxPyCheckSwigType(const wxChar* className) {
1537
1538 swig_type_info* swigType = wxPyFindSwigType(className);
1539 return swigType != NULL;
1540 }
1541
1542
1543 // Given a pointer to a C++ object and a class name, construct a Python proxy
1544 // object for it.
1545 PyObject* wxPyConstructObject(void* ptr,
1546 const wxChar* className,
1547 int setThisOwn) {
1548
1549 swig_type_info* swigType = wxPyFindSwigType(className);
1550 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1551
1552 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1553 }
1554
1555
1556 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1557 // Ensures that the proxy object is of the specified (or derived) type. If
1558 // not able to perform the conversion then a Python exception is set and the
1559 // error should be handled properly in the caller. Returns True on success.
1560 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1561 const wxChar* className) {
1562
1563 swig_type_info* swigType = wxPyFindSwigType(className);
1564 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1565
1566 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1567 }
1568
1569
1570 // Make a SWIGified pointer object suitable for a .this attribute
1571 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1572
1573 PyObject* robj = NULL;
1574
1575 swig_type_info* swigType = wxPyFindSwigType(className);
1576 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1577
1578 #ifdef SWIG_COBJECT_TYPES
1579 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1580 #else
1581 {
1582 char result[1024];
1583 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1584 PyString_FromString(result) : 0;
1585 }
1586 #endif
1587
1588 return robj;
1589 }
1590
1591
1592
1593
1594 // Export a C API in a struct. Other modules will be able to load this from
1595 // the wx._core_ module and will then have safe access to these functions,
1596 // even if they are located in another shared library.
1597 static wxPyCoreAPI API = {
1598
1599 wxPyCheckSwigType,
1600 wxPyConstructObject,
1601 wxPyConvertSwigPtr,
1602 wxPyMakeSwigPtr,
1603
1604 wxPyBeginAllowThreads,
1605 wxPyEndAllowThreads,
1606 wxPyBeginBlockThreads,
1607 wxPyEndBlockThreads,
1608
1609 wxPy_ConvertList,
1610
1611 wxString_in_helper,
1612 Py2wxString,
1613 wx2PyString,
1614
1615 byte_LIST_helper,
1616 int_LIST_helper,
1617 long_LIST_helper,
1618 string_LIST_helper,
1619 wxPoint_LIST_helper,
1620 wxBitmap_LIST_helper,
1621 wxString_LIST_helper,
1622 wxAcceleratorEntry_LIST_helper,
1623
1624 wxSize_helper,
1625 wxPoint_helper,
1626 wxRealPoint_helper,
1627 wxRect_helper,
1628 wxColour_helper,
1629 wxPoint2D_helper,
1630
1631 wxPySimple_typecheck,
1632 wxColour_typecheck,
1633
1634 wxPyCBH_setCallbackInfo,
1635 wxPyCBH_findCallback,
1636 wxPyCBH_callCallback,
1637 wxPyCBH_callCallbackObj,
1638 wxPyCBH_delete,
1639
1640 wxPyMake_wxObject,
1641 wxPyMake_wxSizer,
1642 wxPyPtrTypeMap_Add,
1643 wxPy2int_seq_helper,
1644 wxPy4int_seq_helper,
1645 wxArrayString2PyList_helper,
1646 wxArrayInt2PyList_helper,
1647
1648 wxPyClientData_dtor,
1649 wxPyUserData_dtor,
1650 wxPyOORClientData_dtor,
1651
1652 wxPyCBInputStream_create,
1653 wxPyCBInputStream_copy,
1654
1655 wxPyInstance_Check,
1656 wxPySwigInstance_Check,
1657
1658 wxPyCheckForApp
1659
1660 };
1661
1662 #endif
1663
1664
1665 #if !WXWIN_COMPATIBILITY_2_4
1666 #define wxHIDE_READONLY 0
1667 #endif
1668
1669
1670 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1671 #define SWIG_From_int PyInt_FromLong
1672 /*@@*/
1673
1674
1675 #if ! wxUSE_HOTKEY
1676 enum wxHotkeyModifier
1677 {
1678 wxMOD_NONE = 0,
1679 wxMOD_ALT = 1,
1680 wxMOD_CONTROL = 2,
1681 wxMOD_SHIFT = 4,
1682 wxMOD_WIN = 8
1683 };
1684 #define wxEVT_HOTKEY 9999
1685 #endif
1686
1687 static const wxString wxPyEmptyString(wxEmptyString);
1688 static wxString wxObject_GetClassName(wxObject *self){
1689 return self->GetClassInfo()->GetClassName();
1690 }
1691 static void wxObject_Destroy(wxObject *self){
1692 delete self;
1693 }
1694
1695 #ifndef __WXMAC__
1696 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1697 #endif
1698
1699
1700 #include <limits.h>
1701
1702
1703 SWIGINTERN int
1704 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1705 const char *errmsg)
1706 {
1707 if (value < min_value) {
1708 if (errmsg) {
1709 PyErr_Format(PyExc_OverflowError,
1710 "value %ld is less than '%s' minimum %ld",
1711 value, errmsg, min_value);
1712 }
1713 return 0;
1714 } else if (value > max_value) {
1715 if (errmsg) {
1716 PyErr_Format(PyExc_OverflowError,
1717 "value %ld is greater than '%s' maximum %ld",
1718 value, errmsg, max_value);
1719 }
1720 return 0;
1721 }
1722 return 1;
1723 }
1724
1725
1726 SWIGINTERN int
1727 SWIG_AsVal_long(PyObject* obj, long* val)
1728 {
1729 if (PyNumber_Check(obj)) {
1730 if (val) *val = PyInt_AsLong(obj);
1731 return 1;
1732 }
1733 else {
1734 SWIG_type_error("number", obj);
1735 }
1736 return 0;
1737 }
1738
1739
1740 #if INT_MAX != LONG_MAX
1741 SWIGINTERN int
1742 SWIG_AsVal_int(PyObject *obj, int *val)
1743 {
1744 const char* errmsg = val ? "int" : (char*)0;
1745 long v;
1746 if (SWIG_AsVal_long(obj, &v)) {
1747 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1748 if (val) *val = (int)(v);
1749 return 1;
1750 } else {
1751 return 0;
1752 }
1753 } else {
1754 PyErr_Clear();
1755 }
1756 if (val) {
1757 SWIG_type_error(errmsg, obj);
1758 }
1759 return 0;
1760 }
1761 #else
1762 SWIGINTERNSHORT int
1763 SWIG_AsVal_int(PyObject *obj, int *val)
1764 {
1765 return SWIG_AsVal_long(obj,(long*)val);
1766 }
1767 #endif
1768
1769
1770 SWIGINTERNSHORT int
1771 SWIG_As_int(PyObject* obj)
1772 {
1773 int v;
1774 if (!SWIG_AsVal_int(obj, &v)) {
1775 /*
1776 this is needed to make valgrind/purify happier.
1777 */
1778 memset((void*)&v, 0, sizeof(int));
1779 }
1780 return v;
1781 }
1782
1783
1784 SWIGINTERNSHORT int
1785 SWIG_Check_int(PyObject* obj)
1786 {
1787 return SWIG_AsVal_int(obj, (int*)0);
1788 }
1789
1790 static PyObject *wxSize_Get(wxSize *self){
1791 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1792 PyObject* tup = PyTuple_New(2);
1793 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1794 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1795 wxPyEndBlockThreads(blocked);
1796 return tup;
1797 }
1798
1799 SWIGINTERN int
1800 SWIG_AsVal_double(PyObject *obj, double* val)
1801 {
1802 if (PyNumber_Check(obj)) {
1803 if (val) *val = PyFloat_AsDouble(obj);
1804 return 1;
1805 }
1806 else {
1807 SWIG_type_error("number", obj);
1808 }
1809 return 0;
1810 }
1811
1812
1813 SWIGINTERNSHORT double
1814 SWIG_As_double(PyObject* obj)
1815 {
1816 double v;
1817 if (!SWIG_AsVal_double(obj, &v)) {
1818 /*
1819 this is needed to make valgrind/purify happier.
1820 */
1821 memset((void*)&v, 0, sizeof(double));
1822 }
1823 return v;
1824 }
1825
1826
1827 SWIGINTERNSHORT int
1828 SWIG_Check_double(PyObject* obj)
1829 {
1830 return SWIG_AsVal_double(obj, (double*)0);
1831 }
1832
1833
1834 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1835 #define SWIG_From_double PyFloat_FromDouble
1836 /*@@*/
1837
1838 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1839 self->x = x;
1840 self->y = y;
1841 }
1842 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1844 PyObject* tup = PyTuple_New(2);
1845 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1846 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1847 wxPyEndBlockThreads(blocked);
1848 return tup;
1849 }
1850
1851 SWIGINTERNSHORT long
1852 SWIG_As_long(PyObject* obj)
1853 {
1854 long v;
1855 if (!SWIG_AsVal_long(obj, &v)) {
1856 /*
1857 this is needed to make valgrind/purify happier.
1858 */
1859 memset((void*)&v, 0, sizeof(long));
1860 }
1861 return v;
1862 }
1863
1864
1865 SWIGINTERNSHORT int
1866 SWIG_Check_long(PyObject* obj)
1867 {
1868 return SWIG_AsVal_long(obj, (long*)0);
1869 }
1870
1871 static void wxPoint_Set(wxPoint *self,long x,long y){
1872 self->x = x;
1873 self->y = y;
1874 }
1875 static PyObject *wxPoint_Get(wxPoint *self){
1876 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1877 PyObject* tup = PyTuple_New(2);
1878 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1879 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1880 wxPyEndBlockThreads(blocked);
1881 return tup;
1882 }
1883 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1884 self->x = x;
1885 self->y = y;
1886 self->width = width;
1887 self->height = height;
1888 }
1889 static PyObject *wxRect_Get(wxRect *self){
1890 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1891 PyObject* tup = PyTuple_New(4);
1892 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1893 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1894 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1895 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1896 wxPyEndBlockThreads(blocked);
1897 return tup;
1898 }
1899
1900 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1901 wxRegion reg1(*r1);
1902 wxRegion reg2(*r2);
1903 wxRect dest(0,0,0,0);
1904 PyObject* obj;
1905
1906 reg1.Intersect(reg2);
1907 dest = reg1.GetBox();
1908
1909 if (dest != wxRect(0,0,0,0)) {
1910 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1911 wxRect* newRect = new wxRect(dest);
1912 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1913 wxPyEndBlockThreads(blocked);
1914 return obj;
1915 }
1916 Py_INCREF(Py_None);
1917 return Py_None;
1918 }
1919
1920
1921 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1922 PyObject* o2;
1923 PyObject* o3;
1924
1925 if (!target) {
1926 target = o;
1927 } else if (target == Py_None) {
1928 Py_DECREF(Py_None);
1929 target = o;
1930 } else {
1931 if (!PyTuple_Check(target)) {
1932 o2 = target;
1933 target = PyTuple_New(1);
1934 PyTuple_SetItem(target, 0, o2);
1935 }
1936 o3 = PyTuple_New(1);
1937 PyTuple_SetItem(o3, 0, o);
1938
1939 o2 = target;
1940 target = PySequence_Concat(o2, o3);
1941 Py_DECREF(o2);
1942 Py_DECREF(o3);
1943 }
1944 return target;
1945 }
1946
1947
1948 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1949 self->m_x = x;
1950 self->m_y = y;
1951 }
1952 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1953 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1954 PyObject* tup = PyTuple_New(2);
1955 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1956 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1957 wxPyEndBlockThreads(blocked);
1958 return tup;
1959 }
1960
1961 #include "wx/wxPython/pyistream.h"
1962
1963 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1964 wxInputStream* wxis = wxPyCBInputStream::create(p);
1965 if (wxis)
1966 return new wxPyInputStream(wxis);
1967 else
1968 return NULL;
1969 }
1970
1971 SWIGINTERNSHORT PyObject*
1972 SWIG_From_char(char c)
1973 {
1974 return PyString_FromStringAndSize(&c,1);
1975 }
1976
1977
1978 SWIGINTERNSHORT PyObject*
1979 SWIG_From_unsigned_SS_long(unsigned long value)
1980 {
1981 return (value > LONG_MAX) ?
1982 PyLong_FromUnsignedLong(value)
1983 : PyInt_FromLong((long)(value));
1984 }
1985
1986
1987 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1988 SWIGINTERN int
1989 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1990 {
1991 static swig_type_info* pchar_info = 0;
1992 char* vptr = 0;
1993 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1994 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1995 if (cptr) *cptr = vptr;
1996 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1997 return SWIG_OLDOBJ;
1998 } else {
1999 PyErr_Clear();
2000 if (PyString_Check(obj)) {
2001 if (cptr) {
2002 *cptr = PyString_AS_STRING(obj);
2003 if (psize) {
2004 *psize = PyString_GET_SIZE(obj) + 1;
2005 }
2006 }
2007 return SWIG_PYSTR;
2008 }
2009 }
2010 if (cptr) {
2011 SWIG_type_error("char *", obj);
2012 }
2013 return 0;
2014 }
2015
2016
2017 SWIGINTERN int
2018 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2019 {
2020 char* cptr; size_t csize;
2021 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2022 /* in C you can do:
2023
2024 char x[5] = "hello";
2025
2026 ie, assing the array using an extra '0' char.
2027 */
2028 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2029 if (csize <= size) {
2030 if (val) {
2031 if (csize) memcpy(val, cptr, csize);
2032 if (csize < size) memset(val + csize, 0, size - csize);
2033 }
2034 return 1;
2035 }
2036 }
2037 if (val) {
2038 PyErr_Format(PyExc_TypeError,
2039 "a char array of maximum size %lu is expected",
2040 (unsigned long) size);
2041 }
2042 return 0;
2043 }
2044
2045
2046 SWIGINTERN int
2047 SWIG_AsVal_char(PyObject *obj, char *val)
2048 {
2049 const char* errmsg = val ? "char" : (char*)0;
2050 long v;
2051 if (SWIG_AsVal_long(obj, &v)) {
2052 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2053 if (val) *val = (char)(v);
2054 return 1;
2055 } else {
2056 return 0;
2057 }
2058 } else {
2059 PyErr_Clear();
2060 return SWIG_AsCharArray(obj, val, 1);
2061 }
2062 }
2063
2064
2065 SWIGINTERNSHORT char
2066 SWIG_As_char(PyObject* obj)
2067 {
2068 char v;
2069 if (!SWIG_AsVal_char(obj, &v)) {
2070 /*
2071 this is needed to make valgrind/purify happier.
2072 */
2073 memset((void*)&v, 0, sizeof(char));
2074 }
2075 return v;
2076 }
2077
2078
2079 SWIGINTERNSHORT int
2080 SWIG_Check_char(PyObject* obj)
2081 {
2082 return SWIG_AsVal_char(obj, (char*)0);
2083 }
2084
2085
2086 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2087 #define SWIG_From_long PyInt_FromLong
2088 /*@@*/
2089
2090 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2091 // We use only strings for the streams, not unicode
2092 PyObject* str = PyObject_Str(obj);
2093 if (! str) {
2094 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2095 return;
2096 }
2097 self->Write(PyString_AS_STRING(str),
2098 PyString_GET_SIZE(str));
2099 Py_DECREF(str);
2100 }
2101
2102 #include "wx/wxPython/pyistream.h"
2103
2104
2105 class wxPyFileSystemHandler : public wxFileSystemHandler
2106 {
2107 public:
2108 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2109
2110 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2111 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2112 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2113 DEC_PYCALLBACK_STRING__pure(FindNext);
2114
2115 wxString GetProtocol(const wxString& location) {
2116 return wxFileSystemHandler::GetProtocol(location);
2117 }
2118
2119 wxString GetLeftLocation(const wxString& location) {
2120 return wxFileSystemHandler::GetLeftLocation(location);
2121 }
2122
2123 wxString GetAnchor(const wxString& location) {
2124 return wxFileSystemHandler::GetAnchor(location);
2125 }
2126
2127 wxString GetRightLocation(const wxString& location) {
2128 return wxFileSystemHandler::GetRightLocation(location);
2129 }
2130
2131 wxString GetMimeTypeFromExt(const wxString& location) {
2132 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2133 }
2134
2135 PYPRIVATE;
2136 };
2137
2138
2139 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2140 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2141 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2142 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2143
2144
2145 SWIGINTERN int
2146 SWIG_AsVal_bool(PyObject *obj, bool *val)
2147 {
2148 if (obj == Py_True) {
2149 if (val) *val = true;
2150 return 1;
2151 }
2152 if (obj == Py_False) {
2153 if (val) *val = false;
2154 return 1;
2155 }
2156 int res = 0;
2157 if (SWIG_AsVal_int(obj, &res)) {
2158 if (val) *val = res ? true : false;
2159 return 1;
2160 } else {
2161 PyErr_Clear();
2162 }
2163 if (val) {
2164 SWIG_type_error("bool", obj);
2165 }
2166 return 0;
2167 }
2168
2169
2170 SWIGINTERNSHORT bool
2171 SWIG_As_bool(PyObject* obj)
2172 {
2173 bool v;
2174 if (!SWIG_AsVal_bool(obj, &v)) {
2175 /*
2176 this is needed to make valgrind/purify happier.
2177 */
2178 memset((void*)&v, 0, sizeof(bool));
2179 }
2180 return v;
2181 }
2182
2183
2184 SWIGINTERNSHORT int
2185 SWIG_Check_bool(PyObject* obj)
2186 {
2187 return SWIG_AsVal_bool(obj, (bool*)0);
2188 }
2189
2190 static wxString FileSystem_URLToFileName(wxString const &url){
2191 wxFileName fname = wxFileSystem::URLToFileName(url);
2192 return fname.GetFullPath();
2193 }
2194
2195 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2196 wxImage& image,
2197 long type) {
2198 wxMemoryFSHandler::AddFile(filename, image, type);
2199 }
2200
2201 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2202 const wxBitmap& bitmap,
2203 long type) {
2204 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2205 }
2206
2207 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2208 PyObject* data) {
2209 if (! PyString_Check(data)) {
2210 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2211 "Expected string object"));
2212 return;
2213 }
2214
2215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2216 void* ptr = (void*)PyString_AsString(data);
2217 size_t size = PyString_Size(data);
2218 wxPyEndBlockThreads(blocked);
2219
2220 wxMemoryFSHandler::AddFile(filename, ptr, size);
2221 }
2222
2223
2224 #include "wx/wxPython/pyistream.h"
2225
2226
2227 SWIGINTERN int
2228 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2229 {
2230 long v = 0;
2231 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2232 SWIG_type_error("unsigned number", obj);
2233 }
2234 else if (val)
2235 *val = (unsigned long)v;
2236 return 1;
2237 }
2238
2239
2240 SWIGINTERNSHORT int
2241 SWIG_CheckUnsignedLongInRange(unsigned long value,
2242 unsigned long max_value,
2243 const char *errmsg)
2244 {
2245 if (value > max_value) {
2246 if (errmsg) {
2247 PyErr_Format(PyExc_OverflowError,
2248 "value %lu is greater than '%s' minimum %lu",
2249 value, errmsg, max_value);
2250 }
2251 return 0;
2252 }
2253 return 1;
2254 }
2255
2256
2257 SWIGINTERN int
2258 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2259 {
2260 const char* errmsg = val ? "unsigned char" : (char*)0;
2261 unsigned long v;
2262 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2263 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2264 if (val) *val = (unsigned char)(v);
2265 return 1;
2266 } else {
2267 return 0;
2268 }
2269 } else {
2270 PyErr_Clear();
2271 }
2272 if (val) {
2273 SWIG_type_error(errmsg, obj);
2274 }
2275 return 0;
2276 }
2277
2278
2279 SWIGINTERNSHORT unsigned char
2280 SWIG_As_unsigned_SS_char(PyObject* obj)
2281 {
2282 unsigned char v;
2283 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2284 /*
2285 this is needed to make valgrind/purify happier.
2286 */
2287 memset((void*)&v, 0, sizeof(unsigned char));
2288 }
2289 return v;
2290 }
2291
2292
2293 SWIGINTERNSHORT int
2294 SWIG_Check_unsigned_SS_char(PyObject* obj)
2295 {
2296 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2297 }
2298
2299
2300 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2301 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2302 /*@@*/
2303
2304
2305
2306 SWIGINTERNSHORT unsigned long
2307 SWIG_As_unsigned_SS_long(PyObject* obj)
2308 {
2309 unsigned long v;
2310 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2311 /*
2312 this is needed to make valgrind/purify happier.
2313 */
2314 memset((void*)&v, 0, sizeof(unsigned long));
2315 }
2316 return v;
2317 }
2318
2319
2320 SWIGINTERNSHORT int
2321 SWIG_Check_unsigned_SS_long(PyObject* obj)
2322 {
2323 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2324 }
2325
2326 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2327 wxImageHistogramEntry e = (*self)[key];
2328 return e.value;
2329 }
2330 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,unsigned char r,unsigned char g,unsigned char b){
2331 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2332 wxImageHistogramEntry e = (*self)[key];
2333 return e.value;
2334 }
2335 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2336 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2337 colour.Green(),
2338 colour.Blue());
2339 wxImageHistogramEntry e = (*self)[key];
2340 return e.value;
2341 }
2342
2343 typedef unsigned char* buffer;
2344
2345 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2346 if (width > 0 && height > 0)
2347 return new wxImage(width, height, clear);
2348 else
2349 return new wxImage;
2350 }
2351 static wxImage *new_wxImage(wxBitmap const &bitmap){
2352 return new wxImage(bitmap.ConvertToImage());
2353 }
2354 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2355 if (DATASIZE != width*height*3) {
2356 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2357 return NULL;
2358 }
2359
2360 // Copy the source data so the wxImage can clean it up later
2361 buffer copy = (buffer)malloc(DATASIZE);
2362 if (copy == NULL) {
2363 wxPyBLOCK_THREADS(PyErr_NoMemory());
2364 return NULL;
2365 }
2366 memcpy(copy, data, DATASIZE);
2367 return new wxImage(width, height, copy, false);
2368 }
2369 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2370 if (DATASIZE != width*height*3) {
2371 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2372 return NULL;
2373 }
2374 if (ALPHASIZE != width*height) {
2375 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2376 return NULL;
2377 }
2378
2379 // Copy the source data so the wxImage can clean it up later
2380 buffer dcopy = (buffer)malloc(DATASIZE);
2381 if (dcopy == NULL) {
2382 wxPyBLOCK_THREADS(PyErr_NoMemory());
2383 return NULL;
2384 }
2385 memcpy(dcopy, data, DATASIZE);
2386
2387 buffer acopy = (buffer)malloc(ALPHASIZE);
2388 if (acopy == NULL) {
2389 wxPyBLOCK_THREADS(PyErr_NoMemory());
2390 return NULL;
2391 }
2392 memcpy(acopy, alpha, ALPHASIZE);
2393
2394 return new wxImage(width, height, dcopy, acopy, false);
2395 }
2396 static wxSize wxImage_GetSize(wxImage *self){
2397 wxSize size(self->GetWidth(), self->GetHeight());
2398 return size;
2399 }
2400 static PyObject *wxImage_GetData(wxImage *self){
2401 buffer data = self->GetData();
2402 int len = self->GetWidth() * self->GetHeight() * 3;
2403 PyObject* rv;
2404 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2405 return rv;
2406 }
2407 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2408 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2409 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2410 return;
2411 }
2412 buffer copy = (buffer)malloc(DATASIZE);
2413 if (copy == NULL) {
2414 wxPyBLOCK_THREADS(PyErr_NoMemory());
2415 return;
2416 }
2417 memcpy(copy, data, DATASIZE);
2418 self->SetData(copy, false);
2419 // wxImage takes ownership of copy...
2420 }
2421 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2422 buffer data = self->GetData();
2423 int len = self->GetWidth() * self->GetHeight() * 3;
2424 PyObject* rv;
2425 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2426 return rv;
2427 }
2428 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2429 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2430 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2431 return;
2432 }
2433 self->SetData(data, true);
2434 }
2435 static PyObject *wxImage_GetAlphaData(wxImage *self){
2436 buffer data = self->GetAlpha();
2437 if (! data) {
2438 RETURN_NONE();
2439 } else {
2440 int len = self->GetWidth() * self->GetHeight();
2441 PyObject* rv;
2442 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2443 return rv;
2444 }
2445 }
2446 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2447 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2448 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2449 return;
2450 }
2451 buffer acopy = (buffer)malloc(ALPHASIZE);
2452 if (acopy == NULL) {
2453 wxPyBLOCK_THREADS(PyErr_NoMemory());
2454 return;
2455 }
2456 memcpy(acopy, alpha, ALPHASIZE);
2457 self->SetAlpha(acopy, false);
2458 // wxImage takes ownership of acopy...
2459 }
2460 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2461 buffer data = self->GetAlpha();
2462 int len = self->GetWidth() * self->GetHeight();
2463 PyObject* rv;
2464 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2465 return rv;
2466 }
2467 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2468 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2469 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2470 return;
2471 }
2472 self->SetAlpha(alpha, true);
2473 }
2474 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2475 wxBitmap bitmap(*self, depth);
2476 return bitmap;
2477 }
2478 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2479 wxImage mono = self->ConvertToMono( red, green, blue );
2480 wxBitmap bitmap( mono, 1 );
2481 return bitmap;
2482 }
2483 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2484 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2485 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2487 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2491 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2492 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2493 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2494 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2495 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2496 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2497 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2498
2499 #include <wx/quantize.h>
2500
2501 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2502 return wxQuantize::Quantize(src, dest,
2503 //NULL, // palette
2504 desiredNoColours,
2505 NULL, // eightBitData
2506 flags);
2507 }
2508 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2509 if (PyCallable_Check(func)) {
2510 self->Connect(id, lastId, eventType,
2511 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2512 new wxPyCallback(func));
2513 }
2514 else if (func == Py_None) {
2515 self->Disconnect(id, lastId, eventType,
2516 (wxObjectEventFunction)
2517 &wxPyCallback::EventThunker);
2518 }
2519 else {
2520 wxPyBLOCK_THREADS(
2521 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2522 }
2523 }
2524 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2525 return self->Disconnect(id, lastId, eventType,
2526 (wxObjectEventFunction)
2527 &wxPyCallback::EventThunker);
2528 }
2529 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2530 if (_self && _self != Py_None) {
2531 self->SetClientObject(new wxPyOORClientData(_self, incref));
2532 }
2533 else {
2534 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2535 if (data) {
2536 self->SetClientObject(NULL); // This will delete it too
2537 }
2538 }
2539 }
2540
2541 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2542 #if wxUSE_UNICODE
2543 return self->GetUnicodeKey();
2544 #else
2545 return 0;
2546 #endif
2547 }
2548
2549 #if UINT_MAX < LONG_MAX
2550 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2551 #define SWIG_From_unsigned_SS_int SWIG_From_long
2552 /*@@*/
2553 #else
2554 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2555 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2556 /*@@*/
2557 #endif
2558
2559
2560 #if UINT_MAX != ULONG_MAX
2561 SWIGINTERN int
2562 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2563 {
2564 const char* errmsg = val ? "unsigned int" : (char*)0;
2565 unsigned long v;
2566 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2567 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2568 if (val) *val = (unsigned int)(v);
2569 return 1;
2570 }
2571 } else {
2572 PyErr_Clear();
2573 }
2574 if (val) {
2575 SWIG_type_error(errmsg, obj);
2576 }
2577 return 0;
2578 }
2579 #else
2580 SWIGINTERNSHORT unsigned int
2581 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2582 {
2583 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2584 }
2585 #endif
2586
2587
2588 SWIGINTERNSHORT unsigned int
2589 SWIG_As_unsigned_SS_int(PyObject* obj)
2590 {
2591 unsigned int v;
2592 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2593 /*
2594 this is needed to make valgrind/purify happier.
2595 */
2596 memset((void*)&v, 0, sizeof(unsigned int));
2597 }
2598 return v;
2599 }
2600
2601
2602 SWIGINTERNSHORT int
2603 SWIG_Check_unsigned_SS_int(PyObject* obj)
2604 {
2605 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2606 }
2607
2608 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2609 self->m_size = size;
2610 }
2611 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2612 int count = self->GetNumberOfFiles();
2613 wxString* files = self->GetFiles();
2614 PyObject* list = PyList_New(count);
2615
2616 if (!list) {
2617 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2618 return NULL;
2619 }
2620
2621 for (int i=0; i<count; i++) {
2622 PyList_SetItem(list, i, wx2PyString(files[i]));
2623 }
2624 return list;
2625 }
2626
2627
2628 static wxPyApp *new_wxPyApp(){
2629 wxPythonApp = new wxPyApp();
2630 return wxPythonApp;
2631 }
2632 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2633
2634 void wxApp_CleanUp() {
2635 __wxPyCleanup();
2636 }
2637
2638
2639 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2640
2641
2642 SWIGINTERNSHORT int
2643 SWIG_AsCharPtr(PyObject *obj, char **val)
2644 {
2645 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2646 return 1;
2647 }
2648 if (val) {
2649 PyErr_Clear();
2650 SWIG_type_error("char *", obj);
2651 }
2652 return 0;
2653 }
2654
2655
2656 SWIGINTERN PyObject *
2657 SWIG_FromCharPtr(const char* cptr)
2658 {
2659 if (cptr) {
2660 size_t size = strlen(cptr);
2661 if (size > INT_MAX) {
2662 return SWIG_NewPointerObj((char*)(cptr),
2663 SWIG_TypeQuery("char *"), 0);
2664 } else {
2665 if (size != 0) {
2666 return PyString_FromStringAndSize(cptr, size);
2667 } else {
2668 return PyString_FromString(cptr);
2669 }
2670 }
2671 }
2672 Py_INCREF(Py_None);
2673 return Py_None;
2674 }
2675
2676
2677 #ifdef __WXMAC__
2678
2679 // A dummy class that raises an exception if used...
2680 class wxEventLoop
2681 {
2682 public:
2683 wxEventLoop() { wxPyRaiseNotImplemented(); }
2684 int Run() { return 0; }
2685 void Exit(int rc = 0) {}
2686 bool Pending() const { return false; }
2687 bool Dispatch() { return false; }
2688 bool IsRunning() const { return false; }
2689 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2690 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2691 };
2692
2693 #else
2694
2695 #include <wx/evtloop.h>
2696
2697 #endif
2698
2699
2700
2701 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2702 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2703 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2704 static PyObject *wxWindow_GetChildren(wxWindow *self){
2705 wxWindowList& list = self->GetChildren();
2706 return wxPy_ConvertList(&list);
2707 }
2708 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2709 #if wxUSE_HOTKEY
2710 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2711 #else
2712 return false;
2713 #endif
2714 }
2715 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2716
2717
2718
2719 return false;
2720
2721 }
2722 static long wxWindow_GetHandle(wxWindow *self){
2723 return wxPyGetWinHandle(self);
2724 }
2725 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2726 self->AssociateHandle((WXWidget)handle);
2727 }
2728
2729 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2730 return wxWindow::FindWindowById(id, parent);
2731 }
2732
2733 wxWindow* wxFindWindowByName( const wxString& name,
2734 const wxWindow *parent = NULL ) {
2735 return wxWindow::FindWindowByName(name, parent);
2736 }
2737
2738 wxWindow* wxFindWindowByLabel( const wxString& label,
2739 const wxWindow *parent = NULL ) {
2740 return wxWindow::FindWindowByLabel(label, parent);
2741 }
2742
2743
2744 #ifdef __WXMSW__
2745 #include <wx/msw/private.h> // to get wxGetWindowId
2746 #endif
2747
2748
2749 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2750 #ifdef __WXMSW__
2751 WXHWND hWnd = (WXHWND)_hWnd;
2752 long id = wxGetWindowId(hWnd);
2753 wxWindow* win = new wxWindow;
2754 parent->AddChild(win);
2755 win->SetEventHandler(win);
2756 win->SetHWND(hWnd);
2757 win->SetId(id);
2758 win->SubclassWin(hWnd);
2759 win->AdoptAttributesFromHWND();
2760 win->SetupColours();
2761 return win;
2762 #else
2763 wxPyRaiseNotImplemented();
2764 return NULL;
2765 #endif
2766 }
2767
2768
2769 PyObject* GetTopLevelWindows() {
2770 return wxPy_ConvertList(&wxTopLevelWindows);
2771 }
2772
2773
2774 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2775 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2776 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2777
2778 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2779
2780 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2781 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2782 wxMenuItemList& list = self->GetMenuItems();
2783 return wxPy_ConvertList(&list);
2784 }
2785 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2786 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2787 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2788 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2789 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2790 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2791 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2792 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2793 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2794 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2795 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2796 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2797 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2798 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2799 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2800 static const wxString wxPyControlNameStr(wxControlNameStr);
2801 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2802 if (clientData) {
2803 wxPyClientData* data = new wxPyClientData(clientData);
2804 return self->Append(item, data);
2805 } else
2806 return self->Append(item);
2807 }
2808 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2809 if (clientData) {
2810 wxPyClientData* data = new wxPyClientData(clientData);
2811 return self->Insert(item, pos, data);
2812 } else
2813 return self->Insert(item, pos);
2814 }
2815 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2816 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2817 if (data) {
2818 Py_INCREF(data->m_obj);
2819 return data->m_obj;
2820 } else {
2821 Py_INCREF(Py_None);
2822 return Py_None;
2823 }
2824 }
2825 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2826 wxPyClientData* data = new wxPyClientData(clientData);
2827 self->SetClientObject(n, data);
2828 }
2829
2830
2831 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2832 wxPyUserData* data = NULL;
2833 if ( userData ) {
2834 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2835 data = new wxPyUserData(userData);
2836 wxPyEndBlockThreads(blocked);
2837 }
2838 return new wxSizerItem(window, proportion, flag, border, data);
2839 }
2840 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2841 wxPyUserData* data = NULL;
2842 if ( userData ) {
2843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2844 data = new wxPyUserData(userData);
2845 wxPyEndBlockThreads(blocked);
2846 }
2847 return new wxSizerItem(width, height, proportion, flag, border, data);
2848 }
2849 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2850 wxPyUserData* data = NULL;
2851 if ( userData ) {
2852 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2853 data = new wxPyUserData(userData);
2854 wxPyEndBlockThreads(blocked);
2855 }
2856 return new wxSizerItem(sizer, proportion, flag, border, data);
2857 }
2858
2859 #include <float.h>
2860 SWIGINTERN int
2861 SWIG_CheckDoubleInRange(double value, double min_value,
2862 double max_value, const char* errmsg)
2863 {
2864 if (value < min_value) {
2865 if (errmsg) {
2866 PyErr_Format(PyExc_OverflowError,
2867 "value %g is less than %s minimum %g",
2868 value, errmsg, min_value);
2869 }
2870 return 0;
2871 } else if (value > max_value) {
2872 if (errmsg) {
2873 PyErr_Format(PyExc_OverflowError,
2874 "value %g is greater than %s maximum %g",
2875 value, errmsg, max_value);
2876 }
2877 return 0;
2878 }
2879 return 1;
2880 }
2881
2882
2883 SWIGINTERN int
2884 SWIG_AsVal_float(PyObject *obj, float *val)
2885 {
2886 const char* errmsg = val ? "float" : (char*)0;
2887 double v;
2888 if (SWIG_AsVal_double(obj, &v)) {
2889 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2890 if (val) *val = (float)(v);
2891 return 1;
2892 } else {
2893 return 0;
2894 }
2895 } else {
2896 PyErr_Clear();
2897 }
2898 if (val) {
2899 SWIG_type_error(errmsg, obj);
2900 }
2901 return 0;
2902 }
2903
2904
2905 SWIGINTERNSHORT float
2906 SWIG_As_float(PyObject* obj)
2907 {
2908 float v;
2909 if (!SWIG_AsVal_float(obj, &v)) {
2910 /*
2911 this is needed to make valgrind/purify happier.
2912 */
2913 memset((void*)&v, 0, sizeof(float));
2914 }
2915 return v;
2916 }
2917
2918
2919 SWIGINTERNSHORT int
2920 SWIG_Check_float(PyObject* obj)
2921 {
2922 return SWIG_AsVal_float(obj, (float*)0);
2923 }
2924
2925
2926 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2927 #define SWIG_From_float PyFloat_FromDouble
2928 /*@@*/
2929
2930 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2931 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2932 if (data) {
2933 Py_INCREF(data->m_obj);
2934 return data->m_obj;
2935 } else {
2936 Py_INCREF(Py_None);
2937 return Py_None;
2938 }
2939 }
2940
2941 // Figure out the type of the sizer item
2942
2943 struct wxPySizerItemInfo {
2944 wxPySizerItemInfo()
2945 : window(NULL), sizer(NULL), gotSize(false),
2946 size(wxDefaultSize), gotPos(false), pos(-1)
2947 {}
2948
2949 wxWindow* window;
2950 wxSizer* sizer;
2951 bool gotSize;
2952 wxSize size;
2953 bool gotPos;
2954 int pos;
2955 };
2956
2957 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2958
2959 wxPySizerItemInfo info;
2960 wxSize size;
2961 wxSize* sizePtr = &size;
2962
2963 // Find out what the type of the item is
2964 // try wxWindow
2965 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2966 PyErr_Clear();
2967 info.window = NULL;
2968
2969 // try wxSizer
2970 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2971 PyErr_Clear();
2972 info.sizer = NULL;
2973
2974 // try wxSize or (w,h)
2975 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2976 info.size = *sizePtr;
2977 info.gotSize = true;
2978 }
2979
2980 // or a single int
2981 if (checkIdx && PyInt_Check(item)) {
2982 info.pos = PyInt_AsLong(item);
2983 info.gotPos = true;
2984 }
2985 }
2986 }
2987
2988 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2989 // no expected type, figure out what kind of error message to generate
2990 if ( !checkSize && !checkIdx )
2991 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2992 else if ( checkSize && !checkIdx )
2993 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2994 else if ( !checkSize && checkIdx)
2995 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2996 else
2997 // can this one happen?
2998 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2999 }
3000
3001 return info;
3002 }
3003
3004 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3005 if (!self->GetClientObject())
3006 self->SetClientObject(new wxPyOORClientData(_self));
3007 }
3008 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3009
3010 wxPyUserData* data = NULL;
3011 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3012 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3013 if ( userData && (info.window || info.sizer || info.gotSize) )
3014 data = new wxPyUserData(userData);
3015 wxPyEndBlockThreads(blocked);
3016
3017 // Now call the real Add method if a valid item type was found
3018 if ( info.window )
3019 return self->Add(info.window, proportion, flag, border, data);
3020 else if ( info.sizer )
3021 return self->Add(info.sizer, proportion, flag, border, data);
3022 else if (info.gotSize)
3023 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3024 proportion, flag, border, data);
3025 else
3026 return NULL;
3027 }
3028 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3029
3030 wxPyUserData* data = NULL;
3031 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3032 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3033 if ( userData && (info.window || info.sizer || info.gotSize) )
3034 data = new wxPyUserData(userData);
3035 wxPyEndBlockThreads(blocked);
3036
3037 // Now call the real Insert method if a valid item type was found
3038 if ( info.window )
3039 return self->Insert(before, info.window, proportion, flag, border, data);
3040 else if ( info.sizer )
3041 return self->Insert(before, info.sizer, proportion, flag, border, data);
3042 else if (info.gotSize)
3043 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3044 proportion, flag, border, data);
3045 else
3046 return NULL;
3047 }
3048 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3049
3050 wxPyUserData* data = NULL;
3051 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3052 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3053 if ( userData && (info.window || info.sizer || info.gotSize) )
3054 data = new wxPyUserData(userData);
3055 wxPyEndBlockThreads(blocked);
3056
3057 // Now call the real Prepend method if a valid item type was found
3058 if ( info.window )
3059 return self->Prepend(info.window, proportion, flag, border, data);
3060 else if ( info.sizer )
3061 return self->Prepend(info.sizer, proportion, flag, border, data);
3062 else if (info.gotSize)
3063 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3064 proportion, flag, border, data);
3065 else
3066 return NULL;
3067 }
3068 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3069 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3070 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3071 wxPyEndBlockThreads(blocked);
3072 if ( info.window )
3073 return self->Remove(info.window);
3074 else if ( info.sizer )
3075 return self->Remove(info.sizer);
3076 else if ( info.gotPos )
3077 return self->Remove(info.pos);
3078 else
3079 return false;
3080 }
3081 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3082 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3083 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3084 wxPyEndBlockThreads(blocked);
3085 if ( info.window )
3086 return self->Detach(info.window);
3087 else if ( info.sizer )
3088 return self->Detach(info.sizer);
3089 else if ( info.gotPos )
3090 return self->Detach(info.pos);
3091 else
3092 return false;
3093 }
3094 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3095 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3096 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3097 wxPyEndBlockThreads(blocked);
3098 if ( info.window )
3099 return self->GetItem(info.window);
3100 else if ( info.sizer )
3101 return self->GetItem(info.sizer);
3102 else if ( info.gotPos )
3103 return self->GetItem(info.pos);
3104 else
3105 return NULL;
3106 }
3107 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3110 wxPyEndBlockThreads(blocked);
3111 if ( info.window )
3112 self->SetItemMinSize(info.window, size);
3113 else if ( info.sizer )
3114 self->SetItemMinSize(info.sizer, size);
3115 else if ( info.gotPos )
3116 self->SetItemMinSize(info.pos, size);
3117 }
3118 static PyObject *wxSizer_GetChildren(wxSizer *self){
3119 wxSizerItemList& list = self->GetChildren();
3120 return wxPy_ConvertList(&list);
3121 }
3122 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3123 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3124 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3125 wxPyEndBlockThreads(blocked);
3126 if ( info.window )
3127 return self->Show(info.window, show, recursive);
3128 else if ( info.sizer )
3129 return self->Show(info.sizer, show, recursive);
3130 else if ( info.gotPos )
3131 return self->Show(info.pos, show);
3132 else
3133 return false;
3134 }
3135 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3136 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3137 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3138 wxPyEndBlockThreads(blocked);
3139 if ( info.window )
3140 return self->IsShown(info.window);
3141 else if ( info.sizer )
3142 return self->IsShown(info.sizer);
3143 else if ( info.gotPos )
3144 return self->IsShown(info.pos);
3145 else
3146 return false;
3147 }
3148
3149 // See pyclasses.h
3150 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3151 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3152 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3153
3154
3155
3156
3157 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3158 {
3159 if (source == Py_None) {
3160 **obj = wxGBPosition(-1,-1);
3161 return true;
3162 }
3163 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3164 }
3165
3166 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3167 {
3168 if (source == Py_None) {
3169 **obj = wxGBSpan(-1,-1);
3170 return true;
3171 }
3172 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3173 }
3174
3175
3176 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3177 self->SetRow(row);
3178 self->SetCol(col);
3179 }
3180 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3182 PyObject* tup = PyTuple_New(2);
3183 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3184 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3185 wxPyEndBlockThreads(blocked);
3186 return tup;
3187 }
3188 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3189 self->SetRowspan(rowspan);
3190 self->SetColspan(colspan);
3191 }
3192 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3194 PyObject* tup = PyTuple_New(2);
3195 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3196 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3197 wxPyEndBlockThreads(blocked);
3198 return tup;
3199 }
3200 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3201 wxPyUserData* data = NULL;
3202 if ( userData ) {
3203 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3204 data = new wxPyUserData(userData);
3205 wxPyEndBlockThreads(blocked);
3206 }
3207 return new wxGBSizerItem(window, pos, span, flag, border, data);
3208 }
3209 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3210 wxPyUserData* data = NULL;
3211 if ( userData ) {
3212 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3213 data = new wxPyUserData(userData);
3214 wxPyEndBlockThreads(blocked);
3215 }
3216 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3217 }
3218 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3219 wxPyUserData* data = NULL;
3220 if ( userData ) {
3221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3222 data = new wxPyUserData(userData);
3223 wxPyEndBlockThreads(blocked);
3224 }
3225 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3226 }
3227 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3228 int row, col;
3229 self->GetEndPos(row, col);
3230 return wxGBPosition(row, col);
3231 }
3232 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3233
3234 wxPyUserData* data = NULL;
3235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3237 if ( userData && (info.window || info.sizer || info.gotSize) )
3238 data = new wxPyUserData(userData);
3239 wxPyEndBlockThreads(blocked);
3240
3241 // Now call the real Add method if a valid item type was found
3242 if ( info.window )
3243 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3244 else if ( info.sizer )
3245 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3246 else if (info.gotSize)
3247 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3248 pos, span, flag, border, data);
3249 return NULL;
3250 }
3251
3252
3253 #ifdef __cplusplus
3254 extern "C" {
3255 #endif
3256 static int _wrap_EmptyString_set(PyObject *) {
3257 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3258 return 1;
3259 }
3260
3261
3262 static PyObject *_wrap_EmptyString_get(void) {
3263 PyObject *pyobj;
3264
3265 {
3266 #if wxUSE_UNICODE
3267 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3268 #else
3269 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3270 #endif
3271 }
3272 return pyobj;
3273 }
3274
3275
3276 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3277 PyObject *resultobj;
3278 wxObject *arg1 = (wxObject *) 0 ;
3279 wxString result;
3280 PyObject * obj0 = 0 ;
3281 char *kwnames[] = {
3282 (char *) "self", NULL
3283 };
3284
3285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3287 if (SWIG_arg_fail(1)) SWIG_fail;
3288 {
3289 PyThreadState* __tstate = wxPyBeginAllowThreads();
3290 result = wxObject_GetClassName(arg1);
3291
3292 wxPyEndAllowThreads(__tstate);
3293 if (PyErr_Occurred()) SWIG_fail;
3294 }
3295 {
3296 #if wxUSE_UNICODE
3297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3298 #else
3299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3300 #endif
3301 }
3302 return resultobj;
3303 fail:
3304 return NULL;
3305 }
3306
3307
3308 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3309 PyObject *resultobj;
3310 wxObject *arg1 = (wxObject *) 0 ;
3311 PyObject * obj0 = 0 ;
3312 char *kwnames[] = {
3313 (char *) "self", NULL
3314 };
3315
3316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3318 if (SWIG_arg_fail(1)) SWIG_fail;
3319 {
3320 PyThreadState* __tstate = wxPyBeginAllowThreads();
3321 wxObject_Destroy(arg1);
3322
3323 wxPyEndAllowThreads(__tstate);
3324 if (PyErr_Occurred()) SWIG_fail;
3325 }
3326 Py_INCREF(Py_None); resultobj = Py_None;
3327 return resultobj;
3328 fail:
3329 return NULL;
3330 }
3331
3332
3333 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3334 PyObject *obj;
3335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3336 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3337 Py_INCREF(obj);
3338 return Py_BuildValue((char *)"");
3339 }
3340 static PyObject *_wrap_Size_width_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 *) "x", NULL
3348 };
3349
3350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_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)->x = 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_width_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_width_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)->x);
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_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3390 PyObject *resultobj;
3391 wxSize *arg1 = (wxSize *) 0 ;
3392 int arg2 ;
3393 PyObject * obj0 = 0 ;
3394 PyObject * obj1 = 0 ;
3395 char *kwnames[] = {
3396 (char *) "self",(char *) "y", NULL
3397 };
3398
3399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3401 if (SWIG_arg_fail(1)) SWIG_fail;
3402 {
3403 arg2 = (int)(SWIG_As_int(obj1));
3404 if (SWIG_arg_fail(2)) SWIG_fail;
3405 }
3406 if (arg1) (arg1)->y = arg2;
3407
3408 Py_INCREF(Py_None); resultobj = Py_None;
3409 return resultobj;
3410 fail:
3411 return NULL;
3412 }
3413
3414
3415 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3416 PyObject *resultobj;
3417 wxSize *arg1 = (wxSize *) 0 ;
3418 int result;
3419 PyObject * obj0 = 0 ;
3420 char *kwnames[] = {
3421 (char *) "self", NULL
3422 };
3423
3424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3426 if (SWIG_arg_fail(1)) SWIG_fail;
3427 result = (int) ((arg1)->y);
3428
3429 {
3430 resultobj = SWIG_From_int((int)(result));
3431 }
3432 return resultobj;
3433 fail:
3434 return NULL;
3435 }
3436
3437
3438 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3439 PyObject *resultobj;
3440 int arg1 = (int) 0 ;
3441 int arg2 = (int) 0 ;
3442 wxSize *result;
3443 PyObject * obj0 = 0 ;
3444 PyObject * obj1 = 0 ;
3445 char *kwnames[] = {
3446 (char *) "w",(char *) "h", NULL
3447 };
3448
3449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3450 if (obj0) {
3451 {
3452 arg1 = (int)(SWIG_As_int(obj0));
3453 if (SWIG_arg_fail(1)) SWIG_fail;
3454 }
3455 }
3456 if (obj1) {
3457 {
3458 arg2 = (int)(SWIG_As_int(obj1));
3459 if (SWIG_arg_fail(2)) SWIG_fail;
3460 }
3461 }
3462 {
3463 PyThreadState* __tstate = wxPyBeginAllowThreads();
3464 result = (wxSize *)new wxSize(arg1,arg2);
3465
3466 wxPyEndAllowThreads(__tstate);
3467 if (PyErr_Occurred()) SWIG_fail;
3468 }
3469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3470 return resultobj;
3471 fail:
3472 return NULL;
3473 }
3474
3475
3476 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3477 PyObject *resultobj;
3478 wxSize *arg1 = (wxSize *) 0 ;
3479 PyObject * obj0 = 0 ;
3480 char *kwnames[] = {
3481 (char *) "self", NULL
3482 };
3483
3484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3486 if (SWIG_arg_fail(1)) SWIG_fail;
3487 {
3488 PyThreadState* __tstate = wxPyBeginAllowThreads();
3489 delete arg1;
3490
3491 wxPyEndAllowThreads(__tstate);
3492 if (PyErr_Occurred()) SWIG_fail;
3493 }
3494 Py_INCREF(Py_None); resultobj = Py_None;
3495 return resultobj;
3496 fail:
3497 return NULL;
3498 }
3499
3500
3501 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3502 PyObject *resultobj;
3503 wxSize *arg1 = (wxSize *) 0 ;
3504 wxSize *arg2 = 0 ;
3505 bool result;
3506 wxSize temp2 ;
3507 PyObject * obj0 = 0 ;
3508 PyObject * obj1 = 0 ;
3509 char *kwnames[] = {
3510 (char *) "self",(char *) "sz", NULL
3511 };
3512
3513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3515 if (SWIG_arg_fail(1)) SWIG_fail;
3516 {
3517 arg2 = &temp2;
3518 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3519 }
3520 {
3521 PyThreadState* __tstate = wxPyBeginAllowThreads();
3522 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3523
3524 wxPyEndAllowThreads(__tstate);
3525 if (PyErr_Occurred()) SWIG_fail;
3526 }
3527 {
3528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3529 }
3530 return resultobj;
3531 fail:
3532 return NULL;
3533 }
3534
3535
3536 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3537 PyObject *resultobj;
3538 wxSize *arg1 = (wxSize *) 0 ;
3539 wxSize *arg2 = 0 ;
3540 bool result;
3541 wxSize temp2 ;
3542 PyObject * obj0 = 0 ;
3543 PyObject * obj1 = 0 ;
3544 char *kwnames[] = {
3545 (char *) "self",(char *) "sz", NULL
3546 };
3547
3548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3550 if (SWIG_arg_fail(1)) SWIG_fail;
3551 {
3552 arg2 = &temp2;
3553 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3554 }
3555 {
3556 PyThreadState* __tstate = wxPyBeginAllowThreads();
3557 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3558
3559 wxPyEndAllowThreads(__tstate);
3560 if (PyErr_Occurred()) SWIG_fail;
3561 }
3562 {
3563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3564 }
3565 return resultobj;
3566 fail:
3567 return NULL;
3568 }
3569
3570
3571 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3572 PyObject *resultobj;
3573 wxSize *arg1 = (wxSize *) 0 ;
3574 wxSize *arg2 = 0 ;
3575 wxSize result;
3576 wxSize temp2 ;
3577 PyObject * obj0 = 0 ;
3578 PyObject * obj1 = 0 ;
3579 char *kwnames[] = {
3580 (char *) "self",(char *) "sz", NULL
3581 };
3582
3583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3585 if (SWIG_arg_fail(1)) SWIG_fail;
3586 {
3587 arg2 = &temp2;
3588 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3589 }
3590 {
3591 PyThreadState* __tstate = wxPyBeginAllowThreads();
3592 result = (arg1)->operator +((wxSize const &)*arg2);
3593
3594 wxPyEndAllowThreads(__tstate);
3595 if (PyErr_Occurred()) SWIG_fail;
3596 }
3597 {
3598 wxSize * resultptr;
3599 resultptr = new wxSize((wxSize &)(result));
3600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3601 }
3602 return resultobj;
3603 fail:
3604 return NULL;
3605 }
3606
3607
3608 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3609 PyObject *resultobj;
3610 wxSize *arg1 = (wxSize *) 0 ;
3611 wxSize *arg2 = 0 ;
3612 wxSize result;
3613 wxSize temp2 ;
3614 PyObject * obj0 = 0 ;
3615 PyObject * obj1 = 0 ;
3616 char *kwnames[] = {
3617 (char *) "self",(char *) "sz", NULL
3618 };
3619
3620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3622 if (SWIG_arg_fail(1)) SWIG_fail;
3623 {
3624 arg2 = &temp2;
3625 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3626 }
3627 {
3628 PyThreadState* __tstate = wxPyBeginAllowThreads();
3629 result = (arg1)->operator -((wxSize const &)*arg2);
3630
3631 wxPyEndAllowThreads(__tstate);
3632 if (PyErr_Occurred()) SWIG_fail;
3633 }
3634 {
3635 wxSize * resultptr;
3636 resultptr = new wxSize((wxSize &)(result));
3637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3638 }
3639 return resultobj;
3640 fail:
3641 return NULL;
3642 }
3643
3644
3645 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3646 PyObject *resultobj;
3647 wxSize *arg1 = (wxSize *) 0 ;
3648 wxSize *arg2 = 0 ;
3649 wxSize temp2 ;
3650 PyObject * obj0 = 0 ;
3651 PyObject * obj1 = 0 ;
3652 char *kwnames[] = {
3653 (char *) "self",(char *) "sz", NULL
3654 };
3655
3656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3658 if (SWIG_arg_fail(1)) SWIG_fail;
3659 {
3660 arg2 = &temp2;
3661 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3662 }
3663 {
3664 PyThreadState* __tstate = wxPyBeginAllowThreads();
3665 (arg1)->IncTo((wxSize const &)*arg2);
3666
3667 wxPyEndAllowThreads(__tstate);
3668 if (PyErr_Occurred()) SWIG_fail;
3669 }
3670 Py_INCREF(Py_None); resultobj = Py_None;
3671 return resultobj;
3672 fail:
3673 return NULL;
3674 }
3675
3676
3677 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3678 PyObject *resultobj;
3679 wxSize *arg1 = (wxSize *) 0 ;
3680 wxSize *arg2 = 0 ;
3681 wxSize temp2 ;
3682 PyObject * obj0 = 0 ;
3683 PyObject * obj1 = 0 ;
3684 char *kwnames[] = {
3685 (char *) "self",(char *) "sz", NULL
3686 };
3687
3688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3690 if (SWIG_arg_fail(1)) SWIG_fail;
3691 {
3692 arg2 = &temp2;
3693 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3694 }
3695 {
3696 PyThreadState* __tstate = wxPyBeginAllowThreads();
3697 (arg1)->DecTo((wxSize const &)*arg2);
3698
3699 wxPyEndAllowThreads(__tstate);
3700 if (PyErr_Occurred()) SWIG_fail;
3701 }
3702 Py_INCREF(Py_None); resultobj = Py_None;
3703 return resultobj;
3704 fail:
3705 return NULL;
3706 }
3707
3708
3709 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3710 PyObject *resultobj;
3711 wxSize *arg1 = (wxSize *) 0 ;
3712 int arg2 ;
3713 int arg3 ;
3714 PyObject * obj0 = 0 ;
3715 PyObject * obj1 = 0 ;
3716 PyObject * obj2 = 0 ;
3717 char *kwnames[] = {
3718 (char *) "self",(char *) "w",(char *) "h", NULL
3719 };
3720
3721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3723 if (SWIG_arg_fail(1)) SWIG_fail;
3724 {
3725 arg2 = (int)(SWIG_As_int(obj1));
3726 if (SWIG_arg_fail(2)) SWIG_fail;
3727 }
3728 {
3729 arg3 = (int)(SWIG_As_int(obj2));
3730 if (SWIG_arg_fail(3)) SWIG_fail;
3731 }
3732 {
3733 PyThreadState* __tstate = wxPyBeginAllowThreads();
3734 (arg1)->Set(arg2,arg3);
3735
3736 wxPyEndAllowThreads(__tstate);
3737 if (PyErr_Occurred()) SWIG_fail;
3738 }
3739 Py_INCREF(Py_None); resultobj = Py_None;
3740 return resultobj;
3741 fail:
3742 return NULL;
3743 }
3744
3745
3746 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3747 PyObject *resultobj;
3748 wxSize *arg1 = (wxSize *) 0 ;
3749 int arg2 ;
3750 PyObject * obj0 = 0 ;
3751 PyObject * obj1 = 0 ;
3752 char *kwnames[] = {
3753 (char *) "self",(char *) "w", NULL
3754 };
3755
3756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3758 if (SWIG_arg_fail(1)) SWIG_fail;
3759 {
3760 arg2 = (int)(SWIG_As_int(obj1));
3761 if (SWIG_arg_fail(2)) SWIG_fail;
3762 }
3763 {
3764 PyThreadState* __tstate = wxPyBeginAllowThreads();
3765 (arg1)->SetWidth(arg2);
3766
3767 wxPyEndAllowThreads(__tstate);
3768 if (PyErr_Occurred()) SWIG_fail;
3769 }
3770 Py_INCREF(Py_None); resultobj = Py_None;
3771 return resultobj;
3772 fail:
3773 return NULL;
3774 }
3775
3776
3777 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3778 PyObject *resultobj;
3779 wxSize *arg1 = (wxSize *) 0 ;
3780 int arg2 ;
3781 PyObject * obj0 = 0 ;
3782 PyObject * obj1 = 0 ;
3783 char *kwnames[] = {
3784 (char *) "self",(char *) "h", NULL
3785 };
3786
3787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3789 if (SWIG_arg_fail(1)) SWIG_fail;
3790 {
3791 arg2 = (int)(SWIG_As_int(obj1));
3792 if (SWIG_arg_fail(2)) SWIG_fail;
3793 }
3794 {
3795 PyThreadState* __tstate = wxPyBeginAllowThreads();
3796 (arg1)->SetHeight(arg2);
3797
3798 wxPyEndAllowThreads(__tstate);
3799 if (PyErr_Occurred()) SWIG_fail;
3800 }
3801 Py_INCREF(Py_None); resultobj = Py_None;
3802 return resultobj;
3803 fail:
3804 return NULL;
3805 }
3806
3807
3808 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3809 PyObject *resultobj;
3810 wxSize *arg1 = (wxSize *) 0 ;
3811 int result;
3812 PyObject * obj0 = 0 ;
3813 char *kwnames[] = {
3814 (char *) "self", NULL
3815 };
3816
3817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3819 if (SWIG_arg_fail(1)) SWIG_fail;
3820 {
3821 PyThreadState* __tstate = wxPyBeginAllowThreads();
3822 result = (int)((wxSize const *)arg1)->GetWidth();
3823
3824 wxPyEndAllowThreads(__tstate);
3825 if (PyErr_Occurred()) SWIG_fail;
3826 }
3827 {
3828 resultobj = SWIG_From_int((int)(result));
3829 }
3830 return resultobj;
3831 fail:
3832 return NULL;
3833 }
3834
3835
3836 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3837 PyObject *resultobj;
3838 wxSize *arg1 = (wxSize *) 0 ;
3839 int result;
3840 PyObject * obj0 = 0 ;
3841 char *kwnames[] = {
3842 (char *) "self", NULL
3843 };
3844
3845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3847 if (SWIG_arg_fail(1)) SWIG_fail;
3848 {
3849 PyThreadState* __tstate = wxPyBeginAllowThreads();
3850 result = (int)((wxSize const *)arg1)->GetHeight();
3851
3852 wxPyEndAllowThreads(__tstate);
3853 if (PyErr_Occurred()) SWIG_fail;
3854 }
3855 {
3856 resultobj = SWIG_From_int((int)(result));
3857 }
3858 return resultobj;
3859 fail:
3860 return NULL;
3861 }
3862
3863
3864 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3865 PyObject *resultobj;
3866 wxSize *arg1 = (wxSize *) 0 ;
3867 bool result;
3868 PyObject * obj0 = 0 ;
3869 char *kwnames[] = {
3870 (char *) "self", NULL
3871 };
3872
3873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3875 if (SWIG_arg_fail(1)) SWIG_fail;
3876 {
3877 PyThreadState* __tstate = wxPyBeginAllowThreads();
3878 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3879
3880 wxPyEndAllowThreads(__tstate);
3881 if (PyErr_Occurred()) SWIG_fail;
3882 }
3883 {
3884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3885 }
3886 return resultobj;
3887 fail:
3888 return NULL;
3889 }
3890
3891
3892 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3893 PyObject *resultobj;
3894 wxSize *arg1 = (wxSize *) 0 ;
3895 wxSize *arg2 = 0 ;
3896 wxSize temp2 ;
3897 PyObject * obj0 = 0 ;
3898 PyObject * obj1 = 0 ;
3899 char *kwnames[] = {
3900 (char *) "self",(char *) "size", NULL
3901 };
3902
3903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3905 if (SWIG_arg_fail(1)) SWIG_fail;
3906 {
3907 arg2 = &temp2;
3908 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3909 }
3910 {
3911 PyThreadState* __tstate = wxPyBeginAllowThreads();
3912 (arg1)->SetDefaults((wxSize const &)*arg2);
3913
3914 wxPyEndAllowThreads(__tstate);
3915 if (PyErr_Occurred()) SWIG_fail;
3916 }
3917 Py_INCREF(Py_None); resultobj = Py_None;
3918 return resultobj;
3919 fail:
3920 return NULL;
3921 }
3922
3923
3924 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3925 PyObject *resultobj;
3926 wxSize *arg1 = (wxSize *) 0 ;
3927 PyObject *result;
3928 PyObject * obj0 = 0 ;
3929 char *kwnames[] = {
3930 (char *) "self", NULL
3931 };
3932
3933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3935 if (SWIG_arg_fail(1)) SWIG_fail;
3936 {
3937 PyThreadState* __tstate = wxPyBeginAllowThreads();
3938 result = (PyObject *)wxSize_Get(arg1);
3939
3940 wxPyEndAllowThreads(__tstate);
3941 if (PyErr_Occurred()) SWIG_fail;
3942 }
3943 resultobj = result;
3944 return resultobj;
3945 fail:
3946 return NULL;
3947 }
3948
3949
3950 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3951 PyObject *obj;
3952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3953 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3954 Py_INCREF(obj);
3955 return Py_BuildValue((char *)"");
3956 }
3957 static PyObject *_wrap_RealPoint_x_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 *) "x", NULL
3965 };
3966
3967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_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)->x = 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_x_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_x_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)->x);
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_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4007 PyObject *resultobj;
4008 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4009 double arg2 ;
4010 PyObject * obj0 = 0 ;
4011 PyObject * obj1 = 0 ;
4012 char *kwnames[] = {
4013 (char *) "self",(char *) "y", NULL
4014 };
4015
4016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4018 if (SWIG_arg_fail(1)) SWIG_fail;
4019 {
4020 arg2 = (double)(SWIG_As_double(obj1));
4021 if (SWIG_arg_fail(2)) SWIG_fail;
4022 }
4023 if (arg1) (arg1)->y = arg2;
4024
4025 Py_INCREF(Py_None); resultobj = Py_None;
4026 return resultobj;
4027 fail:
4028 return NULL;
4029 }
4030
4031
4032 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4033 PyObject *resultobj;
4034 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4035 double result;
4036 PyObject * obj0 = 0 ;
4037 char *kwnames[] = {
4038 (char *) "self", NULL
4039 };
4040
4041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4043 if (SWIG_arg_fail(1)) SWIG_fail;
4044 result = (double) ((arg1)->y);
4045
4046 {
4047 resultobj = SWIG_From_double((double)(result));
4048 }
4049 return resultobj;
4050 fail:
4051 return NULL;
4052 }
4053
4054
4055 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4056 PyObject *resultobj;
4057 double arg1 = (double) 0.0 ;
4058 double arg2 = (double) 0.0 ;
4059 wxRealPoint *result;
4060 PyObject * obj0 = 0 ;
4061 PyObject * obj1 = 0 ;
4062 char *kwnames[] = {
4063 (char *) "x",(char *) "y", NULL
4064 };
4065
4066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4067 if (obj0) {
4068 {
4069 arg1 = (double)(SWIG_As_double(obj0));
4070 if (SWIG_arg_fail(1)) SWIG_fail;
4071 }
4072 }
4073 if (obj1) {
4074 {
4075 arg2 = (double)(SWIG_As_double(obj1));
4076 if (SWIG_arg_fail(2)) SWIG_fail;
4077 }
4078 }
4079 {
4080 PyThreadState* __tstate = wxPyBeginAllowThreads();
4081 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4082
4083 wxPyEndAllowThreads(__tstate);
4084 if (PyErr_Occurred()) SWIG_fail;
4085 }
4086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4087 return resultobj;
4088 fail:
4089 return NULL;
4090 }
4091
4092
4093 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj;
4095 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4096 PyObject * obj0 = 0 ;
4097 char *kwnames[] = {
4098 (char *) "self", NULL
4099 };
4100
4101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4103 if (SWIG_arg_fail(1)) SWIG_fail;
4104 {
4105 PyThreadState* __tstate = wxPyBeginAllowThreads();
4106 delete arg1;
4107
4108 wxPyEndAllowThreads(__tstate);
4109 if (PyErr_Occurred()) SWIG_fail;
4110 }
4111 Py_INCREF(Py_None); resultobj = Py_None;
4112 return resultobj;
4113 fail:
4114 return NULL;
4115 }
4116
4117
4118 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4119 PyObject *resultobj;
4120 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4121 wxRealPoint *arg2 = 0 ;
4122 bool result;
4123 wxRealPoint temp2 ;
4124 PyObject * obj0 = 0 ;
4125 PyObject * obj1 = 0 ;
4126 char *kwnames[] = {
4127 (char *) "self",(char *) "pt", NULL
4128 };
4129
4130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4132 if (SWIG_arg_fail(1)) SWIG_fail;
4133 {
4134 arg2 = &temp2;
4135 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4136 }
4137 {
4138 PyThreadState* __tstate = wxPyBeginAllowThreads();
4139 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4140
4141 wxPyEndAllowThreads(__tstate);
4142 if (PyErr_Occurred()) SWIG_fail;
4143 }
4144 {
4145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4146 }
4147 return resultobj;
4148 fail:
4149 return NULL;
4150 }
4151
4152
4153 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4154 PyObject *resultobj;
4155 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4156 wxRealPoint *arg2 = 0 ;
4157 bool result;
4158 wxRealPoint temp2 ;
4159 PyObject * obj0 = 0 ;
4160 PyObject * obj1 = 0 ;
4161 char *kwnames[] = {
4162 (char *) "self",(char *) "pt", NULL
4163 };
4164
4165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4167 if (SWIG_arg_fail(1)) SWIG_fail;
4168 {
4169 arg2 = &temp2;
4170 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4171 }
4172 {
4173 PyThreadState* __tstate = wxPyBeginAllowThreads();
4174 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4175
4176 wxPyEndAllowThreads(__tstate);
4177 if (PyErr_Occurred()) SWIG_fail;
4178 }
4179 {
4180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4181 }
4182 return resultobj;
4183 fail:
4184 return NULL;
4185 }
4186
4187
4188 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4189 PyObject *resultobj;
4190 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4191 wxRealPoint *arg2 = 0 ;
4192 wxRealPoint result;
4193 wxRealPoint temp2 ;
4194 PyObject * obj0 = 0 ;
4195 PyObject * obj1 = 0 ;
4196 char *kwnames[] = {
4197 (char *) "self",(char *) "pt", NULL
4198 };
4199
4200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4202 if (SWIG_arg_fail(1)) SWIG_fail;
4203 {
4204 arg2 = &temp2;
4205 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4206 }
4207 {
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4210
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 {
4215 wxRealPoint * resultptr;
4216 resultptr = new wxRealPoint((wxRealPoint &)(result));
4217 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4218 }
4219 return resultobj;
4220 fail:
4221 return NULL;
4222 }
4223
4224
4225 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4226 PyObject *resultobj;
4227 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4228 wxRealPoint *arg2 = 0 ;
4229 wxRealPoint result;
4230 wxRealPoint temp2 ;
4231 PyObject * obj0 = 0 ;
4232 PyObject * obj1 = 0 ;
4233 char *kwnames[] = {
4234 (char *) "self",(char *) "pt", NULL
4235 };
4236
4237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4239 if (SWIG_arg_fail(1)) SWIG_fail;
4240 {
4241 arg2 = &temp2;
4242 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4243 }
4244 {
4245 PyThreadState* __tstate = wxPyBeginAllowThreads();
4246 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4247
4248 wxPyEndAllowThreads(__tstate);
4249 if (PyErr_Occurred()) SWIG_fail;
4250 }
4251 {
4252 wxRealPoint * resultptr;
4253 resultptr = new wxRealPoint((wxRealPoint &)(result));
4254 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4255 }
4256 return resultobj;
4257 fail:
4258 return NULL;
4259 }
4260
4261
4262 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4263 PyObject *resultobj;
4264 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4265 double arg2 ;
4266 double arg3 ;
4267 PyObject * obj0 = 0 ;
4268 PyObject * obj1 = 0 ;
4269 PyObject * obj2 = 0 ;
4270 char *kwnames[] = {
4271 (char *) "self",(char *) "x",(char *) "y", NULL
4272 };
4273
4274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4276 if (SWIG_arg_fail(1)) SWIG_fail;
4277 {
4278 arg2 = (double)(SWIG_As_double(obj1));
4279 if (SWIG_arg_fail(2)) SWIG_fail;
4280 }
4281 {
4282 arg3 = (double)(SWIG_As_double(obj2));
4283 if (SWIG_arg_fail(3)) SWIG_fail;
4284 }
4285 {
4286 PyThreadState* __tstate = wxPyBeginAllowThreads();
4287 wxRealPoint_Set(arg1,arg2,arg3);
4288
4289 wxPyEndAllowThreads(__tstate);
4290 if (PyErr_Occurred()) SWIG_fail;
4291 }
4292 Py_INCREF(Py_None); resultobj = Py_None;
4293 return resultobj;
4294 fail:
4295 return NULL;
4296 }
4297
4298
4299 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4300 PyObject *resultobj;
4301 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4302 PyObject *result;
4303 PyObject * obj0 = 0 ;
4304 char *kwnames[] = {
4305 (char *) "self", NULL
4306 };
4307
4308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4310 if (SWIG_arg_fail(1)) SWIG_fail;
4311 {
4312 PyThreadState* __tstate = wxPyBeginAllowThreads();
4313 result = (PyObject *)wxRealPoint_Get(arg1);
4314
4315 wxPyEndAllowThreads(__tstate);
4316 if (PyErr_Occurred()) SWIG_fail;
4317 }
4318 resultobj = result;
4319 return resultobj;
4320 fail:
4321 return NULL;
4322 }
4323
4324
4325 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4326 PyObject *obj;
4327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4328 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4329 Py_INCREF(obj);
4330 return Py_BuildValue((char *)"");
4331 }
4332 static PyObject *_wrap_Point_x_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 *) "x", NULL
4340 };
4341
4342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_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)->x = 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_x_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_x_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)->x);
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_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4382 PyObject *resultobj;
4383 wxPoint *arg1 = (wxPoint *) 0 ;
4384 int arg2 ;
4385 PyObject * obj0 = 0 ;
4386 PyObject * obj1 = 0 ;
4387 char *kwnames[] = {
4388 (char *) "self",(char *) "y", NULL
4389 };
4390
4391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4393 if (SWIG_arg_fail(1)) SWIG_fail;
4394 {
4395 arg2 = (int)(SWIG_As_int(obj1));
4396 if (SWIG_arg_fail(2)) SWIG_fail;
4397 }
4398 if (arg1) (arg1)->y = arg2;
4399
4400 Py_INCREF(Py_None); resultobj = Py_None;
4401 return resultobj;
4402 fail:
4403 return NULL;
4404 }
4405
4406
4407 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4408 PyObject *resultobj;
4409 wxPoint *arg1 = (wxPoint *) 0 ;
4410 int result;
4411 PyObject * obj0 = 0 ;
4412 char *kwnames[] = {
4413 (char *) "self", NULL
4414 };
4415
4416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4418 if (SWIG_arg_fail(1)) SWIG_fail;
4419 result = (int) ((arg1)->y);
4420
4421 {
4422 resultobj = SWIG_From_int((int)(result));
4423 }
4424 return resultobj;
4425 fail:
4426 return NULL;
4427 }
4428
4429
4430 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4431 PyObject *resultobj;
4432 int arg1 = (int) 0 ;
4433 int arg2 = (int) 0 ;
4434 wxPoint *result;
4435 PyObject * obj0 = 0 ;
4436 PyObject * obj1 = 0 ;
4437 char *kwnames[] = {
4438 (char *) "x",(char *) "y", NULL
4439 };
4440
4441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4442 if (obj0) {
4443 {
4444 arg1 = (int)(SWIG_As_int(obj0));
4445 if (SWIG_arg_fail(1)) SWIG_fail;
4446 }
4447 }
4448 if (obj1) {
4449 {
4450 arg2 = (int)(SWIG_As_int(obj1));
4451 if (SWIG_arg_fail(2)) SWIG_fail;
4452 }
4453 }
4454 {
4455 PyThreadState* __tstate = wxPyBeginAllowThreads();
4456 result = (wxPoint *)new wxPoint(arg1,arg2);
4457
4458 wxPyEndAllowThreads(__tstate);
4459 if (PyErr_Occurred()) SWIG_fail;
4460 }
4461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4462 return resultobj;
4463 fail:
4464 return NULL;
4465 }
4466
4467
4468 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4469 PyObject *resultobj;
4470 wxPoint *arg1 = (wxPoint *) 0 ;
4471 PyObject * obj0 = 0 ;
4472 char *kwnames[] = {
4473 (char *) "self", NULL
4474 };
4475
4476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4478 if (SWIG_arg_fail(1)) SWIG_fail;
4479 {
4480 PyThreadState* __tstate = wxPyBeginAllowThreads();
4481 delete arg1;
4482
4483 wxPyEndAllowThreads(__tstate);
4484 if (PyErr_Occurred()) SWIG_fail;
4485 }
4486 Py_INCREF(Py_None); resultobj = Py_None;
4487 return resultobj;
4488 fail:
4489 return NULL;
4490 }
4491
4492
4493 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4494 PyObject *resultobj;
4495 wxPoint *arg1 = (wxPoint *) 0 ;
4496 wxPoint *arg2 = 0 ;
4497 bool result;
4498 wxPoint temp2 ;
4499 PyObject * obj0 = 0 ;
4500 PyObject * obj1 = 0 ;
4501 char *kwnames[] = {
4502 (char *) "self",(char *) "pt", NULL
4503 };
4504
4505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4507 if (SWIG_arg_fail(1)) SWIG_fail;
4508 {
4509 arg2 = &temp2;
4510 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4511 }
4512 {
4513 PyThreadState* __tstate = wxPyBeginAllowThreads();
4514 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4515
4516 wxPyEndAllowThreads(__tstate);
4517 if (PyErr_Occurred()) SWIG_fail;
4518 }
4519 {
4520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4521 }
4522 return resultobj;
4523 fail:
4524 return NULL;
4525 }
4526
4527
4528 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4529 PyObject *resultobj;
4530 wxPoint *arg1 = (wxPoint *) 0 ;
4531 wxPoint *arg2 = 0 ;
4532 bool result;
4533 wxPoint temp2 ;
4534 PyObject * obj0 = 0 ;
4535 PyObject * obj1 = 0 ;
4536 char *kwnames[] = {
4537 (char *) "self",(char *) "pt", NULL
4538 };
4539
4540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4542 if (SWIG_arg_fail(1)) SWIG_fail;
4543 {
4544 arg2 = &temp2;
4545 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4546 }
4547 {
4548 PyThreadState* __tstate = wxPyBeginAllowThreads();
4549 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4550
4551 wxPyEndAllowThreads(__tstate);
4552 if (PyErr_Occurred()) SWIG_fail;
4553 }
4554 {
4555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4556 }
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4564 PyObject *resultobj;
4565 wxPoint *arg1 = (wxPoint *) 0 ;
4566 wxPoint *arg2 = 0 ;
4567 wxPoint result;
4568 wxPoint temp2 ;
4569 PyObject * obj0 = 0 ;
4570 PyObject * obj1 = 0 ;
4571 char *kwnames[] = {
4572 (char *) "self",(char *) "pt", NULL
4573 };
4574
4575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4577 if (SWIG_arg_fail(1)) SWIG_fail;
4578 {
4579 arg2 = &temp2;
4580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4581 }
4582 {
4583 PyThreadState* __tstate = wxPyBeginAllowThreads();
4584 result = (arg1)->operator +((wxPoint const &)*arg2);
4585
4586 wxPyEndAllowThreads(__tstate);
4587 if (PyErr_Occurred()) SWIG_fail;
4588 }
4589 {
4590 wxPoint * resultptr;
4591 resultptr = new wxPoint((wxPoint &)(result));
4592 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4593 }
4594 return resultobj;
4595 fail:
4596 return NULL;
4597 }
4598
4599
4600 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4601 PyObject *resultobj;
4602 wxPoint *arg1 = (wxPoint *) 0 ;
4603 wxPoint *arg2 = 0 ;
4604 wxPoint result;
4605 wxPoint temp2 ;
4606 PyObject * obj0 = 0 ;
4607 PyObject * obj1 = 0 ;
4608 char *kwnames[] = {
4609 (char *) "self",(char *) "pt", NULL
4610 };
4611
4612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4614 if (SWIG_arg_fail(1)) SWIG_fail;
4615 {
4616 arg2 = &temp2;
4617 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4618 }
4619 {
4620 PyThreadState* __tstate = wxPyBeginAllowThreads();
4621 result = (arg1)->operator -((wxPoint const &)*arg2);
4622
4623 wxPyEndAllowThreads(__tstate);
4624 if (PyErr_Occurred()) SWIG_fail;
4625 }
4626 {
4627 wxPoint * resultptr;
4628 resultptr = new wxPoint((wxPoint &)(result));
4629 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4630 }
4631 return resultobj;
4632 fail:
4633 return NULL;
4634 }
4635
4636
4637 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4638 PyObject *resultobj;
4639 wxPoint *arg1 = (wxPoint *) 0 ;
4640 wxPoint *arg2 = 0 ;
4641 wxPoint *result;
4642 wxPoint temp2 ;
4643 PyObject * obj0 = 0 ;
4644 PyObject * obj1 = 0 ;
4645 char *kwnames[] = {
4646 (char *) "self",(char *) "pt", NULL
4647 };
4648
4649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4651 if (SWIG_arg_fail(1)) SWIG_fail;
4652 {
4653 arg2 = &temp2;
4654 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4655 }
4656 {
4657 PyThreadState* __tstate = wxPyBeginAllowThreads();
4658 {
4659 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4660 result = (wxPoint *) &_result_ref;
4661 }
4662
4663 wxPyEndAllowThreads(__tstate);
4664 if (PyErr_Occurred()) SWIG_fail;
4665 }
4666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4667 return resultobj;
4668 fail:
4669 return NULL;
4670 }
4671
4672
4673 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4674 PyObject *resultobj;
4675 wxPoint *arg1 = (wxPoint *) 0 ;
4676 wxPoint *arg2 = 0 ;
4677 wxPoint *result;
4678 wxPoint temp2 ;
4679 PyObject * obj0 = 0 ;
4680 PyObject * obj1 = 0 ;
4681 char *kwnames[] = {
4682 (char *) "self",(char *) "pt", NULL
4683 };
4684
4685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4687 if (SWIG_arg_fail(1)) SWIG_fail;
4688 {
4689 arg2 = &temp2;
4690 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4691 }
4692 {
4693 PyThreadState* __tstate = wxPyBeginAllowThreads();
4694 {
4695 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4696 result = (wxPoint *) &_result_ref;
4697 }
4698
4699 wxPyEndAllowThreads(__tstate);
4700 if (PyErr_Occurred()) SWIG_fail;
4701 }
4702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
4709 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4710 PyObject *resultobj;
4711 wxPoint *arg1 = (wxPoint *) 0 ;
4712 long arg2 ;
4713 long arg3 ;
4714 PyObject * obj0 = 0 ;
4715 PyObject * obj1 = 0 ;
4716 PyObject * obj2 = 0 ;
4717 char *kwnames[] = {
4718 (char *) "self",(char *) "x",(char *) "y", NULL
4719 };
4720
4721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4723 if (SWIG_arg_fail(1)) SWIG_fail;
4724 {
4725 arg2 = (long)(SWIG_As_long(obj1));
4726 if (SWIG_arg_fail(2)) SWIG_fail;
4727 }
4728 {
4729 arg3 = (long)(SWIG_As_long(obj2));
4730 if (SWIG_arg_fail(3)) SWIG_fail;
4731 }
4732 {
4733 PyThreadState* __tstate = wxPyBeginAllowThreads();
4734 wxPoint_Set(arg1,arg2,arg3);
4735
4736 wxPyEndAllowThreads(__tstate);
4737 if (PyErr_Occurred()) SWIG_fail;
4738 }
4739 Py_INCREF(Py_None); resultobj = Py_None;
4740 return resultobj;
4741 fail:
4742 return NULL;
4743 }
4744
4745
4746 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4747 PyObject *resultobj;
4748 wxPoint *arg1 = (wxPoint *) 0 ;
4749 PyObject *result;
4750 PyObject * obj0 = 0 ;
4751 char *kwnames[] = {
4752 (char *) "self", NULL
4753 };
4754
4755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4757 if (SWIG_arg_fail(1)) SWIG_fail;
4758 {
4759 PyThreadState* __tstate = wxPyBeginAllowThreads();
4760 result = (PyObject *)wxPoint_Get(arg1);
4761
4762 wxPyEndAllowThreads(__tstate);
4763 if (PyErr_Occurred()) SWIG_fail;
4764 }
4765 resultobj = result;
4766 return resultobj;
4767 fail:
4768 return NULL;
4769 }
4770
4771
4772 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4773 PyObject *obj;
4774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4775 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4776 Py_INCREF(obj);
4777 return Py_BuildValue((char *)"");
4778 }
4779 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4780 PyObject *resultobj;
4781 int arg1 = (int) 0 ;
4782 int arg2 = (int) 0 ;
4783 int arg3 = (int) 0 ;
4784 int arg4 = (int) 0 ;
4785 wxRect *result;
4786 PyObject * obj0 = 0 ;
4787 PyObject * obj1 = 0 ;
4788 PyObject * obj2 = 0 ;
4789 PyObject * obj3 = 0 ;
4790 char *kwnames[] = {
4791 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4792 };
4793
4794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4795 if (obj0) {
4796 {
4797 arg1 = (int)(SWIG_As_int(obj0));
4798 if (SWIG_arg_fail(1)) SWIG_fail;
4799 }
4800 }
4801 if (obj1) {
4802 {
4803 arg2 = (int)(SWIG_As_int(obj1));
4804 if (SWIG_arg_fail(2)) SWIG_fail;
4805 }
4806 }
4807 if (obj2) {
4808 {
4809 arg3 = (int)(SWIG_As_int(obj2));
4810 if (SWIG_arg_fail(3)) SWIG_fail;
4811 }
4812 }
4813 if (obj3) {
4814 {
4815 arg4 = (int)(SWIG_As_int(obj3));
4816 if (SWIG_arg_fail(4)) SWIG_fail;
4817 }
4818 }
4819 {
4820 PyThreadState* __tstate = wxPyBeginAllowThreads();
4821 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4822
4823 wxPyEndAllowThreads(__tstate);
4824 if (PyErr_Occurred()) SWIG_fail;
4825 }
4826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4827 return resultobj;
4828 fail:
4829 return NULL;
4830 }
4831
4832
4833 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4834 PyObject *resultobj;
4835 wxPoint *arg1 = 0 ;
4836 wxPoint *arg2 = 0 ;
4837 wxRect *result;
4838 wxPoint temp1 ;
4839 wxPoint temp2 ;
4840 PyObject * obj0 = 0 ;
4841 PyObject * obj1 = 0 ;
4842 char *kwnames[] = {
4843 (char *) "topLeft",(char *) "bottomRight", NULL
4844 };
4845
4846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4847 {
4848 arg1 = &temp1;
4849 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4850 }
4851 {
4852 arg2 = &temp2;
4853 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4854 }
4855 {
4856 PyThreadState* __tstate = wxPyBeginAllowThreads();
4857 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4858
4859 wxPyEndAllowThreads(__tstate);
4860 if (PyErr_Occurred()) SWIG_fail;
4861 }
4862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4863 return resultobj;
4864 fail:
4865 return NULL;
4866 }
4867
4868
4869 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4870 PyObject *resultobj;
4871 wxPoint *arg1 = 0 ;
4872 wxSize *arg2 = 0 ;
4873 wxRect *result;
4874 wxPoint temp1 ;
4875 wxSize temp2 ;
4876 PyObject * obj0 = 0 ;
4877 PyObject * obj1 = 0 ;
4878 char *kwnames[] = {
4879 (char *) "pos",(char *) "size", NULL
4880 };
4881
4882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4883 {
4884 arg1 = &temp1;
4885 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4886 }
4887 {
4888 arg2 = &temp2;
4889 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4890 }
4891 {
4892 PyThreadState* __tstate = wxPyBeginAllowThreads();
4893 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4894
4895 wxPyEndAllowThreads(__tstate);
4896 if (PyErr_Occurred()) SWIG_fail;
4897 }
4898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4899 return resultobj;
4900 fail:
4901 return NULL;
4902 }
4903
4904
4905 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4906 PyObject *resultobj;
4907 wxSize *arg1 = 0 ;
4908 wxRect *result;
4909 wxSize temp1 ;
4910 PyObject * obj0 = 0 ;
4911 char *kwnames[] = {
4912 (char *) "size", NULL
4913 };
4914
4915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4916 {
4917 arg1 = &temp1;
4918 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4919 }
4920 {
4921 PyThreadState* __tstate = wxPyBeginAllowThreads();
4922 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4923
4924 wxPyEndAllowThreads(__tstate);
4925 if (PyErr_Occurred()) SWIG_fail;
4926 }
4927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4928 return resultobj;
4929 fail:
4930 return NULL;
4931 }
4932
4933
4934 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4935 PyObject *resultobj;
4936 wxRect *arg1 = (wxRect *) 0 ;
4937 PyObject * obj0 = 0 ;
4938 char *kwnames[] = {
4939 (char *) "self", NULL
4940 };
4941
4942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4944 if (SWIG_arg_fail(1)) SWIG_fail;
4945 {
4946 PyThreadState* __tstate = wxPyBeginAllowThreads();
4947 delete arg1;
4948
4949 wxPyEndAllowThreads(__tstate);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 Py_INCREF(Py_None); resultobj = Py_None;
4953 return resultobj;
4954 fail:
4955 return NULL;
4956 }
4957
4958
4959 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4960 PyObject *resultobj;
4961 wxRect *arg1 = (wxRect *) 0 ;
4962 int result;
4963 PyObject * obj0 = 0 ;
4964 char *kwnames[] = {
4965 (char *) "self", NULL
4966 };
4967
4968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4970 if (SWIG_arg_fail(1)) SWIG_fail;
4971 {
4972 PyThreadState* __tstate = wxPyBeginAllowThreads();
4973 result = (int)((wxRect const *)arg1)->GetX();
4974
4975 wxPyEndAllowThreads(__tstate);
4976 if (PyErr_Occurred()) SWIG_fail;
4977 }
4978 {
4979 resultobj = SWIG_From_int((int)(result));
4980 }
4981 return resultobj;
4982 fail:
4983 return NULL;
4984 }
4985
4986
4987 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4988 PyObject *resultobj;
4989 wxRect *arg1 = (wxRect *) 0 ;
4990 int arg2 ;
4991 PyObject * obj0 = 0 ;
4992 PyObject * obj1 = 0 ;
4993 char *kwnames[] = {
4994 (char *) "self",(char *) "x", NULL
4995 };
4996
4997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4999 if (SWIG_arg_fail(1)) SWIG_fail;
5000 {
5001 arg2 = (int)(SWIG_As_int(obj1));
5002 if (SWIG_arg_fail(2)) SWIG_fail;
5003 }
5004 {
5005 PyThreadState* __tstate = wxPyBeginAllowThreads();
5006 (arg1)->SetX(arg2);
5007
5008 wxPyEndAllowThreads(__tstate);
5009 if (PyErr_Occurred()) SWIG_fail;
5010 }
5011 Py_INCREF(Py_None); resultobj = Py_None;
5012 return resultobj;
5013 fail:
5014 return NULL;
5015 }
5016
5017
5018 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5019 PyObject *resultobj;
5020 wxRect *arg1 = (wxRect *) 0 ;
5021 int result;
5022 PyObject * obj0 = 0 ;
5023 char *kwnames[] = {
5024 (char *) "self", NULL
5025 };
5026
5027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5029 if (SWIG_arg_fail(1)) SWIG_fail;
5030 {
5031 PyThreadState* __tstate = wxPyBeginAllowThreads();
5032 result = (int)(arg1)->GetY();
5033
5034 wxPyEndAllowThreads(__tstate);
5035 if (PyErr_Occurred()) SWIG_fail;
5036 }
5037 {
5038 resultobj = SWIG_From_int((int)(result));
5039 }
5040 return resultobj;
5041 fail:
5042 return NULL;
5043 }
5044
5045
5046 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5047 PyObject *resultobj;
5048 wxRect *arg1 = (wxRect *) 0 ;
5049 int arg2 ;
5050 PyObject * obj0 = 0 ;
5051 PyObject * obj1 = 0 ;
5052 char *kwnames[] = {
5053 (char *) "self",(char *) "y", NULL
5054 };
5055
5056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5058 if (SWIG_arg_fail(1)) SWIG_fail;
5059 {
5060 arg2 = (int)(SWIG_As_int(obj1));
5061 if (SWIG_arg_fail(2)) SWIG_fail;
5062 }
5063 {
5064 PyThreadState* __tstate = wxPyBeginAllowThreads();
5065 (arg1)->SetY(arg2);
5066
5067 wxPyEndAllowThreads(__tstate);
5068 if (PyErr_Occurred()) SWIG_fail;
5069 }
5070 Py_INCREF(Py_None); resultobj = Py_None;
5071 return resultobj;
5072 fail:
5073 return NULL;
5074 }
5075
5076
5077 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5078 PyObject *resultobj;
5079 wxRect *arg1 = (wxRect *) 0 ;
5080 int result;
5081 PyObject * obj0 = 0 ;
5082 char *kwnames[] = {
5083 (char *) "self", NULL
5084 };
5085
5086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5088 if (SWIG_arg_fail(1)) SWIG_fail;
5089 {
5090 PyThreadState* __tstate = wxPyBeginAllowThreads();
5091 result = (int)((wxRect const *)arg1)->GetWidth();
5092
5093 wxPyEndAllowThreads(__tstate);
5094 if (PyErr_Occurred()) SWIG_fail;
5095 }
5096 {
5097 resultobj = SWIG_From_int((int)(result));
5098 }
5099 return resultobj;
5100 fail:
5101 return NULL;
5102 }
5103
5104
5105 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5106 PyObject *resultobj;
5107 wxRect *arg1 = (wxRect *) 0 ;
5108 int arg2 ;
5109 PyObject * obj0 = 0 ;
5110 PyObject * obj1 = 0 ;
5111 char *kwnames[] = {
5112 (char *) "self",(char *) "w", NULL
5113 };
5114
5115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5117 if (SWIG_arg_fail(1)) SWIG_fail;
5118 {
5119 arg2 = (int)(SWIG_As_int(obj1));
5120 if (SWIG_arg_fail(2)) SWIG_fail;
5121 }
5122 {
5123 PyThreadState* __tstate = wxPyBeginAllowThreads();
5124 (arg1)->SetWidth(arg2);
5125
5126 wxPyEndAllowThreads(__tstate);
5127 if (PyErr_Occurred()) SWIG_fail;
5128 }
5129 Py_INCREF(Py_None); resultobj = Py_None;
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5137 PyObject *resultobj;
5138 wxRect *arg1 = (wxRect *) 0 ;
5139 int result;
5140 PyObject * obj0 = 0 ;
5141 char *kwnames[] = {
5142 (char *) "self", NULL
5143 };
5144
5145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5147 if (SWIG_arg_fail(1)) SWIG_fail;
5148 {
5149 PyThreadState* __tstate = wxPyBeginAllowThreads();
5150 result = (int)((wxRect const *)arg1)->GetHeight();
5151
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 {
5156 resultobj = SWIG_From_int((int)(result));
5157 }
5158 return resultobj;
5159 fail:
5160 return NULL;
5161 }
5162
5163
5164 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5165 PyObject *resultobj;
5166 wxRect *arg1 = (wxRect *) 0 ;
5167 int arg2 ;
5168 PyObject * obj0 = 0 ;
5169 PyObject * obj1 = 0 ;
5170 char *kwnames[] = {
5171 (char *) "self",(char *) "h", NULL
5172 };
5173
5174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5176 if (SWIG_arg_fail(1)) SWIG_fail;
5177 {
5178 arg2 = (int)(SWIG_As_int(obj1));
5179 if (SWIG_arg_fail(2)) SWIG_fail;
5180 }
5181 {
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 (arg1)->SetHeight(arg2);
5184
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 Py_INCREF(Py_None); resultobj = Py_None;
5189 return resultobj;
5190 fail:
5191 return NULL;
5192 }
5193
5194
5195 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5196 PyObject *resultobj;
5197 wxRect *arg1 = (wxRect *) 0 ;
5198 wxPoint result;
5199 PyObject * obj0 = 0 ;
5200 char *kwnames[] = {
5201 (char *) "self", NULL
5202 };
5203
5204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5206 if (SWIG_arg_fail(1)) SWIG_fail;
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 result = ((wxRect const *)arg1)->GetPosition();
5210
5211 wxPyEndAllowThreads(__tstate);
5212 if (PyErr_Occurred()) SWIG_fail;
5213 }
5214 {
5215 wxPoint * resultptr;
5216 resultptr = new wxPoint((wxPoint &)(result));
5217 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5218 }
5219 return resultobj;
5220 fail:
5221 return NULL;
5222 }
5223
5224
5225 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5226 PyObject *resultobj;
5227 wxRect *arg1 = (wxRect *) 0 ;
5228 wxPoint *arg2 = 0 ;
5229 wxPoint temp2 ;
5230 PyObject * obj0 = 0 ;
5231 PyObject * obj1 = 0 ;
5232 char *kwnames[] = {
5233 (char *) "self",(char *) "p", NULL
5234 };
5235
5236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5238 if (SWIG_arg_fail(1)) SWIG_fail;
5239 {
5240 arg2 = &temp2;
5241 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5242 }
5243 {
5244 PyThreadState* __tstate = wxPyBeginAllowThreads();
5245 (arg1)->SetPosition((wxPoint const &)*arg2);
5246
5247 wxPyEndAllowThreads(__tstate);
5248 if (PyErr_Occurred()) SWIG_fail;
5249 }
5250 Py_INCREF(Py_None); resultobj = Py_None;
5251 return resultobj;
5252 fail:
5253 return NULL;
5254 }
5255
5256
5257 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5258 PyObject *resultobj;
5259 wxRect *arg1 = (wxRect *) 0 ;
5260 wxSize result;
5261 PyObject * obj0 = 0 ;
5262 char *kwnames[] = {
5263 (char *) "self", NULL
5264 };
5265
5266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5268 if (SWIG_arg_fail(1)) SWIG_fail;
5269 {
5270 PyThreadState* __tstate = wxPyBeginAllowThreads();
5271 result = ((wxRect const *)arg1)->GetSize();
5272
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 {
5277 wxSize * resultptr;
5278 resultptr = new wxSize((wxSize &)(result));
5279 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5280 }
5281 return resultobj;
5282 fail:
5283 return NULL;
5284 }
5285
5286
5287 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5288 PyObject *resultobj;
5289 wxRect *arg1 = (wxRect *) 0 ;
5290 wxSize *arg2 = 0 ;
5291 wxSize temp2 ;
5292 PyObject * obj0 = 0 ;
5293 PyObject * obj1 = 0 ;
5294 char *kwnames[] = {
5295 (char *) "self",(char *) "s", NULL
5296 };
5297
5298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5300 if (SWIG_arg_fail(1)) SWIG_fail;
5301 {
5302 arg2 = &temp2;
5303 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5304 }
5305 {
5306 PyThreadState* __tstate = wxPyBeginAllowThreads();
5307 (arg1)->SetSize((wxSize const &)*arg2);
5308
5309 wxPyEndAllowThreads(__tstate);
5310 if (PyErr_Occurred()) SWIG_fail;
5311 }
5312 Py_INCREF(Py_None); resultobj = Py_None;
5313 return resultobj;
5314 fail:
5315 return NULL;
5316 }
5317
5318
5319 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5320 PyObject *resultobj;
5321 wxRect *arg1 = (wxRect *) 0 ;
5322 bool result;
5323 PyObject * obj0 = 0 ;
5324 char *kwnames[] = {
5325 (char *) "self", NULL
5326 };
5327
5328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5330 if (SWIG_arg_fail(1)) SWIG_fail;
5331 {
5332 PyThreadState* __tstate = wxPyBeginAllowThreads();
5333 result = (bool)((wxRect const *)arg1)->IsEmpty();
5334
5335 wxPyEndAllowThreads(__tstate);
5336 if (PyErr_Occurred()) SWIG_fail;
5337 }
5338 {
5339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5340 }
5341 return resultobj;
5342 fail:
5343 return NULL;
5344 }
5345
5346
5347 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5348 PyObject *resultobj;
5349 wxRect *arg1 = (wxRect *) 0 ;
5350 wxPoint result;
5351 PyObject * obj0 = 0 ;
5352 char *kwnames[] = {
5353 (char *) "self", NULL
5354 };
5355
5356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5358 if (SWIG_arg_fail(1)) SWIG_fail;
5359 {
5360 PyThreadState* __tstate = wxPyBeginAllowThreads();
5361 result = ((wxRect const *)arg1)->GetTopLeft();
5362
5363 wxPyEndAllowThreads(__tstate);
5364 if (PyErr_Occurred()) SWIG_fail;
5365 }
5366 {
5367 wxPoint * resultptr;
5368 resultptr = new wxPoint((wxPoint &)(result));
5369 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5370 }
5371 return resultobj;
5372 fail:
5373 return NULL;
5374 }
5375
5376
5377 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5378 PyObject *resultobj;
5379 wxRect *arg1 = (wxRect *) 0 ;
5380 wxPoint *arg2 = 0 ;
5381 wxPoint temp2 ;
5382 PyObject * obj0 = 0 ;
5383 PyObject * obj1 = 0 ;
5384 char *kwnames[] = {
5385 (char *) "self",(char *) "p", NULL
5386 };
5387
5388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5390 if (SWIG_arg_fail(1)) SWIG_fail;
5391 {
5392 arg2 = &temp2;
5393 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5394 }
5395 {
5396 PyThreadState* __tstate = wxPyBeginAllowThreads();
5397 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5398
5399 wxPyEndAllowThreads(__tstate);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 Py_INCREF(Py_None); resultobj = Py_None;
5403 return resultobj;
5404 fail:
5405 return NULL;
5406 }
5407
5408
5409 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5410 PyObject *resultobj;
5411 wxRect *arg1 = (wxRect *) 0 ;
5412 wxPoint result;
5413 PyObject * obj0 = 0 ;
5414 char *kwnames[] = {
5415 (char *) "self", NULL
5416 };
5417
5418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5420 if (SWIG_arg_fail(1)) SWIG_fail;
5421 {
5422 PyThreadState* __tstate = wxPyBeginAllowThreads();
5423 result = ((wxRect const *)arg1)->GetBottomRight();
5424
5425 wxPyEndAllowThreads(__tstate);
5426 if (PyErr_Occurred()) SWIG_fail;
5427 }
5428 {
5429 wxPoint * resultptr;
5430 resultptr = new wxPoint((wxPoint &)(result));
5431 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5432 }
5433 return resultobj;
5434 fail:
5435 return NULL;
5436 }
5437
5438
5439 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5440 PyObject *resultobj;
5441 wxRect *arg1 = (wxRect *) 0 ;
5442 wxPoint *arg2 = 0 ;
5443 wxPoint temp2 ;
5444 PyObject * obj0 = 0 ;
5445 PyObject * obj1 = 0 ;
5446 char *kwnames[] = {
5447 (char *) "self",(char *) "p", NULL
5448 };
5449
5450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5452 if (SWIG_arg_fail(1)) SWIG_fail;
5453 {
5454 arg2 = &temp2;
5455 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5456 }
5457 {
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5460
5461 wxPyEndAllowThreads(__tstate);
5462 if (PyErr_Occurred()) SWIG_fail;
5463 }
5464 Py_INCREF(Py_None); resultobj = Py_None;
5465 return resultobj;
5466 fail:
5467 return NULL;
5468 }
5469
5470
5471 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5472 PyObject *resultobj;
5473 wxRect *arg1 = (wxRect *) 0 ;
5474 int result;
5475 PyObject * obj0 = 0 ;
5476 char *kwnames[] = {
5477 (char *) "self", NULL
5478 };
5479
5480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5482 if (SWIG_arg_fail(1)) SWIG_fail;
5483 {
5484 PyThreadState* __tstate = wxPyBeginAllowThreads();
5485 result = (int)((wxRect const *)arg1)->GetLeft();
5486
5487 wxPyEndAllowThreads(__tstate);
5488 if (PyErr_Occurred()) SWIG_fail;
5489 }
5490 {
5491 resultobj = SWIG_From_int((int)(result));
5492 }
5493 return resultobj;
5494 fail:
5495 return NULL;
5496 }
5497
5498
5499 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5500 PyObject *resultobj;
5501 wxRect *arg1 = (wxRect *) 0 ;
5502 int result;
5503 PyObject * obj0 = 0 ;
5504 char *kwnames[] = {
5505 (char *) "self", NULL
5506 };
5507
5508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5510 if (SWIG_arg_fail(1)) SWIG_fail;
5511 {
5512 PyThreadState* __tstate = wxPyBeginAllowThreads();
5513 result = (int)((wxRect const *)arg1)->GetTop();
5514
5515 wxPyEndAllowThreads(__tstate);
5516 if (PyErr_Occurred()) SWIG_fail;
5517 }
5518 {
5519 resultobj = SWIG_From_int((int)(result));
5520 }
5521 return resultobj;
5522 fail:
5523 return NULL;
5524 }
5525
5526
5527 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5528 PyObject *resultobj;
5529 wxRect *arg1 = (wxRect *) 0 ;
5530 int result;
5531 PyObject * obj0 = 0 ;
5532 char *kwnames[] = {
5533 (char *) "self", NULL
5534 };
5535
5536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5538 if (SWIG_arg_fail(1)) SWIG_fail;
5539 {
5540 PyThreadState* __tstate = wxPyBeginAllowThreads();
5541 result = (int)((wxRect const *)arg1)->GetBottom();
5542
5543 wxPyEndAllowThreads(__tstate);
5544 if (PyErr_Occurred()) SWIG_fail;
5545 }
5546 {
5547 resultobj = SWIG_From_int((int)(result));
5548 }
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5556 PyObject *resultobj;
5557 wxRect *arg1 = (wxRect *) 0 ;
5558 int result;
5559 PyObject * obj0 = 0 ;
5560 char *kwnames[] = {
5561 (char *) "self", NULL
5562 };
5563
5564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5566 if (SWIG_arg_fail(1)) SWIG_fail;
5567 {
5568 PyThreadState* __tstate = wxPyBeginAllowThreads();
5569 result = (int)((wxRect const *)arg1)->GetRight();
5570
5571 wxPyEndAllowThreads(__tstate);
5572 if (PyErr_Occurred()) SWIG_fail;
5573 }
5574 {
5575 resultobj = SWIG_From_int((int)(result));
5576 }
5577 return resultobj;
5578 fail:
5579 return NULL;
5580 }
5581
5582
5583 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5584 PyObject *resultobj;
5585 wxRect *arg1 = (wxRect *) 0 ;
5586 int arg2 ;
5587 PyObject * obj0 = 0 ;
5588 PyObject * obj1 = 0 ;
5589 char *kwnames[] = {
5590 (char *) "self",(char *) "left", NULL
5591 };
5592
5593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5595 if (SWIG_arg_fail(1)) SWIG_fail;
5596 {
5597 arg2 = (int)(SWIG_As_int(obj1));
5598 if (SWIG_arg_fail(2)) SWIG_fail;
5599 }
5600 {
5601 PyThreadState* __tstate = wxPyBeginAllowThreads();
5602 (arg1)->SetLeft(arg2);
5603
5604 wxPyEndAllowThreads(__tstate);
5605 if (PyErr_Occurred()) SWIG_fail;
5606 }
5607 Py_INCREF(Py_None); resultobj = Py_None;
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj;
5616 wxRect *arg1 = (wxRect *) 0 ;
5617 int arg2 ;
5618 PyObject * obj0 = 0 ;
5619 PyObject * obj1 = 0 ;
5620 char *kwnames[] = {
5621 (char *) "self",(char *) "right", NULL
5622 };
5623
5624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5626 if (SWIG_arg_fail(1)) SWIG_fail;
5627 {
5628 arg2 = (int)(SWIG_As_int(obj1));
5629 if (SWIG_arg_fail(2)) SWIG_fail;
5630 }
5631 {
5632 PyThreadState* __tstate = wxPyBeginAllowThreads();
5633 (arg1)->SetRight(arg2);
5634
5635 wxPyEndAllowThreads(__tstate);
5636 if (PyErr_Occurred()) SWIG_fail;
5637 }
5638 Py_INCREF(Py_None); resultobj = Py_None;
5639 return resultobj;
5640 fail:
5641 return NULL;
5642 }
5643
5644
5645 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5646 PyObject *resultobj;
5647 wxRect *arg1 = (wxRect *) 0 ;
5648 int arg2 ;
5649 PyObject * obj0 = 0 ;
5650 PyObject * obj1 = 0 ;
5651 char *kwnames[] = {
5652 (char *) "self",(char *) "top", NULL
5653 };
5654
5655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5657 if (SWIG_arg_fail(1)) SWIG_fail;
5658 {
5659 arg2 = (int)(SWIG_As_int(obj1));
5660 if (SWIG_arg_fail(2)) SWIG_fail;
5661 }
5662 {
5663 PyThreadState* __tstate = wxPyBeginAllowThreads();
5664 (arg1)->SetTop(arg2);
5665
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 Py_INCREF(Py_None); resultobj = Py_None;
5670 return resultobj;
5671 fail:
5672 return NULL;
5673 }
5674
5675
5676 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5677 PyObject *resultobj;
5678 wxRect *arg1 = (wxRect *) 0 ;
5679 int arg2 ;
5680 PyObject * obj0 = 0 ;
5681 PyObject * obj1 = 0 ;
5682 char *kwnames[] = {
5683 (char *) "self",(char *) "bottom", NULL
5684 };
5685
5686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5688 if (SWIG_arg_fail(1)) SWIG_fail;
5689 {
5690 arg2 = (int)(SWIG_As_int(obj1));
5691 if (SWIG_arg_fail(2)) SWIG_fail;
5692 }
5693 {
5694 PyThreadState* __tstate = wxPyBeginAllowThreads();
5695 (arg1)->SetBottom(arg2);
5696
5697 wxPyEndAllowThreads(__tstate);
5698 if (PyErr_Occurred()) SWIG_fail;
5699 }
5700 Py_INCREF(Py_None); resultobj = Py_None;
5701 return resultobj;
5702 fail:
5703 return NULL;
5704 }
5705
5706
5707 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5708 PyObject *resultobj;
5709 wxRect *arg1 = (wxRect *) 0 ;
5710 int arg2 ;
5711 int arg3 ;
5712 wxRect *result;
5713 PyObject * obj0 = 0 ;
5714 PyObject * obj1 = 0 ;
5715 PyObject * obj2 = 0 ;
5716 char *kwnames[] = {
5717 (char *) "self",(char *) "dx",(char *) "dy", NULL
5718 };
5719
5720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5722 if (SWIG_arg_fail(1)) SWIG_fail;
5723 {
5724 arg2 = (int)(SWIG_As_int(obj1));
5725 if (SWIG_arg_fail(2)) SWIG_fail;
5726 }
5727 {
5728 arg3 = (int)(SWIG_As_int(obj2));
5729 if (SWIG_arg_fail(3)) SWIG_fail;
5730 }
5731 {
5732 PyThreadState* __tstate = wxPyBeginAllowThreads();
5733 {
5734 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5735 result = (wxRect *) &_result_ref;
5736 }
5737
5738 wxPyEndAllowThreads(__tstate);
5739 if (PyErr_Occurred()) SWIG_fail;
5740 }
5741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5742 return resultobj;
5743 fail:
5744 return NULL;
5745 }
5746
5747
5748 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5749 PyObject *resultobj;
5750 wxRect *arg1 = (wxRect *) 0 ;
5751 int arg2 ;
5752 int arg3 ;
5753 wxRect *result;
5754 PyObject * obj0 = 0 ;
5755 PyObject * obj1 = 0 ;
5756 PyObject * obj2 = 0 ;
5757 char *kwnames[] = {
5758 (char *) "self",(char *) "dx",(char *) "dy", NULL
5759 };
5760
5761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5763 if (SWIG_arg_fail(1)) SWIG_fail;
5764 {
5765 arg2 = (int)(SWIG_As_int(obj1));
5766 if (SWIG_arg_fail(2)) SWIG_fail;
5767 }
5768 {
5769 arg3 = (int)(SWIG_As_int(obj2));
5770 if (SWIG_arg_fail(3)) SWIG_fail;
5771 }
5772 {
5773 PyThreadState* __tstate = wxPyBeginAllowThreads();
5774 {
5775 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5776 result = (wxRect *) &_result_ref;
5777 }
5778
5779 wxPyEndAllowThreads(__tstate);
5780 if (PyErr_Occurred()) SWIG_fail;
5781 }
5782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5783 return resultobj;
5784 fail:
5785 return NULL;
5786 }
5787
5788
5789 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5790 PyObject *resultobj;
5791 wxRect *arg1 = (wxRect *) 0 ;
5792 int arg2 ;
5793 int arg3 ;
5794 PyObject * obj0 = 0 ;
5795 PyObject * obj1 = 0 ;
5796 PyObject * obj2 = 0 ;
5797 char *kwnames[] = {
5798 (char *) "self",(char *) "dx",(char *) "dy", NULL
5799 };
5800
5801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5803 if (SWIG_arg_fail(1)) SWIG_fail;
5804 {
5805 arg2 = (int)(SWIG_As_int(obj1));
5806 if (SWIG_arg_fail(2)) SWIG_fail;
5807 }
5808 {
5809 arg3 = (int)(SWIG_As_int(obj2));
5810 if (SWIG_arg_fail(3)) SWIG_fail;
5811 }
5812 {
5813 PyThreadState* __tstate = wxPyBeginAllowThreads();
5814 (arg1)->Offset(arg2,arg3);
5815
5816 wxPyEndAllowThreads(__tstate);
5817 if (PyErr_Occurred()) SWIG_fail;
5818 }
5819 Py_INCREF(Py_None); resultobj = Py_None;
5820 return resultobj;
5821 fail:
5822 return NULL;
5823 }
5824
5825
5826 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5827 PyObject *resultobj;
5828 wxRect *arg1 = (wxRect *) 0 ;
5829 wxPoint *arg2 = 0 ;
5830 wxPoint temp2 ;
5831 PyObject * obj0 = 0 ;
5832 PyObject * obj1 = 0 ;
5833 char *kwnames[] = {
5834 (char *) "self",(char *) "pt", NULL
5835 };
5836
5837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5839 if (SWIG_arg_fail(1)) SWIG_fail;
5840 {
5841 arg2 = &temp2;
5842 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5843 }
5844 {
5845 PyThreadState* __tstate = wxPyBeginAllowThreads();
5846 (arg1)->Offset((wxPoint const &)*arg2);
5847
5848 wxPyEndAllowThreads(__tstate);
5849 if (PyErr_Occurred()) SWIG_fail;
5850 }
5851 Py_INCREF(Py_None); resultobj = Py_None;
5852 return resultobj;
5853 fail:
5854 return NULL;
5855 }
5856
5857
5858 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5859 PyObject *resultobj;
5860 wxRect *arg1 = (wxRect *) 0 ;
5861 wxRect *arg2 = 0 ;
5862 wxRect result;
5863 wxRect temp2 ;
5864 PyObject * obj0 = 0 ;
5865 PyObject * obj1 = 0 ;
5866 char *kwnames[] = {
5867 (char *) "self",(char *) "rect", NULL
5868 };
5869
5870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5872 if (SWIG_arg_fail(1)) SWIG_fail;
5873 {
5874 arg2 = &temp2;
5875 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5876 }
5877 {
5878 PyThreadState* __tstate = wxPyBeginAllowThreads();
5879 result = (arg1)->Intersect((wxRect const &)*arg2);
5880
5881 wxPyEndAllowThreads(__tstate);
5882 if (PyErr_Occurred()) SWIG_fail;
5883 }
5884 {
5885 wxRect * resultptr;
5886 resultptr = new wxRect((wxRect &)(result));
5887 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5888 }
5889 return resultobj;
5890 fail:
5891 return NULL;
5892 }
5893
5894
5895 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5896 PyObject *resultobj;
5897 wxRect *arg1 = (wxRect *) 0 ;
5898 wxRect *arg2 = 0 ;
5899 wxRect result;
5900 wxRect temp2 ;
5901 PyObject * obj0 = 0 ;
5902 PyObject * obj1 = 0 ;
5903 char *kwnames[] = {
5904 (char *) "self",(char *) "rect", NULL
5905 };
5906
5907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5909 if (SWIG_arg_fail(1)) SWIG_fail;
5910 {
5911 arg2 = &temp2;
5912 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5913 }
5914 {
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 result = (arg1)->Union((wxRect const &)*arg2);
5917
5918 wxPyEndAllowThreads(__tstate);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 {
5922 wxRect * resultptr;
5923 resultptr = new wxRect((wxRect &)(result));
5924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5925 }
5926 return resultobj;
5927 fail:
5928 return NULL;
5929 }
5930
5931
5932 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5933 PyObject *resultobj;
5934 wxRect *arg1 = (wxRect *) 0 ;
5935 wxRect *arg2 = 0 ;
5936 wxRect result;
5937 wxRect temp2 ;
5938 PyObject * obj0 = 0 ;
5939 PyObject * obj1 = 0 ;
5940 char *kwnames[] = {
5941 (char *) "self",(char *) "rect", NULL
5942 };
5943
5944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5946 if (SWIG_arg_fail(1)) SWIG_fail;
5947 {
5948 arg2 = &temp2;
5949 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5950 }
5951 {
5952 PyThreadState* __tstate = wxPyBeginAllowThreads();
5953 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5954
5955 wxPyEndAllowThreads(__tstate);
5956 if (PyErr_Occurred()) SWIG_fail;
5957 }
5958 {
5959 wxRect * resultptr;
5960 resultptr = new wxRect((wxRect &)(result));
5961 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5962 }
5963 return resultobj;
5964 fail:
5965 return NULL;
5966 }
5967
5968
5969 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5970 PyObject *resultobj;
5971 wxRect *arg1 = (wxRect *) 0 ;
5972 wxRect *arg2 = 0 ;
5973 wxRect *result;
5974 wxRect temp2 ;
5975 PyObject * obj0 = 0 ;
5976 PyObject * obj1 = 0 ;
5977 char *kwnames[] = {
5978 (char *) "self",(char *) "rect", NULL
5979 };
5980
5981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5983 if (SWIG_arg_fail(1)) SWIG_fail;
5984 {
5985 arg2 = &temp2;
5986 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5987 }
5988 {
5989 PyThreadState* __tstate = wxPyBeginAllowThreads();
5990 {
5991 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5992 result = (wxRect *) &_result_ref;
5993 }
5994
5995 wxPyEndAllowThreads(__tstate);
5996 if (PyErr_Occurred()) SWIG_fail;
5997 }
5998 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5999 return resultobj;
6000 fail:
6001 return NULL;
6002 }
6003
6004
6005 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6006 PyObject *resultobj;
6007 wxRect *arg1 = (wxRect *) 0 ;
6008 wxRect *arg2 = 0 ;
6009 bool result;
6010 wxRect temp2 ;
6011 PyObject * obj0 = 0 ;
6012 PyObject * obj1 = 0 ;
6013 char *kwnames[] = {
6014 (char *) "self",(char *) "rect", NULL
6015 };
6016
6017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6019 if (SWIG_arg_fail(1)) SWIG_fail;
6020 {
6021 arg2 = &temp2;
6022 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6023 }
6024 {
6025 PyThreadState* __tstate = wxPyBeginAllowThreads();
6026 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6027
6028 wxPyEndAllowThreads(__tstate);
6029 if (PyErr_Occurred()) SWIG_fail;
6030 }
6031 {
6032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6033 }
6034 return resultobj;
6035 fail:
6036 return NULL;
6037 }
6038
6039
6040 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6041 PyObject *resultobj;
6042 wxRect *arg1 = (wxRect *) 0 ;
6043 wxRect *arg2 = 0 ;
6044 bool result;
6045 wxRect temp2 ;
6046 PyObject * obj0 = 0 ;
6047 PyObject * obj1 = 0 ;
6048 char *kwnames[] = {
6049 (char *) "self",(char *) "rect", NULL
6050 };
6051
6052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6054 if (SWIG_arg_fail(1)) SWIG_fail;
6055 {
6056 arg2 = &temp2;
6057 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6058 }
6059 {
6060 PyThreadState* __tstate = wxPyBeginAllowThreads();
6061 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6062
6063 wxPyEndAllowThreads(__tstate);
6064 if (PyErr_Occurred()) SWIG_fail;
6065 }
6066 {
6067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6068 }
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj;
6077 wxRect *arg1 = (wxRect *) 0 ;
6078 int arg2 ;
6079 int arg3 ;
6080 bool result;
6081 PyObject * obj0 = 0 ;
6082 PyObject * obj1 = 0 ;
6083 PyObject * obj2 = 0 ;
6084 char *kwnames[] = {
6085 (char *) "self",(char *) "x",(char *) "y", NULL
6086 };
6087
6088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6090 if (SWIG_arg_fail(1)) SWIG_fail;
6091 {
6092 arg2 = (int)(SWIG_As_int(obj1));
6093 if (SWIG_arg_fail(2)) SWIG_fail;
6094 }
6095 {
6096 arg3 = (int)(SWIG_As_int(obj2));
6097 if (SWIG_arg_fail(3)) SWIG_fail;
6098 }
6099 {
6100 PyThreadState* __tstate = wxPyBeginAllowThreads();
6101 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6102
6103 wxPyEndAllowThreads(__tstate);
6104 if (PyErr_Occurred()) SWIG_fail;
6105 }
6106 {
6107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6108 }
6109 return resultobj;
6110 fail:
6111 return NULL;
6112 }
6113
6114
6115 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6116 PyObject *resultobj;
6117 wxRect *arg1 = (wxRect *) 0 ;
6118 wxPoint *arg2 = 0 ;
6119 bool result;
6120 wxPoint temp2 ;
6121 PyObject * obj0 = 0 ;
6122 PyObject * obj1 = 0 ;
6123 char *kwnames[] = {
6124 (char *) "self",(char *) "pt", NULL
6125 };
6126
6127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6129 if (SWIG_arg_fail(1)) SWIG_fail;
6130 {
6131 arg2 = &temp2;
6132 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6133 }
6134 {
6135 PyThreadState* __tstate = wxPyBeginAllowThreads();
6136 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6137
6138 wxPyEndAllowThreads(__tstate);
6139 if (PyErr_Occurred()) SWIG_fail;
6140 }
6141 {
6142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6143 }
6144 return resultobj;
6145 fail:
6146 return NULL;
6147 }
6148
6149
6150 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6151 PyObject *resultobj;
6152 wxRect *arg1 = (wxRect *) 0 ;
6153 wxRect *arg2 = 0 ;
6154 bool result;
6155 wxRect temp2 ;
6156 PyObject * obj0 = 0 ;
6157 PyObject * obj1 = 0 ;
6158 char *kwnames[] = {
6159 (char *) "self",(char *) "rect", NULL
6160 };
6161
6162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6164 if (SWIG_arg_fail(1)) SWIG_fail;
6165 {
6166 arg2 = &temp2;
6167 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6168 }
6169 {
6170 PyThreadState* __tstate = wxPyBeginAllowThreads();
6171 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6172
6173 wxPyEndAllowThreads(__tstate);
6174 if (PyErr_Occurred()) SWIG_fail;
6175 }
6176 {
6177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6178 }
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj;
6187 wxRect *arg1 = (wxRect *) 0 ;
6188 int arg2 ;
6189 PyObject * obj0 = 0 ;
6190 PyObject * obj1 = 0 ;
6191 char *kwnames[] = {
6192 (char *) "self",(char *) "x", NULL
6193 };
6194
6195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6197 if (SWIG_arg_fail(1)) SWIG_fail;
6198 {
6199 arg2 = (int)(SWIG_As_int(obj1));
6200 if (SWIG_arg_fail(2)) SWIG_fail;
6201 }
6202 if (arg1) (arg1)->x = arg2;
6203
6204 Py_INCREF(Py_None); resultobj = Py_None;
6205 return resultobj;
6206 fail:
6207 return NULL;
6208 }
6209
6210
6211 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6212 PyObject *resultobj;
6213 wxRect *arg1 = (wxRect *) 0 ;
6214 int result;
6215 PyObject * obj0 = 0 ;
6216 char *kwnames[] = {
6217 (char *) "self", NULL
6218 };
6219
6220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6222 if (SWIG_arg_fail(1)) SWIG_fail;
6223 result = (int) ((arg1)->x);
6224
6225 {
6226 resultobj = SWIG_From_int((int)(result));
6227 }
6228 return resultobj;
6229 fail:
6230 return NULL;
6231 }
6232
6233
6234 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6235 PyObject *resultobj;
6236 wxRect *arg1 = (wxRect *) 0 ;
6237 int arg2 ;
6238 PyObject * obj0 = 0 ;
6239 PyObject * obj1 = 0 ;
6240 char *kwnames[] = {
6241 (char *) "self",(char *) "y", NULL
6242 };
6243
6244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6246 if (SWIG_arg_fail(1)) SWIG_fail;
6247 {
6248 arg2 = (int)(SWIG_As_int(obj1));
6249 if (SWIG_arg_fail(2)) SWIG_fail;
6250 }
6251 if (arg1) (arg1)->y = arg2;
6252
6253 Py_INCREF(Py_None); resultobj = Py_None;
6254 return resultobj;
6255 fail:
6256 return NULL;
6257 }
6258
6259
6260 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6261 PyObject *resultobj;
6262 wxRect *arg1 = (wxRect *) 0 ;
6263 int result;
6264 PyObject * obj0 = 0 ;
6265 char *kwnames[] = {
6266 (char *) "self", NULL
6267 };
6268
6269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6271 if (SWIG_arg_fail(1)) SWIG_fail;
6272 result = (int) ((arg1)->y);
6273
6274 {
6275 resultobj = SWIG_From_int((int)(result));
6276 }
6277 return resultobj;
6278 fail:
6279 return NULL;
6280 }
6281
6282
6283 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6284 PyObject *resultobj;
6285 wxRect *arg1 = (wxRect *) 0 ;
6286 int arg2 ;
6287 PyObject * obj0 = 0 ;
6288 PyObject * obj1 = 0 ;
6289 char *kwnames[] = {
6290 (char *) "self",(char *) "width", NULL
6291 };
6292
6293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6295 if (SWIG_arg_fail(1)) SWIG_fail;
6296 {
6297 arg2 = (int)(SWIG_As_int(obj1));
6298 if (SWIG_arg_fail(2)) SWIG_fail;
6299 }
6300 if (arg1) (arg1)->width = arg2;
6301
6302 Py_INCREF(Py_None); resultobj = Py_None;
6303 return resultobj;
6304 fail:
6305 return NULL;
6306 }
6307
6308
6309 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6310 PyObject *resultobj;
6311 wxRect *arg1 = (wxRect *) 0 ;
6312 int result;
6313 PyObject * obj0 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "self", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 result = (int) ((arg1)->width);
6322
6323 {
6324 resultobj = SWIG_From_int((int)(result));
6325 }
6326 return resultobj;
6327 fail:
6328 return NULL;
6329 }
6330
6331
6332 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6333 PyObject *resultobj;
6334 wxRect *arg1 = (wxRect *) 0 ;
6335 int arg2 ;
6336 PyObject * obj0 = 0 ;
6337 PyObject * obj1 = 0 ;
6338 char *kwnames[] = {
6339 (char *) "self",(char *) "height", NULL
6340 };
6341
6342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6344 if (SWIG_arg_fail(1)) SWIG_fail;
6345 {
6346 arg2 = (int)(SWIG_As_int(obj1));
6347 if (SWIG_arg_fail(2)) SWIG_fail;
6348 }
6349 if (arg1) (arg1)->height = arg2;
6350
6351 Py_INCREF(Py_None); resultobj = Py_None;
6352 return resultobj;
6353 fail:
6354 return NULL;
6355 }
6356
6357
6358 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6359 PyObject *resultobj;
6360 wxRect *arg1 = (wxRect *) 0 ;
6361 int result;
6362 PyObject * obj0 = 0 ;
6363 char *kwnames[] = {
6364 (char *) "self", NULL
6365 };
6366
6367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6369 if (SWIG_arg_fail(1)) SWIG_fail;
6370 result = (int) ((arg1)->height);
6371
6372 {
6373 resultobj = SWIG_From_int((int)(result));
6374 }
6375 return resultobj;
6376 fail:
6377 return NULL;
6378 }
6379
6380
6381 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6382 PyObject *resultobj;
6383 wxRect *arg1 = (wxRect *) 0 ;
6384 int arg2 = (int) 0 ;
6385 int arg3 = (int) 0 ;
6386 int arg4 = (int) 0 ;
6387 int arg5 = (int) 0 ;
6388 PyObject * obj0 = 0 ;
6389 PyObject * obj1 = 0 ;
6390 PyObject * obj2 = 0 ;
6391 PyObject * obj3 = 0 ;
6392 PyObject * obj4 = 0 ;
6393 char *kwnames[] = {
6394 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6395 };
6396
6397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6399 if (SWIG_arg_fail(1)) SWIG_fail;
6400 if (obj1) {
6401 {
6402 arg2 = (int)(SWIG_As_int(obj1));
6403 if (SWIG_arg_fail(2)) SWIG_fail;
6404 }
6405 }
6406 if (obj2) {
6407 {
6408 arg3 = (int)(SWIG_As_int(obj2));
6409 if (SWIG_arg_fail(3)) SWIG_fail;
6410 }
6411 }
6412 if (obj3) {
6413 {
6414 arg4 = (int)(SWIG_As_int(obj3));
6415 if (SWIG_arg_fail(4)) SWIG_fail;
6416 }
6417 }
6418 if (obj4) {
6419 {
6420 arg5 = (int)(SWIG_As_int(obj4));
6421 if (SWIG_arg_fail(5)) SWIG_fail;
6422 }
6423 }
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6427
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 Py_INCREF(Py_None); resultobj = Py_None;
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj;
6440 wxRect *arg1 = (wxRect *) 0 ;
6441 PyObject *result;
6442 PyObject * obj0 = 0 ;
6443 char *kwnames[] = {
6444 (char *) "self", NULL
6445 };
6446
6447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6449 if (SWIG_arg_fail(1)) SWIG_fail;
6450 {
6451 PyThreadState* __tstate = wxPyBeginAllowThreads();
6452 result = (PyObject *)wxRect_Get(arg1);
6453
6454 wxPyEndAllowThreads(__tstate);
6455 if (PyErr_Occurred()) SWIG_fail;
6456 }
6457 resultobj = result;
6458 return resultobj;
6459 fail:
6460 return NULL;
6461 }
6462
6463
6464 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6465 PyObject *obj;
6466 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6467 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6468 Py_INCREF(obj);
6469 return Py_BuildValue((char *)"");
6470 }
6471 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6472 PyObject *resultobj;
6473 wxRect *arg1 = (wxRect *) 0 ;
6474 wxRect *arg2 = (wxRect *) 0 ;
6475 PyObject *result;
6476 PyObject * obj0 = 0 ;
6477 PyObject * obj1 = 0 ;
6478 char *kwnames[] = {
6479 (char *) "r1",(char *) "r2", NULL
6480 };
6481
6482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6484 if (SWIG_arg_fail(1)) SWIG_fail;
6485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6486 if (SWIG_arg_fail(2)) SWIG_fail;
6487 {
6488 if (!wxPyCheckForApp()) SWIG_fail;
6489 PyThreadState* __tstate = wxPyBeginAllowThreads();
6490 result = (PyObject *)wxIntersectRect(arg1,arg2);
6491
6492 wxPyEndAllowThreads(__tstate);
6493 if (PyErr_Occurred()) SWIG_fail;
6494 }
6495 resultobj = result;
6496 return resultobj;
6497 fail:
6498 return NULL;
6499 }
6500
6501
6502 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6503 PyObject *resultobj;
6504 double arg1 = (double) 0.0 ;
6505 double arg2 = (double) 0.0 ;
6506 wxPoint2D *result;
6507 PyObject * obj0 = 0 ;
6508 PyObject * obj1 = 0 ;
6509 char *kwnames[] = {
6510 (char *) "x",(char *) "y", NULL
6511 };
6512
6513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6514 if (obj0) {
6515 {
6516 arg1 = (double)(SWIG_As_double(obj0));
6517 if (SWIG_arg_fail(1)) SWIG_fail;
6518 }
6519 }
6520 if (obj1) {
6521 {
6522 arg2 = (double)(SWIG_As_double(obj1));
6523 if (SWIG_arg_fail(2)) SWIG_fail;
6524 }
6525 }
6526 {
6527 PyThreadState* __tstate = wxPyBeginAllowThreads();
6528 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6529
6530 wxPyEndAllowThreads(__tstate);
6531 if (PyErr_Occurred()) SWIG_fail;
6532 }
6533 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6534 return resultobj;
6535 fail:
6536 return NULL;
6537 }
6538
6539
6540 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6541 PyObject *resultobj;
6542 wxPoint2D *arg1 = 0 ;
6543 wxPoint2D *result;
6544 wxPoint2D temp1 ;
6545 PyObject * obj0 = 0 ;
6546 char *kwnames[] = {
6547 (char *) "pt", NULL
6548 };
6549
6550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6551 {
6552 arg1 = &temp1;
6553 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6554 }
6555 {
6556 PyThreadState* __tstate = wxPyBeginAllowThreads();
6557 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6558
6559 wxPyEndAllowThreads(__tstate);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj;
6571 wxPoint *arg1 = 0 ;
6572 wxPoint2D *result;
6573 wxPoint temp1 ;
6574 PyObject * obj0 = 0 ;
6575 char *kwnames[] = {
6576 (char *) "pt", NULL
6577 };
6578
6579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6580 {
6581 arg1 = &temp1;
6582 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6583 }
6584 {
6585 PyThreadState* __tstate = wxPyBeginAllowThreads();
6586 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6587
6588 wxPyEndAllowThreads(__tstate);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6599 PyObject *resultobj;
6600 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6601 int *arg2 = (int *) 0 ;
6602 int *arg3 = (int *) 0 ;
6603 int temp2 ;
6604 int res2 = 0 ;
6605 int temp3 ;
6606 int res3 = 0 ;
6607 PyObject * obj0 = 0 ;
6608 char *kwnames[] = {
6609 (char *) "self", NULL
6610 };
6611
6612 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6613 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6616 if (SWIG_arg_fail(1)) SWIG_fail;
6617 {
6618 PyThreadState* __tstate = wxPyBeginAllowThreads();
6619 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6620
6621 wxPyEndAllowThreads(__tstate);
6622 if (PyErr_Occurred()) SWIG_fail;
6623 }
6624 Py_INCREF(Py_None); resultobj = Py_None;
6625 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6626 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6627 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6628 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6636 PyObject *resultobj;
6637 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6638 int *arg2 = (int *) 0 ;
6639 int *arg3 = (int *) 0 ;
6640 int temp2 ;
6641 int res2 = 0 ;
6642 int temp3 ;
6643 int res3 = 0 ;
6644 PyObject * obj0 = 0 ;
6645 char *kwnames[] = {
6646 (char *) "self", NULL
6647 };
6648
6649 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6650 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6653 if (SWIG_arg_fail(1)) SWIG_fail;
6654 {
6655 PyThreadState* __tstate = wxPyBeginAllowThreads();
6656 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6657
6658 wxPyEndAllowThreads(__tstate);
6659 if (PyErr_Occurred()) SWIG_fail;
6660 }
6661 Py_INCREF(Py_None); resultobj = Py_None;
6662 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6663 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6664 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6665 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6666 return resultobj;
6667 fail:
6668 return NULL;
6669 }
6670
6671
6672 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6673 PyObject *resultobj;
6674 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6675 double result;
6676 PyObject * obj0 = 0 ;
6677 char *kwnames[] = {
6678 (char *) "self", NULL
6679 };
6680
6681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6683 if (SWIG_arg_fail(1)) SWIG_fail;
6684 {
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6687
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = SWIG_From_double((double)(result));
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6701 PyObject *resultobj;
6702 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6703 double result;
6704 PyObject * obj0 = 0 ;
6705 char *kwnames[] = {
6706 (char *) "self", NULL
6707 };
6708
6709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6711 if (SWIG_arg_fail(1)) SWIG_fail;
6712 {
6713 PyThreadState* __tstate = wxPyBeginAllowThreads();
6714 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6715
6716 wxPyEndAllowThreads(__tstate);
6717 if (PyErr_Occurred()) SWIG_fail;
6718 }
6719 {
6720 resultobj = SWIG_From_double((double)(result));
6721 }
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6729 PyObject *resultobj;
6730 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6731 double arg2 ;
6732 PyObject * obj0 = 0 ;
6733 PyObject * obj1 = 0 ;
6734 char *kwnames[] = {
6735 (char *) "self",(char *) "length", NULL
6736 };
6737
6738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6740 if (SWIG_arg_fail(1)) SWIG_fail;
6741 {
6742 arg2 = (double)(SWIG_As_double(obj1));
6743 if (SWIG_arg_fail(2)) SWIG_fail;
6744 }
6745 {
6746 PyThreadState* __tstate = wxPyBeginAllowThreads();
6747 (arg1)->SetVectorLength(arg2);
6748
6749 wxPyEndAllowThreads(__tstate);
6750 if (PyErr_Occurred()) SWIG_fail;
6751 }
6752 Py_INCREF(Py_None); resultobj = Py_None;
6753 return resultobj;
6754 fail:
6755 return NULL;
6756 }
6757
6758
6759 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6760 PyObject *resultobj;
6761 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6762 double arg2 ;
6763 PyObject * obj0 = 0 ;
6764 PyObject * obj1 = 0 ;
6765 char *kwnames[] = {
6766 (char *) "self",(char *) "degrees", NULL
6767 };
6768
6769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6771 if (SWIG_arg_fail(1)) SWIG_fail;
6772 {
6773 arg2 = (double)(SWIG_As_double(obj1));
6774 if (SWIG_arg_fail(2)) SWIG_fail;
6775 }
6776 {
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 (arg1)->SetVectorAngle(arg2);
6779
6780 wxPyEndAllowThreads(__tstate);
6781 if (PyErr_Occurred()) SWIG_fail;
6782 }
6783 Py_INCREF(Py_None); resultobj = Py_None;
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6791 PyObject *resultobj;
6792 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6793 wxPoint2D *arg2 = 0 ;
6794 double result;
6795 wxPoint2D temp2 ;
6796 PyObject * obj0 = 0 ;
6797 PyObject * obj1 = 0 ;
6798 char *kwnames[] = {
6799 (char *) "self",(char *) "pt", NULL
6800 };
6801
6802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6804 if (SWIG_arg_fail(1)) SWIG_fail;
6805 {
6806 arg2 = &temp2;
6807 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6808 }
6809 {
6810 PyThreadState* __tstate = wxPyBeginAllowThreads();
6811 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6812
6813 wxPyEndAllowThreads(__tstate);
6814 if (PyErr_Occurred()) SWIG_fail;
6815 }
6816 {
6817 resultobj = SWIG_From_double((double)(result));
6818 }
6819 return resultobj;
6820 fail:
6821 return NULL;
6822 }
6823
6824
6825 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6826 PyObject *resultobj;
6827 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6828 wxPoint2D *arg2 = 0 ;
6829 double result;
6830 wxPoint2D temp2 ;
6831 PyObject * obj0 = 0 ;
6832 PyObject * obj1 = 0 ;
6833 char *kwnames[] = {
6834 (char *) "self",(char *) "pt", NULL
6835 };
6836
6837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6839 if (SWIG_arg_fail(1)) SWIG_fail;
6840 {
6841 arg2 = &temp2;
6842 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6843 }
6844 {
6845 PyThreadState* __tstate = wxPyBeginAllowThreads();
6846 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6847
6848 wxPyEndAllowThreads(__tstate);
6849 if (PyErr_Occurred()) SWIG_fail;
6850 }
6851 {
6852 resultobj = SWIG_From_double((double)(result));
6853 }
6854 return resultobj;
6855 fail:
6856 return NULL;
6857 }
6858
6859
6860 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6861 PyObject *resultobj;
6862 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6863 wxPoint2D *arg2 = 0 ;
6864 double result;
6865 wxPoint2D temp2 ;
6866 PyObject * obj0 = 0 ;
6867 PyObject * obj1 = 0 ;
6868 char *kwnames[] = {
6869 (char *) "self",(char *) "vec", NULL
6870 };
6871
6872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6874 if (SWIG_arg_fail(1)) SWIG_fail;
6875 {
6876 arg2 = &temp2;
6877 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6878 }
6879 {
6880 PyThreadState* __tstate = wxPyBeginAllowThreads();
6881 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6882
6883 wxPyEndAllowThreads(__tstate);
6884 if (PyErr_Occurred()) SWIG_fail;
6885 }
6886 {
6887 resultobj = SWIG_From_double((double)(result));
6888 }
6889 return resultobj;
6890 fail:
6891 return NULL;
6892 }
6893
6894
6895 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6896 PyObject *resultobj;
6897 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6898 wxPoint2D *arg2 = 0 ;
6899 double result;
6900 wxPoint2D temp2 ;
6901 PyObject * obj0 = 0 ;
6902 PyObject * obj1 = 0 ;
6903 char *kwnames[] = {
6904 (char *) "self",(char *) "vec", NULL
6905 };
6906
6907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6909 if (SWIG_arg_fail(1)) SWIG_fail;
6910 {
6911 arg2 = &temp2;
6912 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6913 }
6914 {
6915 PyThreadState* __tstate = wxPyBeginAllowThreads();
6916 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6917
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 {
6922 resultobj = SWIG_From_double((double)(result));
6923 }
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6931 PyObject *resultobj;
6932 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6933 wxPoint2D result;
6934 PyObject * obj0 = 0 ;
6935 char *kwnames[] = {
6936 (char *) "self", NULL
6937 };
6938
6939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6941 if (SWIG_arg_fail(1)) SWIG_fail;
6942 {
6943 PyThreadState* __tstate = wxPyBeginAllowThreads();
6944 result = (arg1)->operator -();
6945
6946 wxPyEndAllowThreads(__tstate);
6947 if (PyErr_Occurred()) SWIG_fail;
6948 }
6949 {
6950 wxPoint2D * resultptr;
6951 resultptr = new wxPoint2D((wxPoint2D &)(result));
6952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6953 }
6954 return resultobj;
6955 fail:
6956 return NULL;
6957 }
6958
6959
6960 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6961 PyObject *resultobj;
6962 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6963 wxPoint2D *arg2 = 0 ;
6964 wxPoint2D *result;
6965 wxPoint2D temp2 ;
6966 PyObject * obj0 = 0 ;
6967 PyObject * obj1 = 0 ;
6968 char *kwnames[] = {
6969 (char *) "self",(char *) "pt", NULL
6970 };
6971
6972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6974 if (SWIG_arg_fail(1)) SWIG_fail;
6975 {
6976 arg2 = &temp2;
6977 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6978 }
6979 {
6980 PyThreadState* __tstate = wxPyBeginAllowThreads();
6981 {
6982 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6983 result = (wxPoint2D *) &_result_ref;
6984 }
6985
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6990 return resultobj;
6991 fail:
6992 return NULL;
6993 }
6994
6995
6996 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6997 PyObject *resultobj;
6998 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6999 wxPoint2D *arg2 = 0 ;
7000 wxPoint2D *result;
7001 wxPoint2D temp2 ;
7002 PyObject * obj0 = 0 ;
7003 PyObject * obj1 = 0 ;
7004 char *kwnames[] = {
7005 (char *) "self",(char *) "pt", NULL
7006 };
7007
7008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7010 if (SWIG_arg_fail(1)) SWIG_fail;
7011 {
7012 arg2 = &temp2;
7013 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7014 }
7015 {
7016 PyThreadState* __tstate = wxPyBeginAllowThreads();
7017 {
7018 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7019 result = (wxPoint2D *) &_result_ref;
7020 }
7021
7022 wxPyEndAllowThreads(__tstate);
7023 if (PyErr_Occurred()) SWIG_fail;
7024 }
7025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7026 return resultobj;
7027 fail:
7028 return NULL;
7029 }
7030
7031
7032 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7033 PyObject *resultobj;
7034 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7035 wxPoint2D *arg2 = 0 ;
7036 wxPoint2D *result;
7037 wxPoint2D temp2 ;
7038 PyObject * obj0 = 0 ;
7039 PyObject * obj1 = 0 ;
7040 char *kwnames[] = {
7041 (char *) "self",(char *) "pt", NULL
7042 };
7043
7044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7046 if (SWIG_arg_fail(1)) SWIG_fail;
7047 {
7048 arg2 = &temp2;
7049 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7050 }
7051 {
7052 PyThreadState* __tstate = wxPyBeginAllowThreads();
7053 {
7054 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7055 result = (wxPoint2D *) &_result_ref;
7056 }
7057
7058 wxPyEndAllowThreads(__tstate);
7059 if (PyErr_Occurred()) SWIG_fail;
7060 }
7061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7062 return resultobj;
7063 fail:
7064 return NULL;
7065 }
7066
7067
7068 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7069 PyObject *resultobj;
7070 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7071 wxPoint2D *arg2 = 0 ;
7072 wxPoint2D *result;
7073 wxPoint2D temp2 ;
7074 PyObject * obj0 = 0 ;
7075 PyObject * obj1 = 0 ;
7076 char *kwnames[] = {
7077 (char *) "self",(char *) "pt", NULL
7078 };
7079
7080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7082 if (SWIG_arg_fail(1)) SWIG_fail;
7083 {
7084 arg2 = &temp2;
7085 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7086 }
7087 {
7088 PyThreadState* __tstate = wxPyBeginAllowThreads();
7089 {
7090 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7091 result = (wxPoint2D *) &_result_ref;
7092 }
7093
7094 wxPyEndAllowThreads(__tstate);
7095 if (PyErr_Occurred()) SWIG_fail;
7096 }
7097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7098 return resultobj;
7099 fail:
7100 return NULL;
7101 }
7102
7103
7104 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7105 PyObject *resultobj;
7106 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7107 wxPoint2D *arg2 = 0 ;
7108 bool result;
7109 wxPoint2D temp2 ;
7110 PyObject * obj0 = 0 ;
7111 PyObject * obj1 = 0 ;
7112 char *kwnames[] = {
7113 (char *) "self",(char *) "pt", NULL
7114 };
7115
7116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7118 if (SWIG_arg_fail(1)) SWIG_fail;
7119 {
7120 arg2 = &temp2;
7121 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7122 }
7123 {
7124 PyThreadState* __tstate = wxPyBeginAllowThreads();
7125 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7126
7127 wxPyEndAllowThreads(__tstate);
7128 if (PyErr_Occurred()) SWIG_fail;
7129 }
7130 {
7131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7132 }
7133 return resultobj;
7134 fail:
7135 return NULL;
7136 }
7137
7138
7139 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7140 PyObject *resultobj;
7141 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7142 wxPoint2D *arg2 = 0 ;
7143 bool result;
7144 wxPoint2D temp2 ;
7145 PyObject * obj0 = 0 ;
7146 PyObject * obj1 = 0 ;
7147 char *kwnames[] = {
7148 (char *) "self",(char *) "pt", NULL
7149 };
7150
7151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7153 if (SWIG_arg_fail(1)) SWIG_fail;
7154 {
7155 arg2 = &temp2;
7156 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7157 }
7158 {
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7161
7162 wxPyEndAllowThreads(__tstate);
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 {
7166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7167 }
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj;
7176 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7177 double arg2 ;
7178 PyObject * obj0 = 0 ;
7179 PyObject * obj1 = 0 ;
7180 char *kwnames[] = {
7181 (char *) "self",(char *) "m_x", NULL
7182 };
7183
7184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7186 if (SWIG_arg_fail(1)) SWIG_fail;
7187 {
7188 arg2 = (double)(SWIG_As_double(obj1));
7189 if (SWIG_arg_fail(2)) SWIG_fail;
7190 }
7191 if (arg1) (arg1)->m_x = arg2;
7192
7193 Py_INCREF(Py_None); resultobj = Py_None;
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7201 PyObject *resultobj;
7202 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7203 double result;
7204 PyObject * obj0 = 0 ;
7205 char *kwnames[] = {
7206 (char *) "self", NULL
7207 };
7208
7209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7211 if (SWIG_arg_fail(1)) SWIG_fail;
7212 result = (double) ((arg1)->m_x);
7213
7214 {
7215 resultobj = SWIG_From_double((double)(result));
7216 }
7217 return resultobj;
7218 fail:
7219 return NULL;
7220 }
7221
7222
7223 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7224 PyObject *resultobj;
7225 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7226 double arg2 ;
7227 PyObject * obj0 = 0 ;
7228 PyObject * obj1 = 0 ;
7229 char *kwnames[] = {
7230 (char *) "self",(char *) "m_y", NULL
7231 };
7232
7233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7235 if (SWIG_arg_fail(1)) SWIG_fail;
7236 {
7237 arg2 = (double)(SWIG_As_double(obj1));
7238 if (SWIG_arg_fail(2)) SWIG_fail;
7239 }
7240 if (arg1) (arg1)->m_y = arg2;
7241
7242 Py_INCREF(Py_None); resultobj = Py_None;
7243 return resultobj;
7244 fail:
7245 return NULL;
7246 }
7247
7248
7249 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7250 PyObject *resultobj;
7251 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7252 double result;
7253 PyObject * obj0 = 0 ;
7254 char *kwnames[] = {
7255 (char *) "self", NULL
7256 };
7257
7258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7260 if (SWIG_arg_fail(1)) SWIG_fail;
7261 result = (double) ((arg1)->m_y);
7262
7263 {
7264 resultobj = SWIG_From_double((double)(result));
7265 }
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7273 PyObject *resultobj;
7274 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7275 double arg2 = (double) 0 ;
7276 double arg3 = (double) 0 ;
7277 PyObject * obj0 = 0 ;
7278 PyObject * obj1 = 0 ;
7279 PyObject * obj2 = 0 ;
7280 char *kwnames[] = {
7281 (char *) "self",(char *) "x",(char *) "y", NULL
7282 };
7283
7284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7286 if (SWIG_arg_fail(1)) SWIG_fail;
7287 if (obj1) {
7288 {
7289 arg2 = (double)(SWIG_As_double(obj1));
7290 if (SWIG_arg_fail(2)) SWIG_fail;
7291 }
7292 }
7293 if (obj2) {
7294 {
7295 arg3 = (double)(SWIG_As_double(obj2));
7296 if (SWIG_arg_fail(3)) SWIG_fail;
7297 }
7298 }
7299 {
7300 PyThreadState* __tstate = wxPyBeginAllowThreads();
7301 wxPoint2D_Set(arg1,arg2,arg3);
7302
7303 wxPyEndAllowThreads(__tstate);
7304 if (PyErr_Occurred()) SWIG_fail;
7305 }
7306 Py_INCREF(Py_None); resultobj = Py_None;
7307 return resultobj;
7308 fail:
7309 return NULL;
7310 }
7311
7312
7313 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7314 PyObject *resultobj;
7315 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7316 PyObject *result;
7317 PyObject * obj0 = 0 ;
7318 char *kwnames[] = {
7319 (char *) "self", NULL
7320 };
7321
7322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7324 if (SWIG_arg_fail(1)) SWIG_fail;
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (PyObject *)wxPoint2D_Get(arg1);
7328
7329 wxPyEndAllowThreads(__tstate);
7330 if (PyErr_Occurred()) SWIG_fail;
7331 }
7332 resultobj = result;
7333 return resultobj;
7334 fail:
7335 return NULL;
7336 }
7337
7338
7339 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7340 PyObject *obj;
7341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7342 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7343 Py_INCREF(obj);
7344 return Py_BuildValue((char *)"");
7345 }
7346 static int _wrap_DefaultPosition_set(PyObject *) {
7347 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7348 return 1;
7349 }
7350
7351
7352 static PyObject *_wrap_DefaultPosition_get(void) {
7353 PyObject *pyobj;
7354
7355 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7356 return pyobj;
7357 }
7358
7359
7360 static int _wrap_DefaultSize_set(PyObject *) {
7361 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7362 return 1;
7363 }
7364
7365
7366 static PyObject *_wrap_DefaultSize_get(void) {
7367 PyObject *pyobj;
7368
7369 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7370 return pyobj;
7371 }
7372
7373
7374 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj;
7376 PyObject *arg1 = (PyObject *) 0 ;
7377 wxPyInputStream *result;
7378 PyObject * obj0 = 0 ;
7379 char *kwnames[] = {
7380 (char *) "p", NULL
7381 };
7382
7383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7384 arg1 = obj0;
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj;
7401 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7402 PyObject * obj0 = 0 ;
7403 char *kwnames[] = {
7404 (char *) "self", NULL
7405 };
7406
7407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7409 if (SWIG_arg_fail(1)) SWIG_fail;
7410 {
7411 PyThreadState* __tstate = wxPyBeginAllowThreads();
7412 delete arg1;
7413
7414 wxPyEndAllowThreads(__tstate);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 Py_INCREF(Py_None); resultobj = Py_None;
7418 return resultobj;
7419 fail:
7420 return NULL;
7421 }
7422
7423
7424 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7425 PyObject *resultobj;
7426 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7427 PyObject * obj0 = 0 ;
7428 char *kwnames[] = {
7429 (char *) "self", NULL
7430 };
7431
7432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7434 if (SWIG_arg_fail(1)) SWIG_fail;
7435 {
7436 PyThreadState* __tstate = wxPyBeginAllowThreads();
7437 (arg1)->close();
7438
7439 wxPyEndAllowThreads(__tstate);
7440 if (PyErr_Occurred()) SWIG_fail;
7441 }
7442 Py_INCREF(Py_None); resultobj = Py_None;
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj;
7451 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7452 PyObject * obj0 = 0 ;
7453 char *kwnames[] = {
7454 (char *) "self", NULL
7455 };
7456
7457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7459 if (SWIG_arg_fail(1)) SWIG_fail;
7460 {
7461 PyThreadState* __tstate = wxPyBeginAllowThreads();
7462 (arg1)->flush();
7463
7464 wxPyEndAllowThreads(__tstate);
7465 if (PyErr_Occurred()) SWIG_fail;
7466 }
7467 Py_INCREF(Py_None); resultobj = Py_None;
7468 return resultobj;
7469 fail:
7470 return NULL;
7471 }
7472
7473
7474 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7475 PyObject *resultobj;
7476 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7477 bool result;
7478 PyObject * obj0 = 0 ;
7479 char *kwnames[] = {
7480 (char *) "self", NULL
7481 };
7482
7483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7485 if (SWIG_arg_fail(1)) SWIG_fail;
7486 {
7487 PyThreadState* __tstate = wxPyBeginAllowThreads();
7488 result = (bool)(arg1)->eof();
7489
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 {
7494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7495 }
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7503 PyObject *resultobj;
7504 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7505 int arg2 = (int) -1 ;
7506 PyObject *result;
7507 PyObject * obj0 = 0 ;
7508 PyObject * obj1 = 0 ;
7509 char *kwnames[] = {
7510 (char *) "self",(char *) "size", NULL
7511 };
7512
7513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7515 if (SWIG_arg_fail(1)) SWIG_fail;
7516 if (obj1) {
7517 {
7518 arg2 = (int)(SWIG_As_int(obj1));
7519 if (SWIG_arg_fail(2)) SWIG_fail;
7520 }
7521 }
7522 {
7523 PyThreadState* __tstate = wxPyBeginAllowThreads();
7524 result = (PyObject *)(arg1)->read(arg2);
7525
7526 wxPyEndAllowThreads(__tstate);
7527 if (PyErr_Occurred()) SWIG_fail;
7528 }
7529 resultobj = result;
7530 return resultobj;
7531 fail:
7532 return NULL;
7533 }
7534
7535
7536 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7537 PyObject *resultobj;
7538 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7539 int arg2 = (int) -1 ;
7540 PyObject *result;
7541 PyObject * obj0 = 0 ;
7542 PyObject * obj1 = 0 ;
7543 char *kwnames[] = {
7544 (char *) "self",(char *) "size", NULL
7545 };
7546
7547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7549 if (SWIG_arg_fail(1)) SWIG_fail;
7550 if (obj1) {
7551 {
7552 arg2 = (int)(SWIG_As_int(obj1));
7553 if (SWIG_arg_fail(2)) SWIG_fail;
7554 }
7555 }
7556 {
7557 PyThreadState* __tstate = wxPyBeginAllowThreads();
7558 result = (PyObject *)(arg1)->readline(arg2);
7559
7560 wxPyEndAllowThreads(__tstate);
7561 if (PyErr_Occurred()) SWIG_fail;
7562 }
7563 resultobj = result;
7564 return resultobj;
7565 fail:
7566 return NULL;
7567 }
7568
7569
7570 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7571 PyObject *resultobj;
7572 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7573 int arg2 = (int) -1 ;
7574 PyObject *result;
7575 PyObject * obj0 = 0 ;
7576 PyObject * obj1 = 0 ;
7577 char *kwnames[] = {
7578 (char *) "self",(char *) "sizehint", NULL
7579 };
7580
7581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7583 if (SWIG_arg_fail(1)) SWIG_fail;
7584 if (obj1) {
7585 {
7586 arg2 = (int)(SWIG_As_int(obj1));
7587 if (SWIG_arg_fail(2)) SWIG_fail;
7588 }
7589 }
7590 {
7591 PyThreadState* __tstate = wxPyBeginAllowThreads();
7592 result = (PyObject *)(arg1)->readlines(arg2);
7593
7594 wxPyEndAllowThreads(__tstate);
7595 if (PyErr_Occurred()) SWIG_fail;
7596 }
7597 resultobj = result;
7598 return resultobj;
7599 fail:
7600 return NULL;
7601 }
7602
7603
7604 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7605 PyObject *resultobj;
7606 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7607 int arg2 ;
7608 int arg3 = (int) 0 ;
7609 PyObject * obj0 = 0 ;
7610 PyObject * obj1 = 0 ;
7611 PyObject * obj2 = 0 ;
7612 char *kwnames[] = {
7613 (char *) "self",(char *) "offset",(char *) "whence", NULL
7614 };
7615
7616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7618 if (SWIG_arg_fail(1)) SWIG_fail;
7619 {
7620 arg2 = (int)(SWIG_As_int(obj1));
7621 if (SWIG_arg_fail(2)) SWIG_fail;
7622 }
7623 if (obj2) {
7624 {
7625 arg3 = (int)(SWIG_As_int(obj2));
7626 if (SWIG_arg_fail(3)) SWIG_fail;
7627 }
7628 }
7629 {
7630 PyThreadState* __tstate = wxPyBeginAllowThreads();
7631 (arg1)->seek(arg2,arg3);
7632
7633 wxPyEndAllowThreads(__tstate);
7634 if (PyErr_Occurred()) SWIG_fail;
7635 }
7636 Py_INCREF(Py_None); resultobj = Py_None;
7637 return resultobj;
7638 fail:
7639 return NULL;
7640 }
7641
7642
7643 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7644 PyObject *resultobj;
7645 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7646 int result;
7647 PyObject * obj0 = 0 ;
7648 char *kwnames[] = {
7649 (char *) "self", NULL
7650 };
7651
7652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7654 if (SWIG_arg_fail(1)) SWIG_fail;
7655 {
7656 PyThreadState* __tstate = wxPyBeginAllowThreads();
7657 result = (int)(arg1)->tell();
7658
7659 wxPyEndAllowThreads(__tstate);
7660 if (PyErr_Occurred()) SWIG_fail;
7661 }
7662 {
7663 resultobj = SWIG_From_int((int)(result));
7664 }
7665 return resultobj;
7666 fail:
7667 return NULL;
7668 }
7669
7670
7671 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7672 PyObject *resultobj;
7673 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7674 char result;
7675 PyObject * obj0 = 0 ;
7676 char *kwnames[] = {
7677 (char *) "self", NULL
7678 };
7679
7680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7682 if (SWIG_arg_fail(1)) SWIG_fail;
7683 {
7684 PyThreadState* __tstate = wxPyBeginAllowThreads();
7685 result = (char)(arg1)->Peek();
7686
7687 wxPyEndAllowThreads(__tstate);
7688 if (PyErr_Occurred()) SWIG_fail;
7689 }
7690 {
7691 resultobj = SWIG_From_char((char)(result));
7692 }
7693 return resultobj;
7694 fail:
7695 return NULL;
7696 }
7697
7698
7699 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7700 PyObject *resultobj;
7701 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7702 char result;
7703 PyObject * obj0 = 0 ;
7704 char *kwnames[] = {
7705 (char *) "self", NULL
7706 };
7707
7708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7710 if (SWIG_arg_fail(1)) SWIG_fail;
7711 {
7712 PyThreadState* __tstate = wxPyBeginAllowThreads();
7713 result = (char)(arg1)->GetC();
7714
7715 wxPyEndAllowThreads(__tstate);
7716 if (PyErr_Occurred()) SWIG_fail;
7717 }
7718 {
7719 resultobj = SWIG_From_char((char)(result));
7720 }
7721 return resultobj;
7722 fail:
7723 return NULL;
7724 }
7725
7726
7727 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7728 PyObject *resultobj;
7729 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7730 size_t result;
7731 PyObject * obj0 = 0 ;
7732 char *kwnames[] = {
7733 (char *) "self", NULL
7734 };
7735
7736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7738 if (SWIG_arg_fail(1)) SWIG_fail;
7739 {
7740 PyThreadState* __tstate = wxPyBeginAllowThreads();
7741 result = (size_t)(arg1)->LastRead();
7742
7743 wxPyEndAllowThreads(__tstate);
7744 if (PyErr_Occurred()) SWIG_fail;
7745 }
7746 {
7747 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7748 }
7749 return resultobj;
7750 fail:
7751 return NULL;
7752 }
7753
7754
7755 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7756 PyObject *resultobj;
7757 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7758 bool result;
7759 PyObject * obj0 = 0 ;
7760 char *kwnames[] = {
7761 (char *) "self", NULL
7762 };
7763
7764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7766 if (SWIG_arg_fail(1)) SWIG_fail;
7767 {
7768 PyThreadState* __tstate = wxPyBeginAllowThreads();
7769 result = (bool)(arg1)->CanRead();
7770
7771 wxPyEndAllowThreads(__tstate);
7772 if (PyErr_Occurred()) SWIG_fail;
7773 }
7774 {
7775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7776 }
7777 return resultobj;
7778 fail:
7779 return NULL;
7780 }
7781
7782
7783 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7784 PyObject *resultobj;
7785 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7786 bool result;
7787 PyObject * obj0 = 0 ;
7788 char *kwnames[] = {
7789 (char *) "self", NULL
7790 };
7791
7792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7794 if (SWIG_arg_fail(1)) SWIG_fail;
7795 {
7796 PyThreadState* __tstate = wxPyBeginAllowThreads();
7797 result = (bool)(arg1)->Eof();
7798
7799 wxPyEndAllowThreads(__tstate);
7800 if (PyErr_Occurred()) SWIG_fail;
7801 }
7802 {
7803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7804 }
7805 return resultobj;
7806 fail:
7807 return NULL;
7808 }
7809
7810
7811 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7812 PyObject *resultobj;
7813 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7814 char arg2 ;
7815 bool result;
7816 PyObject * obj0 = 0 ;
7817 PyObject * obj1 = 0 ;
7818 char *kwnames[] = {
7819 (char *) "self",(char *) "c", NULL
7820 };
7821
7822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7824 if (SWIG_arg_fail(1)) SWIG_fail;
7825 {
7826 arg2 = (char)(SWIG_As_char(obj1));
7827 if (SWIG_arg_fail(2)) SWIG_fail;
7828 }
7829 {
7830 PyThreadState* __tstate = wxPyBeginAllowThreads();
7831 result = (bool)(arg1)->Ungetch(arg2);
7832
7833 wxPyEndAllowThreads(__tstate);
7834 if (PyErr_Occurred()) SWIG_fail;
7835 }
7836 {
7837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7838 }
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7846 PyObject *resultobj;
7847 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7848 long arg2 ;
7849 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7850 long result;
7851 PyObject * obj0 = 0 ;
7852 PyObject * obj1 = 0 ;
7853 PyObject * obj2 = 0 ;
7854 char *kwnames[] = {
7855 (char *) "self",(char *) "pos",(char *) "mode", NULL
7856 };
7857
7858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7860 if (SWIG_arg_fail(1)) SWIG_fail;
7861 {
7862 arg2 = (long)(SWIG_As_long(obj1));
7863 if (SWIG_arg_fail(2)) SWIG_fail;
7864 }
7865 if (obj2) {
7866 {
7867 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7868 if (SWIG_arg_fail(3)) SWIG_fail;
7869 }
7870 }
7871 {
7872 PyThreadState* __tstate = wxPyBeginAllowThreads();
7873 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7874
7875 wxPyEndAllowThreads(__tstate);
7876 if (PyErr_Occurred()) SWIG_fail;
7877 }
7878 {
7879 resultobj = SWIG_From_long((long)(result));
7880 }
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7888 PyObject *resultobj;
7889 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7890 long result;
7891 PyObject * obj0 = 0 ;
7892 char *kwnames[] = {
7893 (char *) "self", NULL
7894 };
7895
7896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7898 if (SWIG_arg_fail(1)) SWIG_fail;
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 result = (long)(arg1)->TellI();
7902
7903 wxPyEndAllowThreads(__tstate);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 {
7907 resultobj = SWIG_From_long((long)(result));
7908 }
7909 return resultobj;
7910 fail:
7911 return NULL;
7912 }
7913
7914
7915 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7916 PyObject *obj;
7917 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7918 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7919 Py_INCREF(obj);
7920 return Py_BuildValue((char *)"");
7921 }
7922 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7923 PyObject *resultobj;
7924 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7925 PyObject *arg2 = (PyObject *) 0 ;
7926 PyObject * obj0 = 0 ;
7927 PyObject * obj1 = 0 ;
7928 char *kwnames[] = {
7929 (char *) "self",(char *) "obj", NULL
7930 };
7931
7932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7934 if (SWIG_arg_fail(1)) SWIG_fail;
7935 arg2 = obj1;
7936 {
7937 PyThreadState* __tstate = wxPyBeginAllowThreads();
7938 wxOutputStream_write(arg1,arg2);
7939
7940 wxPyEndAllowThreads(__tstate);
7941 if (PyErr_Occurred()) SWIG_fail;
7942 }
7943 Py_INCREF(Py_None); resultobj = Py_None;
7944 return resultobj;
7945 fail:
7946 return NULL;
7947 }
7948
7949
7950 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7951 PyObject *obj;
7952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7953 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7954 Py_INCREF(obj);
7955 return Py_BuildValue((char *)"");
7956 }
7957 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7958 PyObject *resultobj;
7959 wxInputStream *arg1 = (wxInputStream *) 0 ;
7960 wxString *arg2 = 0 ;
7961 wxString *arg3 = 0 ;
7962 wxString *arg4 = 0 ;
7963 wxDateTime arg5 ;
7964 wxFSFile *result;
7965 wxPyInputStream *temp1 ;
7966 bool temp2 = false ;
7967 bool temp3 = false ;
7968 bool temp4 = false ;
7969 PyObject * obj0 = 0 ;
7970 PyObject * obj1 = 0 ;
7971 PyObject * obj2 = 0 ;
7972 PyObject * obj3 = 0 ;
7973 PyObject * obj4 = 0 ;
7974 char *kwnames[] = {
7975 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7976 };
7977
7978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7979 {
7980 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7981 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7982 } else {
7983 PyErr_Clear(); // clear the failure of the wxPyConvert above
7984 arg1 = wxPyCBInputStream_create(obj0, true);
7985 if (arg1 == NULL) {
7986 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7987 SWIG_fail;
7988 }
7989 }
7990 }
7991 {
7992 arg2 = wxString_in_helper(obj1);
7993 if (arg2 == NULL) SWIG_fail;
7994 temp2 = true;
7995 }
7996 {
7997 arg3 = wxString_in_helper(obj2);
7998 if (arg3 == NULL) SWIG_fail;
7999 temp3 = true;
8000 }
8001 {
8002 arg4 = wxString_in_helper(obj3);
8003 if (arg4 == NULL) SWIG_fail;
8004 temp4 = true;
8005 }
8006 {
8007 wxDateTime * argp;
8008 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8009 if (SWIG_arg_fail(5)) SWIG_fail;
8010 if (argp == NULL) {
8011 SWIG_null_ref("wxDateTime");
8012 }
8013 if (SWIG_arg_fail(5)) SWIG_fail;
8014 arg5 = *argp;
8015 }
8016 {
8017 PyThreadState* __tstate = wxPyBeginAllowThreads();
8018 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8019
8020 wxPyEndAllowThreads(__tstate);
8021 if (PyErr_Occurred()) SWIG_fail;
8022 }
8023 {
8024 resultobj = wxPyMake_wxObject(result, 1);
8025 }
8026 {
8027 if (temp2)
8028 delete arg2;
8029 }
8030 {
8031 if (temp3)
8032 delete arg3;
8033 }
8034 {
8035 if (temp4)
8036 delete arg4;
8037 }
8038 return resultobj;
8039 fail:
8040 {
8041 if (temp2)
8042 delete arg2;
8043 }
8044 {
8045 if (temp3)
8046 delete arg3;
8047 }
8048 {
8049 if (temp4)
8050 delete arg4;
8051 }
8052 return NULL;
8053 }
8054
8055
8056 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8057 PyObject *resultobj;
8058 wxFSFile *arg1 = (wxFSFile *) 0 ;
8059 PyObject * obj0 = 0 ;
8060 char *kwnames[] = {
8061 (char *) "self", NULL
8062 };
8063
8064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8066 if (SWIG_arg_fail(1)) SWIG_fail;
8067 {
8068 PyThreadState* __tstate = wxPyBeginAllowThreads();
8069 delete arg1;
8070
8071 wxPyEndAllowThreads(__tstate);
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 Py_INCREF(Py_None); resultobj = Py_None;
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8082 PyObject *resultobj;
8083 wxFSFile *arg1 = (wxFSFile *) 0 ;
8084 wxInputStream *result;
8085 PyObject * obj0 = 0 ;
8086 char *kwnames[] = {
8087 (char *) "self", NULL
8088 };
8089
8090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8092 if (SWIG_arg_fail(1)) SWIG_fail;
8093 {
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 result = (wxInputStream *)(arg1)->GetStream();
8096
8097 wxPyEndAllowThreads(__tstate);
8098 if (PyErr_Occurred()) SWIG_fail;
8099 }
8100 {
8101 wxPyInputStream * _ptr = NULL;
8102
8103 if (result) {
8104 _ptr = new wxPyInputStream(result);
8105 }
8106 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8107 }
8108 return resultobj;
8109 fail:
8110 return NULL;
8111 }
8112
8113
8114 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8115 PyObject *resultobj;
8116 wxFSFile *arg1 = (wxFSFile *) 0 ;
8117 wxString *result;
8118 PyObject * obj0 = 0 ;
8119 char *kwnames[] = {
8120 (char *) "self", NULL
8121 };
8122
8123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8125 if (SWIG_arg_fail(1)) SWIG_fail;
8126 {
8127 PyThreadState* __tstate = wxPyBeginAllowThreads();
8128 {
8129 wxString const &_result_ref = (arg1)->GetMimeType();
8130 result = (wxString *) &_result_ref;
8131 }
8132
8133 wxPyEndAllowThreads(__tstate);
8134 if (PyErr_Occurred()) SWIG_fail;
8135 }
8136 {
8137 #if wxUSE_UNICODE
8138 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8139 #else
8140 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8141 #endif
8142 }
8143 return resultobj;
8144 fail:
8145 return NULL;
8146 }
8147
8148
8149 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8150 PyObject *resultobj;
8151 wxFSFile *arg1 = (wxFSFile *) 0 ;
8152 wxString *result;
8153 PyObject * obj0 = 0 ;
8154 char *kwnames[] = {
8155 (char *) "self", NULL
8156 };
8157
8158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8160 if (SWIG_arg_fail(1)) SWIG_fail;
8161 {
8162 PyThreadState* __tstate = wxPyBeginAllowThreads();
8163 {
8164 wxString const &_result_ref = (arg1)->GetLocation();
8165 result = (wxString *) &_result_ref;
8166 }
8167
8168 wxPyEndAllowThreads(__tstate);
8169 if (PyErr_Occurred()) SWIG_fail;
8170 }
8171 {
8172 #if wxUSE_UNICODE
8173 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8174 #else
8175 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8176 #endif
8177 }
8178 return resultobj;
8179 fail:
8180 return NULL;
8181 }
8182
8183
8184 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8185 PyObject *resultobj;
8186 wxFSFile *arg1 = (wxFSFile *) 0 ;
8187 wxString *result;
8188 PyObject * obj0 = 0 ;
8189 char *kwnames[] = {
8190 (char *) "self", NULL
8191 };
8192
8193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8195 if (SWIG_arg_fail(1)) SWIG_fail;
8196 {
8197 PyThreadState* __tstate = wxPyBeginAllowThreads();
8198 {
8199 wxString const &_result_ref = (arg1)->GetAnchor();
8200 result = (wxString *) &_result_ref;
8201 }
8202
8203 wxPyEndAllowThreads(__tstate);
8204 if (PyErr_Occurred()) SWIG_fail;
8205 }
8206 {
8207 #if wxUSE_UNICODE
8208 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8209 #else
8210 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8211 #endif
8212 }
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8220 PyObject *resultobj;
8221 wxFSFile *arg1 = (wxFSFile *) 0 ;
8222 wxDateTime result;
8223 PyObject * obj0 = 0 ;
8224 char *kwnames[] = {
8225 (char *) "self", NULL
8226 };
8227
8228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8230 if (SWIG_arg_fail(1)) SWIG_fail;
8231 {
8232 PyThreadState* __tstate = wxPyBeginAllowThreads();
8233 result = (arg1)->GetModificationTime();
8234
8235 wxPyEndAllowThreads(__tstate);
8236 if (PyErr_Occurred()) SWIG_fail;
8237 }
8238 {
8239 wxDateTime * resultptr;
8240 resultptr = new wxDateTime((wxDateTime &)(result));
8241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8242 }
8243 return resultobj;
8244 fail:
8245 return NULL;
8246 }
8247
8248
8249 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8250 PyObject *obj;
8251 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8252 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8253 Py_INCREF(obj);
8254 return Py_BuildValue((char *)"");
8255 }
8256 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8257 PyObject *obj;
8258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8259 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8260 Py_INCREF(obj);
8261 return Py_BuildValue((char *)"");
8262 }
8263 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj;
8265 wxPyFileSystemHandler *result;
8266 char *kwnames[] = {
8267 NULL
8268 };
8269
8270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8271 {
8272 PyThreadState* __tstate = wxPyBeginAllowThreads();
8273 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8274
8275 wxPyEndAllowThreads(__tstate);
8276 if (PyErr_Occurred()) SWIG_fail;
8277 }
8278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8279 return resultobj;
8280 fail:
8281 return NULL;
8282 }
8283
8284
8285 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8286 PyObject *resultobj;
8287 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8288 PyObject *arg2 = (PyObject *) 0 ;
8289 PyObject *arg3 = (PyObject *) 0 ;
8290 PyObject * obj0 = 0 ;
8291 PyObject * obj1 = 0 ;
8292 PyObject * obj2 = 0 ;
8293 char *kwnames[] = {
8294 (char *) "self",(char *) "self",(char *) "_class", NULL
8295 };
8296
8297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8299 if (SWIG_arg_fail(1)) SWIG_fail;
8300 arg2 = obj1;
8301 arg3 = obj2;
8302 {
8303 PyThreadState* __tstate = wxPyBeginAllowThreads();
8304 (arg1)->_setCallbackInfo(arg2,arg3);
8305
8306 wxPyEndAllowThreads(__tstate);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 Py_INCREF(Py_None); resultobj = Py_None;
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8317 PyObject *resultobj;
8318 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8319 wxString *arg2 = 0 ;
8320 bool result;
8321 bool temp2 = false ;
8322 PyObject * obj0 = 0 ;
8323 PyObject * obj1 = 0 ;
8324 char *kwnames[] = {
8325 (char *) "self",(char *) "location", NULL
8326 };
8327
8328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8330 if (SWIG_arg_fail(1)) SWIG_fail;
8331 {
8332 arg2 = wxString_in_helper(obj1);
8333 if (arg2 == NULL) SWIG_fail;
8334 temp2 = true;
8335 }
8336 {
8337 PyThreadState* __tstate = wxPyBeginAllowThreads();
8338 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8339
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 {
8344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8345 }
8346 {
8347 if (temp2)
8348 delete arg2;
8349 }
8350 return resultobj;
8351 fail:
8352 {
8353 if (temp2)
8354 delete arg2;
8355 }
8356 return NULL;
8357 }
8358
8359
8360 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj;
8362 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8363 wxFileSystem *arg2 = 0 ;
8364 wxString *arg3 = 0 ;
8365 wxFSFile *result;
8366 bool temp3 = false ;
8367 PyObject * obj0 = 0 ;
8368 PyObject * obj1 = 0 ;
8369 PyObject * obj2 = 0 ;
8370 char *kwnames[] = {
8371 (char *) "self",(char *) "fs",(char *) "location", NULL
8372 };
8373
8374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8376 if (SWIG_arg_fail(1)) SWIG_fail;
8377 {
8378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8379 if (SWIG_arg_fail(2)) SWIG_fail;
8380 if (arg2 == NULL) {
8381 SWIG_null_ref("wxFileSystem");
8382 }
8383 if (SWIG_arg_fail(2)) SWIG_fail;
8384 }
8385 {
8386 arg3 = wxString_in_helper(obj2);
8387 if (arg3 == NULL) SWIG_fail;
8388 temp3 = true;
8389 }
8390 {
8391 PyThreadState* __tstate = wxPyBeginAllowThreads();
8392 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8393
8394 wxPyEndAllowThreads(__tstate);
8395 if (PyErr_Occurred()) SWIG_fail;
8396 }
8397 {
8398 resultobj = wxPyMake_wxObject(result, 1);
8399 }
8400 {
8401 if (temp3)
8402 delete arg3;
8403 }
8404 return resultobj;
8405 fail:
8406 {
8407 if (temp3)
8408 delete arg3;
8409 }
8410 return NULL;
8411 }
8412
8413
8414 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8415 PyObject *resultobj;
8416 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8417 wxString *arg2 = 0 ;
8418 int arg3 = (int) 0 ;
8419 wxString result;
8420 bool temp2 = false ;
8421 PyObject * obj0 = 0 ;
8422 PyObject * obj1 = 0 ;
8423 PyObject * obj2 = 0 ;
8424 char *kwnames[] = {
8425 (char *) "self",(char *) "spec",(char *) "flags", NULL
8426 };
8427
8428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8430 if (SWIG_arg_fail(1)) SWIG_fail;
8431 {
8432 arg2 = wxString_in_helper(obj1);
8433 if (arg2 == NULL) SWIG_fail;
8434 temp2 = true;
8435 }
8436 if (obj2) {
8437 {
8438 arg3 = (int)(SWIG_As_int(obj2));
8439 if (SWIG_arg_fail(3)) SWIG_fail;
8440 }
8441 }
8442 {
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8445
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 {
8450 #if wxUSE_UNICODE
8451 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8452 #else
8453 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8454 #endif
8455 }
8456 {
8457 if (temp2)
8458 delete arg2;
8459 }
8460 return resultobj;
8461 fail:
8462 {
8463 if (temp2)
8464 delete arg2;
8465 }
8466 return NULL;
8467 }
8468
8469
8470 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8471 PyObject *resultobj;
8472 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8473 wxString result;
8474 PyObject * obj0 = 0 ;
8475 char *kwnames[] = {
8476 (char *) "self", NULL
8477 };
8478
8479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8481 if (SWIG_arg_fail(1)) SWIG_fail;
8482 {
8483 PyThreadState* __tstate = wxPyBeginAllowThreads();
8484 result = (arg1)->FindNext();
8485
8486 wxPyEndAllowThreads(__tstate);
8487 if (PyErr_Occurred()) SWIG_fail;
8488 }
8489 {
8490 #if wxUSE_UNICODE
8491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8492 #else
8493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8494 #endif
8495 }
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8503 PyObject *resultobj;
8504 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8505 wxString *arg2 = 0 ;
8506 wxString result;
8507 bool temp2 = false ;
8508 PyObject * obj0 = 0 ;
8509 PyObject * obj1 = 0 ;
8510 char *kwnames[] = {
8511 (char *) "self",(char *) "location", NULL
8512 };
8513
8514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8516 if (SWIG_arg_fail(1)) SWIG_fail;
8517 {
8518 arg2 = wxString_in_helper(obj1);
8519 if (arg2 == NULL) SWIG_fail;
8520 temp2 = true;
8521 }
8522 {
8523 PyThreadState* __tstate = wxPyBeginAllowThreads();
8524 result = (arg1)->GetProtocol((wxString const &)*arg2);
8525
8526 wxPyEndAllowThreads(__tstate);
8527 if (PyErr_Occurred()) SWIG_fail;
8528 }
8529 {
8530 #if wxUSE_UNICODE
8531 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8532 #else
8533 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8534 #endif
8535 }
8536 {
8537 if (temp2)
8538 delete arg2;
8539 }
8540 return resultobj;
8541 fail:
8542 {
8543 if (temp2)
8544 delete arg2;
8545 }
8546 return NULL;
8547 }
8548
8549
8550 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8551 PyObject *resultobj;
8552 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8553 wxString *arg2 = 0 ;
8554 wxString result;
8555 bool temp2 = false ;
8556 PyObject * obj0 = 0 ;
8557 PyObject * obj1 = 0 ;
8558 char *kwnames[] = {
8559 (char *) "self",(char *) "location", NULL
8560 };
8561
8562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8564 if (SWIG_arg_fail(1)) SWIG_fail;
8565 {
8566 arg2 = wxString_in_helper(obj1);
8567 if (arg2 == NULL) SWIG_fail;
8568 temp2 = true;
8569 }
8570 {
8571 PyThreadState* __tstate = wxPyBeginAllowThreads();
8572 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8573
8574 wxPyEndAllowThreads(__tstate);
8575 if (PyErr_Occurred()) SWIG_fail;
8576 }
8577 {
8578 #if wxUSE_UNICODE
8579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8580 #else
8581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8582 #endif
8583 }
8584 {
8585 if (temp2)
8586 delete arg2;
8587 }
8588 return resultobj;
8589 fail:
8590 {
8591 if (temp2)
8592 delete arg2;
8593 }
8594 return NULL;
8595 }
8596
8597
8598 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj;
8600 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8601 wxString *arg2 = 0 ;
8602 wxString result;
8603 bool temp2 = false ;
8604 PyObject * obj0 = 0 ;
8605 PyObject * obj1 = 0 ;
8606 char *kwnames[] = {
8607 (char *) "self",(char *) "location", NULL
8608 };
8609
8610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8612 if (SWIG_arg_fail(1)) SWIG_fail;
8613 {
8614 arg2 = wxString_in_helper(obj1);
8615 if (arg2 == NULL) SWIG_fail;
8616 temp2 = true;
8617 }
8618 {
8619 PyThreadState* __tstate = wxPyBeginAllowThreads();
8620 result = (arg1)->GetAnchor((wxString const &)*arg2);
8621
8622 wxPyEndAllowThreads(__tstate);
8623 if (PyErr_Occurred()) SWIG_fail;
8624 }
8625 {
8626 #if wxUSE_UNICODE
8627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8628 #else
8629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8630 #endif
8631 }
8632 {
8633 if (temp2)
8634 delete arg2;
8635 }
8636 return resultobj;
8637 fail:
8638 {
8639 if (temp2)
8640 delete arg2;
8641 }
8642 return NULL;
8643 }
8644
8645
8646 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8647 PyObject *resultobj;
8648 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8649 wxString *arg2 = 0 ;
8650 wxString result;
8651 bool temp2 = false ;
8652 PyObject * obj0 = 0 ;
8653 PyObject * obj1 = 0 ;
8654 char *kwnames[] = {
8655 (char *) "self",(char *) "location", NULL
8656 };
8657
8658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8660 if (SWIG_arg_fail(1)) SWIG_fail;
8661 {
8662 arg2 = wxString_in_helper(obj1);
8663 if (arg2 == NULL) SWIG_fail;
8664 temp2 = true;
8665 }
8666 {
8667 PyThreadState* __tstate = wxPyBeginAllowThreads();
8668 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8669
8670 wxPyEndAllowThreads(__tstate);
8671 if (PyErr_Occurred()) SWIG_fail;
8672 }
8673 {
8674 #if wxUSE_UNICODE
8675 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8676 #else
8677 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8678 #endif
8679 }
8680 {
8681 if (temp2)
8682 delete arg2;
8683 }
8684 return resultobj;
8685 fail:
8686 {
8687 if (temp2)
8688 delete arg2;
8689 }
8690 return NULL;
8691 }
8692
8693
8694 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj;
8696 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8697 wxString *arg2 = 0 ;
8698 wxString result;
8699 bool temp2 = false ;
8700 PyObject * obj0 = 0 ;
8701 PyObject * obj1 = 0 ;
8702 char *kwnames[] = {
8703 (char *) "self",(char *) "location", NULL
8704 };
8705
8706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8708 if (SWIG_arg_fail(1)) SWIG_fail;
8709 {
8710 arg2 = wxString_in_helper(obj1);
8711 if (arg2 == NULL) SWIG_fail;
8712 temp2 = true;
8713 }
8714 {
8715 PyThreadState* __tstate = wxPyBeginAllowThreads();
8716 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8717
8718 wxPyEndAllowThreads(__tstate);
8719 if (PyErr_Occurred()) SWIG_fail;
8720 }
8721 {
8722 #if wxUSE_UNICODE
8723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8724 #else
8725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8726 #endif
8727 }
8728 {
8729 if (temp2)
8730 delete arg2;
8731 }
8732 return resultobj;
8733 fail:
8734 {
8735 if (temp2)
8736 delete arg2;
8737 }
8738 return NULL;
8739 }
8740
8741
8742 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8743 PyObject *obj;
8744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8745 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8746 Py_INCREF(obj);
8747 return Py_BuildValue((char *)"");
8748 }
8749 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8750 PyObject *resultobj;
8751 wxFileSystem *result;
8752 char *kwnames[] = {
8753 NULL
8754 };
8755
8756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8757 {
8758 PyThreadState* __tstate = wxPyBeginAllowThreads();
8759 result = (wxFileSystem *)new wxFileSystem();
8760
8761 wxPyEndAllowThreads(__tstate);
8762 if (PyErr_Occurred()) SWIG_fail;
8763 }
8764 {
8765 resultobj = wxPyMake_wxObject(result, 1);
8766 }
8767 return resultobj;
8768 fail:
8769 return NULL;
8770 }
8771
8772
8773 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8774 PyObject *resultobj;
8775 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8776 PyObject * obj0 = 0 ;
8777 char *kwnames[] = {
8778 (char *) "self", NULL
8779 };
8780
8781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8783 if (SWIG_arg_fail(1)) SWIG_fail;
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 delete arg1;
8787
8788 wxPyEndAllowThreads(__tstate);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 Py_INCREF(Py_None); resultobj = Py_None;
8792 return resultobj;
8793 fail:
8794 return NULL;
8795 }
8796
8797
8798 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8799 PyObject *resultobj;
8800 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8801 wxString *arg2 = 0 ;
8802 bool arg3 = (bool) false ;
8803 bool temp2 = false ;
8804 PyObject * obj0 = 0 ;
8805 PyObject * obj1 = 0 ;
8806 PyObject * obj2 = 0 ;
8807 char *kwnames[] = {
8808 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8809 };
8810
8811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8813 if (SWIG_arg_fail(1)) SWIG_fail;
8814 {
8815 arg2 = wxString_in_helper(obj1);
8816 if (arg2 == NULL) SWIG_fail;
8817 temp2 = true;
8818 }
8819 if (obj2) {
8820 {
8821 arg3 = (bool)(SWIG_As_bool(obj2));
8822 if (SWIG_arg_fail(3)) SWIG_fail;
8823 }
8824 }
8825 {
8826 PyThreadState* __tstate = wxPyBeginAllowThreads();
8827 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8828
8829 wxPyEndAllowThreads(__tstate);
8830 if (PyErr_Occurred()) SWIG_fail;
8831 }
8832 Py_INCREF(Py_None); resultobj = Py_None;
8833 {
8834 if (temp2)
8835 delete arg2;
8836 }
8837 return resultobj;
8838 fail:
8839 {
8840 if (temp2)
8841 delete arg2;
8842 }
8843 return NULL;
8844 }
8845
8846
8847 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8848 PyObject *resultobj;
8849 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8850 wxString result;
8851 PyObject * obj0 = 0 ;
8852 char *kwnames[] = {
8853 (char *) "self", NULL
8854 };
8855
8856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8858 if (SWIG_arg_fail(1)) SWIG_fail;
8859 {
8860 PyThreadState* __tstate = wxPyBeginAllowThreads();
8861 result = (arg1)->GetPath();
8862
8863 wxPyEndAllowThreads(__tstate);
8864 if (PyErr_Occurred()) SWIG_fail;
8865 }
8866 {
8867 #if wxUSE_UNICODE
8868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8869 #else
8870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8871 #endif
8872 }
8873 return resultobj;
8874 fail:
8875 return NULL;
8876 }
8877
8878
8879 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8880 PyObject *resultobj;
8881 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8882 wxString *arg2 = 0 ;
8883 wxFSFile *result;
8884 bool temp2 = false ;
8885 PyObject * obj0 = 0 ;
8886 PyObject * obj1 = 0 ;
8887 char *kwnames[] = {
8888 (char *) "self",(char *) "location", NULL
8889 };
8890
8891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8893 if (SWIG_arg_fail(1)) SWIG_fail;
8894 {
8895 arg2 = wxString_in_helper(obj1);
8896 if (arg2 == NULL) SWIG_fail;
8897 temp2 = true;
8898 }
8899 {
8900 PyThreadState* __tstate = wxPyBeginAllowThreads();
8901 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8902
8903 wxPyEndAllowThreads(__tstate);
8904 if (PyErr_Occurred()) SWIG_fail;
8905 }
8906 {
8907 resultobj = wxPyMake_wxObject(result, 1);
8908 }
8909 {
8910 if (temp2)
8911 delete arg2;
8912 }
8913 return resultobj;
8914 fail:
8915 {
8916 if (temp2)
8917 delete arg2;
8918 }
8919 return NULL;
8920 }
8921
8922
8923 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8924 PyObject *resultobj;
8925 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8926 wxString *arg2 = 0 ;
8927 int arg3 = (int) 0 ;
8928 wxString result;
8929 bool temp2 = false ;
8930 PyObject * obj0 = 0 ;
8931 PyObject * obj1 = 0 ;
8932 PyObject * obj2 = 0 ;
8933 char *kwnames[] = {
8934 (char *) "self",(char *) "spec",(char *) "flags", NULL
8935 };
8936
8937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8939 if (SWIG_arg_fail(1)) SWIG_fail;
8940 {
8941 arg2 = wxString_in_helper(obj1);
8942 if (arg2 == NULL) SWIG_fail;
8943 temp2 = true;
8944 }
8945 if (obj2) {
8946 {
8947 arg3 = (int)(SWIG_As_int(obj2));
8948 if (SWIG_arg_fail(3)) SWIG_fail;
8949 }
8950 }
8951 {
8952 PyThreadState* __tstate = wxPyBeginAllowThreads();
8953 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8954
8955 wxPyEndAllowThreads(__tstate);
8956 if (PyErr_Occurred()) SWIG_fail;
8957 }
8958 {
8959 #if wxUSE_UNICODE
8960 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8961 #else
8962 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8963 #endif
8964 }
8965 {
8966 if (temp2)
8967 delete arg2;
8968 }
8969 return resultobj;
8970 fail:
8971 {
8972 if (temp2)
8973 delete arg2;
8974 }
8975 return NULL;
8976 }
8977
8978
8979 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8980 PyObject *resultobj;
8981 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8982 wxString result;
8983 PyObject * obj0 = 0 ;
8984 char *kwnames[] = {
8985 (char *) "self", NULL
8986 };
8987
8988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8990 if (SWIG_arg_fail(1)) SWIG_fail;
8991 {
8992 PyThreadState* __tstate = wxPyBeginAllowThreads();
8993 result = (arg1)->FindNext();
8994
8995 wxPyEndAllowThreads(__tstate);
8996 if (PyErr_Occurred()) SWIG_fail;
8997 }
8998 {
8999 #if wxUSE_UNICODE
9000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9001 #else
9002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9003 #endif
9004 }
9005 return resultobj;
9006 fail:
9007 return NULL;
9008 }
9009
9010
9011 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9012 PyObject *resultobj;
9013 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9014 PyObject * obj0 = 0 ;
9015 char *kwnames[] = {
9016 (char *) "handler", NULL
9017 };
9018
9019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9021 if (SWIG_arg_fail(1)) SWIG_fail;
9022 {
9023 PyThreadState* __tstate = wxPyBeginAllowThreads();
9024 wxFileSystem::AddHandler(arg1);
9025
9026 wxPyEndAllowThreads(__tstate);
9027 if (PyErr_Occurred()) SWIG_fail;
9028 }
9029 Py_INCREF(Py_None); resultobj = Py_None;
9030 return resultobj;
9031 fail:
9032 return NULL;
9033 }
9034
9035
9036 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9037 PyObject *resultobj;
9038 char *kwnames[] = {
9039 NULL
9040 };
9041
9042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9043 {
9044 PyThreadState* __tstate = wxPyBeginAllowThreads();
9045 wxFileSystem::CleanUpHandlers();
9046
9047 wxPyEndAllowThreads(__tstate);
9048 if (PyErr_Occurred()) SWIG_fail;
9049 }
9050 Py_INCREF(Py_None); resultobj = Py_None;
9051 return resultobj;
9052 fail:
9053 return NULL;
9054 }
9055
9056
9057 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9058 PyObject *resultobj;
9059 wxString *arg1 = 0 ;
9060 wxString result;
9061 bool temp1 = false ;
9062 PyObject * obj0 = 0 ;
9063 char *kwnames[] = {
9064 (char *) "filename", NULL
9065 };
9066
9067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9068 {
9069 arg1 = wxString_in_helper(obj0);
9070 if (arg1 == NULL) SWIG_fail;
9071 temp1 = true;
9072 }
9073 {
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9076
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 {
9081 #if wxUSE_UNICODE
9082 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9083 #else
9084 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9085 #endif
9086 }
9087 {
9088 if (temp1)
9089 delete arg1;
9090 }
9091 return resultobj;
9092 fail:
9093 {
9094 if (temp1)
9095 delete arg1;
9096 }
9097 return NULL;
9098 }
9099
9100
9101 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9102 PyObject *resultobj;
9103 wxString *arg1 = 0 ;
9104 wxString result;
9105 bool temp1 = false ;
9106 PyObject * obj0 = 0 ;
9107 char *kwnames[] = {
9108 (char *) "url", NULL
9109 };
9110
9111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9112 {
9113 arg1 = wxString_in_helper(obj0);
9114 if (arg1 == NULL) SWIG_fail;
9115 temp1 = true;
9116 }
9117 {
9118 PyThreadState* __tstate = wxPyBeginAllowThreads();
9119 result = FileSystem_URLToFileName((wxString const &)*arg1);
9120
9121 wxPyEndAllowThreads(__tstate);
9122 if (PyErr_Occurred()) SWIG_fail;
9123 }
9124 {
9125 #if wxUSE_UNICODE
9126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9127 #else
9128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9129 #endif
9130 }
9131 {
9132 if (temp1)
9133 delete arg1;
9134 }
9135 return resultobj;
9136 fail:
9137 {
9138 if (temp1)
9139 delete arg1;
9140 }
9141 return NULL;
9142 }
9143
9144
9145 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9146 PyObject *obj;
9147 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9148 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9149 Py_INCREF(obj);
9150 return Py_BuildValue((char *)"");
9151 }
9152 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9153 PyObject *resultobj;
9154 wxInternetFSHandler *result;
9155 char *kwnames[] = {
9156 NULL
9157 };
9158
9159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9160 {
9161 PyThreadState* __tstate = wxPyBeginAllowThreads();
9162 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9163
9164 wxPyEndAllowThreads(__tstate);
9165 if (PyErr_Occurred()) SWIG_fail;
9166 }
9167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9168 return resultobj;
9169 fail:
9170 return NULL;
9171 }
9172
9173
9174 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9175 PyObject *resultobj;
9176 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9177 wxString *arg2 = 0 ;
9178 bool result;
9179 bool temp2 = false ;
9180 PyObject * obj0 = 0 ;
9181 PyObject * obj1 = 0 ;
9182 char *kwnames[] = {
9183 (char *) "self",(char *) "location", NULL
9184 };
9185
9186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9188 if (SWIG_arg_fail(1)) SWIG_fail;
9189 {
9190 arg2 = wxString_in_helper(obj1);
9191 if (arg2 == NULL) SWIG_fail;
9192 temp2 = true;
9193 }
9194 {
9195 PyThreadState* __tstate = wxPyBeginAllowThreads();
9196 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9197
9198 wxPyEndAllowThreads(__tstate);
9199 if (PyErr_Occurred()) SWIG_fail;
9200 }
9201 {
9202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9203 }
9204 {
9205 if (temp2)
9206 delete arg2;
9207 }
9208 return resultobj;
9209 fail:
9210 {
9211 if (temp2)
9212 delete arg2;
9213 }
9214 return NULL;
9215 }
9216
9217
9218 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9219 PyObject *resultobj;
9220 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9221 wxFileSystem *arg2 = 0 ;
9222 wxString *arg3 = 0 ;
9223 wxFSFile *result;
9224 bool temp3 = false ;
9225 PyObject * obj0 = 0 ;
9226 PyObject * obj1 = 0 ;
9227 PyObject * obj2 = 0 ;
9228 char *kwnames[] = {
9229 (char *) "self",(char *) "fs",(char *) "location", NULL
9230 };
9231
9232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9234 if (SWIG_arg_fail(1)) SWIG_fail;
9235 {
9236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9237 if (SWIG_arg_fail(2)) SWIG_fail;
9238 if (arg2 == NULL) {
9239 SWIG_null_ref("wxFileSystem");
9240 }
9241 if (SWIG_arg_fail(2)) SWIG_fail;
9242 }
9243 {
9244 arg3 = wxString_in_helper(obj2);
9245 if (arg3 == NULL) SWIG_fail;
9246 temp3 = true;
9247 }
9248 {
9249 PyThreadState* __tstate = wxPyBeginAllowThreads();
9250 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9251
9252 wxPyEndAllowThreads(__tstate);
9253 if (PyErr_Occurred()) SWIG_fail;
9254 }
9255 {
9256 resultobj = wxPyMake_wxObject(result, 1);
9257 }
9258 {
9259 if (temp3)
9260 delete arg3;
9261 }
9262 return resultobj;
9263 fail:
9264 {
9265 if (temp3)
9266 delete arg3;
9267 }
9268 return NULL;
9269 }
9270
9271
9272 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9273 PyObject *obj;
9274 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9275 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9276 Py_INCREF(obj);
9277 return Py_BuildValue((char *)"");
9278 }
9279 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9280 PyObject *resultobj;
9281 wxZipFSHandler *result;
9282 char *kwnames[] = {
9283 NULL
9284 };
9285
9286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9287 {
9288 PyThreadState* __tstate = wxPyBeginAllowThreads();
9289 result = (wxZipFSHandler *)new wxZipFSHandler();
9290
9291 wxPyEndAllowThreads(__tstate);
9292 if (PyErr_Occurred()) SWIG_fail;
9293 }
9294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9295 return resultobj;
9296 fail:
9297 return NULL;
9298 }
9299
9300
9301 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9302 PyObject *resultobj;
9303 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9304 wxString *arg2 = 0 ;
9305 bool result;
9306 bool temp2 = false ;
9307 PyObject * obj0 = 0 ;
9308 PyObject * obj1 = 0 ;
9309 char *kwnames[] = {
9310 (char *) "self",(char *) "location", NULL
9311 };
9312
9313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9315 if (SWIG_arg_fail(1)) SWIG_fail;
9316 {
9317 arg2 = wxString_in_helper(obj1);
9318 if (arg2 == NULL) SWIG_fail;
9319 temp2 = true;
9320 }
9321 {
9322 PyThreadState* __tstate = wxPyBeginAllowThreads();
9323 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9324
9325 wxPyEndAllowThreads(__tstate);
9326 if (PyErr_Occurred()) SWIG_fail;
9327 }
9328 {
9329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9330 }
9331 {
9332 if (temp2)
9333 delete arg2;
9334 }
9335 return resultobj;
9336 fail:
9337 {
9338 if (temp2)
9339 delete arg2;
9340 }
9341 return NULL;
9342 }
9343
9344
9345 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9346 PyObject *resultobj;
9347 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9348 wxFileSystem *arg2 = 0 ;
9349 wxString *arg3 = 0 ;
9350 wxFSFile *result;
9351 bool temp3 = false ;
9352 PyObject * obj0 = 0 ;
9353 PyObject * obj1 = 0 ;
9354 PyObject * obj2 = 0 ;
9355 char *kwnames[] = {
9356 (char *) "self",(char *) "fs",(char *) "location", NULL
9357 };
9358
9359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9361 if (SWIG_arg_fail(1)) SWIG_fail;
9362 {
9363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9364 if (SWIG_arg_fail(2)) SWIG_fail;
9365 if (arg2 == NULL) {
9366 SWIG_null_ref("wxFileSystem");
9367 }
9368 if (SWIG_arg_fail(2)) SWIG_fail;
9369 }
9370 {
9371 arg3 = wxString_in_helper(obj2);
9372 if (arg3 == NULL) SWIG_fail;
9373 temp3 = true;
9374 }
9375 {
9376 PyThreadState* __tstate = wxPyBeginAllowThreads();
9377 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9378
9379 wxPyEndAllowThreads(__tstate);
9380 if (PyErr_Occurred()) SWIG_fail;
9381 }
9382 {
9383 resultobj = wxPyMake_wxObject(result, 1);
9384 }
9385 {
9386 if (temp3)
9387 delete arg3;
9388 }
9389 return resultobj;
9390 fail:
9391 {
9392 if (temp3)
9393 delete arg3;
9394 }
9395 return NULL;
9396 }
9397
9398
9399 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9400 PyObject *resultobj;
9401 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9402 wxString *arg2 = 0 ;
9403 int arg3 = (int) 0 ;
9404 wxString result;
9405 bool temp2 = false ;
9406 PyObject * obj0 = 0 ;
9407 PyObject * obj1 = 0 ;
9408 PyObject * obj2 = 0 ;
9409 char *kwnames[] = {
9410 (char *) "self",(char *) "spec",(char *) "flags", NULL
9411 };
9412
9413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9415 if (SWIG_arg_fail(1)) SWIG_fail;
9416 {
9417 arg2 = wxString_in_helper(obj1);
9418 if (arg2 == NULL) SWIG_fail;
9419 temp2 = true;
9420 }
9421 if (obj2) {
9422 {
9423 arg3 = (int)(SWIG_As_int(obj2));
9424 if (SWIG_arg_fail(3)) SWIG_fail;
9425 }
9426 }
9427 {
9428 PyThreadState* __tstate = wxPyBeginAllowThreads();
9429 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9430
9431 wxPyEndAllowThreads(__tstate);
9432 if (PyErr_Occurred()) SWIG_fail;
9433 }
9434 {
9435 #if wxUSE_UNICODE
9436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9437 #else
9438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9439 #endif
9440 }
9441 {
9442 if (temp2)
9443 delete arg2;
9444 }
9445 return resultobj;
9446 fail:
9447 {
9448 if (temp2)
9449 delete arg2;
9450 }
9451 return NULL;
9452 }
9453
9454
9455 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9456 PyObject *resultobj;
9457 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9458 wxString result;
9459 PyObject * obj0 = 0 ;
9460 char *kwnames[] = {
9461 (char *) "self", NULL
9462 };
9463
9464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9466 if (SWIG_arg_fail(1)) SWIG_fail;
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 result = (arg1)->FindNext();
9470
9471 wxPyEndAllowThreads(__tstate);
9472 if (PyErr_Occurred()) SWIG_fail;
9473 }
9474 {
9475 #if wxUSE_UNICODE
9476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9477 #else
9478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9479 #endif
9480 }
9481 return resultobj;
9482 fail:
9483 return NULL;
9484 }
9485
9486
9487 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9488 PyObject *obj;
9489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9490 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9491 Py_INCREF(obj);
9492 return Py_BuildValue((char *)"");
9493 }
9494 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9495 PyObject *resultobj;
9496 wxString *arg1 = 0 ;
9497 wxImage *arg2 = 0 ;
9498 long arg3 ;
9499 bool temp1 = false ;
9500 PyObject * obj0 = 0 ;
9501 PyObject * obj1 = 0 ;
9502 PyObject * obj2 = 0 ;
9503 char *kwnames[] = {
9504 (char *) "filename",(char *) "image",(char *) "type", NULL
9505 };
9506
9507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9508 {
9509 arg1 = wxString_in_helper(obj0);
9510 if (arg1 == NULL) SWIG_fail;
9511 temp1 = true;
9512 }
9513 {
9514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9515 if (SWIG_arg_fail(2)) SWIG_fail;
9516 if (arg2 == NULL) {
9517 SWIG_null_ref("wxImage");
9518 }
9519 if (SWIG_arg_fail(2)) SWIG_fail;
9520 }
9521 {
9522 arg3 = (long)(SWIG_As_long(obj2));
9523 if (SWIG_arg_fail(3)) SWIG_fail;
9524 }
9525 {
9526 PyThreadState* __tstate = wxPyBeginAllowThreads();
9527 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9528
9529 wxPyEndAllowThreads(__tstate);
9530 if (PyErr_Occurred()) SWIG_fail;
9531 }
9532 Py_INCREF(Py_None); resultobj = Py_None;
9533 {
9534 if (temp1)
9535 delete arg1;
9536 }
9537 return resultobj;
9538 fail:
9539 {
9540 if (temp1)
9541 delete arg1;
9542 }
9543 return NULL;
9544 }
9545
9546
9547 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9548 PyObject *resultobj;
9549 wxString *arg1 = 0 ;
9550 wxBitmap *arg2 = 0 ;
9551 long arg3 ;
9552 bool temp1 = false ;
9553 PyObject * obj0 = 0 ;
9554 PyObject * obj1 = 0 ;
9555 PyObject * obj2 = 0 ;
9556 char *kwnames[] = {
9557 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9558 };
9559
9560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9561 {
9562 arg1 = wxString_in_helper(obj0);
9563 if (arg1 == NULL) SWIG_fail;
9564 temp1 = true;
9565 }
9566 {
9567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9568 if (SWIG_arg_fail(2)) SWIG_fail;
9569 if (arg2 == NULL) {
9570 SWIG_null_ref("wxBitmap");
9571 }
9572 if (SWIG_arg_fail(2)) SWIG_fail;
9573 }
9574 {
9575 arg3 = (long)(SWIG_As_long(obj2));
9576 if (SWIG_arg_fail(3)) SWIG_fail;
9577 }
9578 {
9579 PyThreadState* __tstate = wxPyBeginAllowThreads();
9580 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9581
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 Py_INCREF(Py_None); resultobj = Py_None;
9586 {
9587 if (temp1)
9588 delete arg1;
9589 }
9590 return resultobj;
9591 fail:
9592 {
9593 if (temp1)
9594 delete arg1;
9595 }
9596 return NULL;
9597 }
9598
9599
9600 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9601 PyObject *resultobj;
9602 wxString *arg1 = 0 ;
9603 PyObject *arg2 = (PyObject *) 0 ;
9604 bool temp1 = false ;
9605 PyObject * obj0 = 0 ;
9606 PyObject * obj1 = 0 ;
9607 char *kwnames[] = {
9608 (char *) "filename",(char *) "data", NULL
9609 };
9610
9611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9612 {
9613 arg1 = wxString_in_helper(obj0);
9614 if (arg1 == NULL) SWIG_fail;
9615 temp1 = true;
9616 }
9617 arg2 = obj1;
9618 {
9619 PyThreadState* __tstate = wxPyBeginAllowThreads();
9620 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9621
9622 wxPyEndAllowThreads(__tstate);
9623 if (PyErr_Occurred()) SWIG_fail;
9624 }
9625 Py_INCREF(Py_None); resultobj = Py_None;
9626 {
9627 if (temp1)
9628 delete arg1;
9629 }
9630 return resultobj;
9631 fail:
9632 {
9633 if (temp1)
9634 delete arg1;
9635 }
9636 return NULL;
9637 }
9638
9639
9640 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9641 PyObject *resultobj;
9642 wxMemoryFSHandler *result;
9643 char *kwnames[] = {
9644 NULL
9645 };
9646
9647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9648 {
9649 PyThreadState* __tstate = wxPyBeginAllowThreads();
9650 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9651
9652 wxPyEndAllowThreads(__tstate);
9653 if (PyErr_Occurred()) SWIG_fail;
9654 }
9655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9656 return resultobj;
9657 fail:
9658 return NULL;
9659 }
9660
9661
9662 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9663 PyObject *resultobj;
9664 wxString *arg1 = 0 ;
9665 bool temp1 = false ;
9666 PyObject * obj0 = 0 ;
9667 char *kwnames[] = {
9668 (char *) "filename", NULL
9669 };
9670
9671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9672 {
9673 arg1 = wxString_in_helper(obj0);
9674 if (arg1 == NULL) SWIG_fail;
9675 temp1 = true;
9676 }
9677 {
9678 PyThreadState* __tstate = wxPyBeginAllowThreads();
9679 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9680
9681 wxPyEndAllowThreads(__tstate);
9682 if (PyErr_Occurred()) SWIG_fail;
9683 }
9684 Py_INCREF(Py_None); resultobj = Py_None;
9685 {
9686 if (temp1)
9687 delete arg1;
9688 }
9689 return resultobj;
9690 fail:
9691 {
9692 if (temp1)
9693 delete arg1;
9694 }
9695 return NULL;
9696 }
9697
9698
9699 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9700 PyObject *resultobj;
9701 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9702 wxString *arg2 = 0 ;
9703 bool result;
9704 bool temp2 = false ;
9705 PyObject * obj0 = 0 ;
9706 PyObject * obj1 = 0 ;
9707 char *kwnames[] = {
9708 (char *) "self",(char *) "location", NULL
9709 };
9710
9711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9713 if (SWIG_arg_fail(1)) SWIG_fail;
9714 {
9715 arg2 = wxString_in_helper(obj1);
9716 if (arg2 == NULL) SWIG_fail;
9717 temp2 = true;
9718 }
9719 {
9720 PyThreadState* __tstate = wxPyBeginAllowThreads();
9721 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9722
9723 wxPyEndAllowThreads(__tstate);
9724 if (PyErr_Occurred()) SWIG_fail;
9725 }
9726 {
9727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9728 }
9729 {
9730 if (temp2)
9731 delete arg2;
9732 }
9733 return resultobj;
9734 fail:
9735 {
9736 if (temp2)
9737 delete arg2;
9738 }
9739 return NULL;
9740 }
9741
9742
9743 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9744 PyObject *resultobj;
9745 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9746 wxFileSystem *arg2 = 0 ;
9747 wxString *arg3 = 0 ;
9748 wxFSFile *result;
9749 bool temp3 = false ;
9750 PyObject * obj0 = 0 ;
9751 PyObject * obj1 = 0 ;
9752 PyObject * obj2 = 0 ;
9753 char *kwnames[] = {
9754 (char *) "self",(char *) "fs",(char *) "location", NULL
9755 };
9756
9757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9759 if (SWIG_arg_fail(1)) SWIG_fail;
9760 {
9761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9762 if (SWIG_arg_fail(2)) SWIG_fail;
9763 if (arg2 == NULL) {
9764 SWIG_null_ref("wxFileSystem");
9765 }
9766 if (SWIG_arg_fail(2)) SWIG_fail;
9767 }
9768 {
9769 arg3 = wxString_in_helper(obj2);
9770 if (arg3 == NULL) SWIG_fail;
9771 temp3 = true;
9772 }
9773 {
9774 PyThreadState* __tstate = wxPyBeginAllowThreads();
9775 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9776
9777 wxPyEndAllowThreads(__tstate);
9778 if (PyErr_Occurred()) SWIG_fail;
9779 }
9780 {
9781 resultobj = wxPyMake_wxObject(result, 1);
9782 }
9783 {
9784 if (temp3)
9785 delete arg3;
9786 }
9787 return resultobj;
9788 fail:
9789 {
9790 if (temp3)
9791 delete arg3;
9792 }
9793 return NULL;
9794 }
9795
9796
9797 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9798 PyObject *resultobj;
9799 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9800 wxString *arg2 = 0 ;
9801 int arg3 = (int) 0 ;
9802 wxString result;
9803 bool temp2 = false ;
9804 PyObject * obj0 = 0 ;
9805 PyObject * obj1 = 0 ;
9806 PyObject * obj2 = 0 ;
9807 char *kwnames[] = {
9808 (char *) "self",(char *) "spec",(char *) "flags", NULL
9809 };
9810
9811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9813 if (SWIG_arg_fail(1)) SWIG_fail;
9814 {
9815 arg2 = wxString_in_helper(obj1);
9816 if (arg2 == NULL) SWIG_fail;
9817 temp2 = true;
9818 }
9819 if (obj2) {
9820 {
9821 arg3 = (int)(SWIG_As_int(obj2));
9822 if (SWIG_arg_fail(3)) SWIG_fail;
9823 }
9824 }
9825 {
9826 PyThreadState* __tstate = wxPyBeginAllowThreads();
9827 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9828
9829 wxPyEndAllowThreads(__tstate);
9830 if (PyErr_Occurred()) SWIG_fail;
9831 }
9832 {
9833 #if wxUSE_UNICODE
9834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9835 #else
9836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9837 #endif
9838 }
9839 {
9840 if (temp2)
9841 delete arg2;
9842 }
9843 return resultobj;
9844 fail:
9845 {
9846 if (temp2)
9847 delete arg2;
9848 }
9849 return NULL;
9850 }
9851
9852
9853 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9854 PyObject *resultobj;
9855 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9856 wxString result;
9857 PyObject * obj0 = 0 ;
9858 char *kwnames[] = {
9859 (char *) "self", NULL
9860 };
9861
9862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9864 if (SWIG_arg_fail(1)) SWIG_fail;
9865 {
9866 PyThreadState* __tstate = wxPyBeginAllowThreads();
9867 result = (arg1)->FindNext();
9868
9869 wxPyEndAllowThreads(__tstate);
9870 if (PyErr_Occurred()) SWIG_fail;
9871 }
9872 {
9873 #if wxUSE_UNICODE
9874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9875 #else
9876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9877 #endif
9878 }
9879 return resultobj;
9880 fail:
9881 return NULL;
9882 }
9883
9884
9885 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9886 PyObject *obj;
9887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9888 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9889 Py_INCREF(obj);
9890 return Py_BuildValue((char *)"");
9891 }
9892 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9893 PyObject *resultobj;
9894 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9895 wxString result;
9896 PyObject * obj0 = 0 ;
9897 char *kwnames[] = {
9898 (char *) "self", NULL
9899 };
9900
9901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9903 if (SWIG_arg_fail(1)) SWIG_fail;
9904 {
9905 PyThreadState* __tstate = wxPyBeginAllowThreads();
9906 result = (arg1)->GetName();
9907
9908 wxPyEndAllowThreads(__tstate);
9909 if (PyErr_Occurred()) SWIG_fail;
9910 }
9911 {
9912 #if wxUSE_UNICODE
9913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9914 #else
9915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9916 #endif
9917 }
9918 return resultobj;
9919 fail:
9920 return NULL;
9921 }
9922
9923
9924 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9925 PyObject *resultobj;
9926 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9927 wxString result;
9928 PyObject * obj0 = 0 ;
9929 char *kwnames[] = {
9930 (char *) "self", NULL
9931 };
9932
9933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9935 if (SWIG_arg_fail(1)) SWIG_fail;
9936 {
9937 PyThreadState* __tstate = wxPyBeginAllowThreads();
9938 result = (arg1)->GetExtension();
9939
9940 wxPyEndAllowThreads(__tstate);
9941 if (PyErr_Occurred()) SWIG_fail;
9942 }
9943 {
9944 #if wxUSE_UNICODE
9945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9946 #else
9947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9948 #endif
9949 }
9950 return resultobj;
9951 fail:
9952 return NULL;
9953 }
9954
9955
9956 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9957 PyObject *resultobj;
9958 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9959 long result;
9960 PyObject * obj0 = 0 ;
9961 char *kwnames[] = {
9962 (char *) "self", NULL
9963 };
9964
9965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9967 if (SWIG_arg_fail(1)) SWIG_fail;
9968 {
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 result = (long)(arg1)->GetType();
9971
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 {
9976 resultobj = SWIG_From_long((long)(result));
9977 }
9978 return resultobj;
9979 fail:
9980 return NULL;
9981 }
9982
9983
9984 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9985 PyObject *resultobj;
9986 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9987 wxString result;
9988 PyObject * obj0 = 0 ;
9989 char *kwnames[] = {
9990 (char *) "self", NULL
9991 };
9992
9993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9995 if (SWIG_arg_fail(1)) SWIG_fail;
9996 {
9997 PyThreadState* __tstate = wxPyBeginAllowThreads();
9998 result = (arg1)->GetMimeType();
9999
10000 wxPyEndAllowThreads(__tstate);
10001 if (PyErr_Occurred()) SWIG_fail;
10002 }
10003 {
10004 #if wxUSE_UNICODE
10005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10006 #else
10007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10008 #endif
10009 }
10010 return resultobj;
10011 fail:
10012 return NULL;
10013 }
10014
10015
10016 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10017 PyObject *resultobj;
10018 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10019 wxString *arg2 = 0 ;
10020 bool result;
10021 bool temp2 = false ;
10022 PyObject * obj0 = 0 ;
10023 PyObject * obj1 = 0 ;
10024 char *kwnames[] = {
10025 (char *) "self",(char *) "name", NULL
10026 };
10027
10028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10030 if (SWIG_arg_fail(1)) SWIG_fail;
10031 {
10032 arg2 = wxString_in_helper(obj1);
10033 if (arg2 == NULL) SWIG_fail;
10034 temp2 = true;
10035 }
10036 {
10037 PyThreadState* __tstate = wxPyBeginAllowThreads();
10038 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10039
10040 wxPyEndAllowThreads(__tstate);
10041 if (PyErr_Occurred()) SWIG_fail;
10042 }
10043 {
10044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10045 }
10046 {
10047 if (temp2)
10048 delete arg2;
10049 }
10050 return resultobj;
10051 fail:
10052 {
10053 if (temp2)
10054 delete arg2;
10055 }
10056 return NULL;
10057 }
10058
10059
10060 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10061 PyObject *resultobj;
10062 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10063 wxString *arg2 = 0 ;
10064 bool temp2 = false ;
10065 PyObject * obj0 = 0 ;
10066 PyObject * obj1 = 0 ;
10067 char *kwnames[] = {
10068 (char *) "self",(char *) "name", NULL
10069 };
10070
10071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10073 if (SWIG_arg_fail(1)) SWIG_fail;
10074 {
10075 arg2 = wxString_in_helper(obj1);
10076 if (arg2 == NULL) SWIG_fail;
10077 temp2 = true;
10078 }
10079 {
10080 PyThreadState* __tstate = wxPyBeginAllowThreads();
10081 (arg1)->SetName((wxString const &)*arg2);
10082
10083 wxPyEndAllowThreads(__tstate);
10084 if (PyErr_Occurred()) SWIG_fail;
10085 }
10086 Py_INCREF(Py_None); resultobj = Py_None;
10087 {
10088 if (temp2)
10089 delete arg2;
10090 }
10091 return resultobj;
10092 fail:
10093 {
10094 if (temp2)
10095 delete arg2;
10096 }
10097 return NULL;
10098 }
10099
10100
10101 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10102 PyObject *resultobj;
10103 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10104 wxString *arg2 = 0 ;
10105 bool temp2 = false ;
10106 PyObject * obj0 = 0 ;
10107 PyObject * obj1 = 0 ;
10108 char *kwnames[] = {
10109 (char *) "self",(char *) "extension", NULL
10110 };
10111
10112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10114 if (SWIG_arg_fail(1)) SWIG_fail;
10115 {
10116 arg2 = wxString_in_helper(obj1);
10117 if (arg2 == NULL) SWIG_fail;
10118 temp2 = true;
10119 }
10120 {
10121 PyThreadState* __tstate = wxPyBeginAllowThreads();
10122 (arg1)->SetExtension((wxString const &)*arg2);
10123
10124 wxPyEndAllowThreads(__tstate);
10125 if (PyErr_Occurred()) SWIG_fail;
10126 }
10127 Py_INCREF(Py_None); resultobj = Py_None;
10128 {
10129 if (temp2)
10130 delete arg2;
10131 }
10132 return resultobj;
10133 fail:
10134 {
10135 if (temp2)
10136 delete arg2;
10137 }
10138 return NULL;
10139 }
10140
10141
10142 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10143 PyObject *resultobj;
10144 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10145 long arg2 ;
10146 PyObject * obj0 = 0 ;
10147 PyObject * obj1 = 0 ;
10148 char *kwnames[] = {
10149 (char *) "self",(char *) "type", NULL
10150 };
10151
10152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10154 if (SWIG_arg_fail(1)) SWIG_fail;
10155 {
10156 arg2 = (long)(SWIG_As_long(obj1));
10157 if (SWIG_arg_fail(2)) SWIG_fail;
10158 }
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 (arg1)->SetType(arg2);
10162
10163 wxPyEndAllowThreads(__tstate);
10164 if (PyErr_Occurred()) SWIG_fail;
10165 }
10166 Py_INCREF(Py_None); resultobj = Py_None;
10167 return resultobj;
10168 fail:
10169 return NULL;
10170 }
10171
10172
10173 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10174 PyObject *resultobj;
10175 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10176 wxString *arg2 = 0 ;
10177 bool temp2 = false ;
10178 PyObject * obj0 = 0 ;
10179 PyObject * obj1 = 0 ;
10180 char *kwnames[] = {
10181 (char *) "self",(char *) "mimetype", NULL
10182 };
10183
10184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10186 if (SWIG_arg_fail(1)) SWIG_fail;
10187 {
10188 arg2 = wxString_in_helper(obj1);
10189 if (arg2 == NULL) SWIG_fail;
10190 temp2 = true;
10191 }
10192 {
10193 PyThreadState* __tstate = wxPyBeginAllowThreads();
10194 (arg1)->SetMimeType((wxString const &)*arg2);
10195
10196 wxPyEndAllowThreads(__tstate);
10197 if (PyErr_Occurred()) SWIG_fail;
10198 }
10199 Py_INCREF(Py_None); resultobj = Py_None;
10200 {
10201 if (temp2)
10202 delete arg2;
10203 }
10204 return resultobj;
10205 fail:
10206 {
10207 if (temp2)
10208 delete arg2;
10209 }
10210 return NULL;
10211 }
10212
10213
10214 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10215 PyObject *obj;
10216 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10217 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10218 Py_INCREF(obj);
10219 return Py_BuildValue((char *)"");
10220 }
10221 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10222 PyObject *resultobj;
10223 wxImageHistogram *result;
10224 char *kwnames[] = {
10225 NULL
10226 };
10227
10228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10229 {
10230 PyThreadState* __tstate = wxPyBeginAllowThreads();
10231 result = (wxImageHistogram *)new wxImageHistogram();
10232
10233 wxPyEndAllowThreads(__tstate);
10234 if (PyErr_Occurred()) SWIG_fail;
10235 }
10236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10237 return resultobj;
10238 fail:
10239 return NULL;
10240 }
10241
10242
10243 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10244 PyObject *resultobj;
10245 unsigned char arg1 ;
10246 unsigned char arg2 ;
10247 unsigned char arg3 ;
10248 unsigned long result;
10249 PyObject * obj0 = 0 ;
10250 PyObject * obj1 = 0 ;
10251 PyObject * obj2 = 0 ;
10252 char *kwnames[] = {
10253 (char *) "r",(char *) "g",(char *) "b", NULL
10254 };
10255
10256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10257 {
10258 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10259 if (SWIG_arg_fail(1)) SWIG_fail;
10260 }
10261 {
10262 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10263 if (SWIG_arg_fail(2)) SWIG_fail;
10264 }
10265 {
10266 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10267 if (SWIG_arg_fail(3)) SWIG_fail;
10268 }
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10272
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 {
10277 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10278 }
10279 return resultobj;
10280 fail:
10281 return NULL;
10282 }
10283
10284
10285 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10286 PyObject *resultobj;
10287 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10288 unsigned char *arg2 = (unsigned char *) 0 ;
10289 unsigned char *arg3 = (unsigned char *) 0 ;
10290 unsigned char *arg4 = (unsigned char *) 0 ;
10291 unsigned char arg5 = (unsigned char) 1 ;
10292 unsigned char arg6 = (unsigned char) 0 ;
10293 unsigned char arg7 = (unsigned char) 0 ;
10294 bool result;
10295 unsigned char temp2 ;
10296 int res2 = 0 ;
10297 unsigned char temp3 ;
10298 int res3 = 0 ;
10299 unsigned char temp4 ;
10300 int res4 = 0 ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 PyObject * obj2 = 0 ;
10304 PyObject * obj3 = 0 ;
10305 char *kwnames[] = {
10306 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10307 };
10308
10309 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10310 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10311 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10314 if (SWIG_arg_fail(1)) SWIG_fail;
10315 if (obj1) {
10316 {
10317 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10318 if (SWIG_arg_fail(5)) SWIG_fail;
10319 }
10320 }
10321 if (obj2) {
10322 {
10323 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10324 if (SWIG_arg_fail(6)) SWIG_fail;
10325 }
10326 }
10327 if (obj3) {
10328 {
10329 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10330 if (SWIG_arg_fail(7)) SWIG_fail;
10331 }
10332 }
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10336
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 {
10341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10342 }
10343 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10344 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10345 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10346 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10347 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10348 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10349 return resultobj;
10350 fail:
10351 return NULL;
10352 }
10353
10354
10355 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10356 PyObject *resultobj;
10357 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10358 unsigned long arg2 ;
10359 unsigned long result;
10360 PyObject * obj0 = 0 ;
10361 PyObject * obj1 = 0 ;
10362 char *kwnames[] = {
10363 (char *) "self",(char *) "key", NULL
10364 };
10365
10366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10368 if (SWIG_arg_fail(1)) SWIG_fail;
10369 {
10370 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10371 if (SWIG_arg_fail(2)) SWIG_fail;
10372 }
10373 {
10374 PyThreadState* __tstate = wxPyBeginAllowThreads();
10375 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10376
10377 wxPyEndAllowThreads(__tstate);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 {
10381 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10382 }
10383 return resultobj;
10384 fail:
10385 return NULL;
10386 }
10387
10388
10389 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10390 PyObject *resultobj;
10391 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10392 unsigned char arg2 ;
10393 unsigned char arg3 ;
10394 unsigned char arg4 ;
10395 unsigned long result;
10396 PyObject * obj0 = 0 ;
10397 PyObject * obj1 = 0 ;
10398 PyObject * obj2 = 0 ;
10399 PyObject * obj3 = 0 ;
10400 char *kwnames[] = {
10401 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10402 };
10403
10404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10406 if (SWIG_arg_fail(1)) SWIG_fail;
10407 {
10408 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10409 if (SWIG_arg_fail(2)) SWIG_fail;
10410 }
10411 {
10412 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10413 if (SWIG_arg_fail(3)) SWIG_fail;
10414 }
10415 {
10416 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10417 if (SWIG_arg_fail(4)) SWIG_fail;
10418 }
10419 {
10420 PyThreadState* __tstate = wxPyBeginAllowThreads();
10421 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10422
10423 wxPyEndAllowThreads(__tstate);
10424 if (PyErr_Occurred()) SWIG_fail;
10425 }
10426 {
10427 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10428 }
10429 return resultobj;
10430 fail:
10431 return NULL;
10432 }
10433
10434
10435 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10436 PyObject *resultobj;
10437 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10438 wxColour *arg2 = 0 ;
10439 unsigned long result;
10440 wxColour temp2 ;
10441 PyObject * obj0 = 0 ;
10442 PyObject * obj1 = 0 ;
10443 char *kwnames[] = {
10444 (char *) "self",(char *) "colour", NULL
10445 };
10446
10447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10449 if (SWIG_arg_fail(1)) SWIG_fail;
10450 {
10451 arg2 = &temp2;
10452 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10453 }
10454 {
10455 PyThreadState* __tstate = wxPyBeginAllowThreads();
10456 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10457
10458 wxPyEndAllowThreads(__tstate);
10459 if (PyErr_Occurred()) SWIG_fail;
10460 }
10461 {
10462 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10463 }
10464 return resultobj;
10465 fail:
10466 return NULL;
10467 }
10468
10469
10470 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10471 PyObject *obj;
10472 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10473 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10474 Py_INCREF(obj);
10475 return Py_BuildValue((char *)"");
10476 }
10477 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10478 PyObject *resultobj;
10479 wxString *arg1 = 0 ;
10480 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10481 int arg3 = (int) -1 ;
10482 wxImage *result;
10483 bool temp1 = false ;
10484 PyObject * obj0 = 0 ;
10485 PyObject * obj1 = 0 ;
10486 PyObject * obj2 = 0 ;
10487 char *kwnames[] = {
10488 (char *) "name",(char *) "type",(char *) "index", NULL
10489 };
10490
10491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10492 {
10493 arg1 = wxString_in_helper(obj0);
10494 if (arg1 == NULL) SWIG_fail;
10495 temp1 = true;
10496 }
10497 if (obj1) {
10498 {
10499 arg2 = (long)(SWIG_As_long(obj1));
10500 if (SWIG_arg_fail(2)) SWIG_fail;
10501 }
10502 }
10503 if (obj2) {
10504 {
10505 arg3 = (int)(SWIG_As_int(obj2));
10506 if (SWIG_arg_fail(3)) SWIG_fail;
10507 }
10508 }
10509 {
10510 PyThreadState* __tstate = wxPyBeginAllowThreads();
10511 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10512
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10517 {
10518 if (temp1)
10519 delete arg1;
10520 }
10521 return resultobj;
10522 fail:
10523 {
10524 if (temp1)
10525 delete arg1;
10526 }
10527 return NULL;
10528 }
10529
10530
10531 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10532 PyObject *resultobj;
10533 wxImage *arg1 = (wxImage *) 0 ;
10534 PyObject * obj0 = 0 ;
10535 char *kwnames[] = {
10536 (char *) "self", NULL
10537 };
10538
10539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10541 if (SWIG_arg_fail(1)) SWIG_fail;
10542 {
10543 PyThreadState* __tstate = wxPyBeginAllowThreads();
10544 delete arg1;
10545
10546 wxPyEndAllowThreads(__tstate);
10547 if (PyErr_Occurred()) SWIG_fail;
10548 }
10549 Py_INCREF(Py_None); resultobj = Py_None;
10550 return resultobj;
10551 fail:
10552 return NULL;
10553 }
10554
10555
10556 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10557 PyObject *resultobj;
10558 wxString *arg1 = 0 ;
10559 wxString *arg2 = 0 ;
10560 int arg3 = (int) -1 ;
10561 wxImage *result;
10562 bool temp1 = false ;
10563 bool temp2 = false ;
10564 PyObject * obj0 = 0 ;
10565 PyObject * obj1 = 0 ;
10566 PyObject * obj2 = 0 ;
10567 char *kwnames[] = {
10568 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10569 };
10570
10571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10572 {
10573 arg1 = wxString_in_helper(obj0);
10574 if (arg1 == NULL) SWIG_fail;
10575 temp1 = true;
10576 }
10577 {
10578 arg2 = wxString_in_helper(obj1);
10579 if (arg2 == NULL) SWIG_fail;
10580 temp2 = true;
10581 }
10582 if (obj2) {
10583 {
10584 arg3 = (int)(SWIG_As_int(obj2));
10585 if (SWIG_arg_fail(3)) SWIG_fail;
10586 }
10587 }
10588 {
10589 PyThreadState* __tstate = wxPyBeginAllowThreads();
10590 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10591
10592 wxPyEndAllowThreads(__tstate);
10593 if (PyErr_Occurred()) SWIG_fail;
10594 }
10595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10596 {
10597 if (temp1)
10598 delete arg1;
10599 }
10600 {
10601 if (temp2)
10602 delete arg2;
10603 }
10604 return resultobj;
10605 fail:
10606 {
10607 if (temp1)
10608 delete arg1;
10609 }
10610 {
10611 if (temp2)
10612 delete arg2;
10613 }
10614 return NULL;
10615 }
10616
10617
10618 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10619 PyObject *resultobj;
10620 wxInputStream *arg1 = 0 ;
10621 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10622 int arg3 = (int) -1 ;
10623 wxImage *result;
10624 wxPyInputStream *temp1 ;
10625 bool created1 ;
10626 PyObject * obj0 = 0 ;
10627 PyObject * obj1 = 0 ;
10628 PyObject * obj2 = 0 ;
10629 char *kwnames[] = {
10630 (char *) "stream",(char *) "type",(char *) "index", NULL
10631 };
10632
10633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10634 {
10635 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10636 arg1 = temp1->m_wxis;
10637 created1 = false;
10638 } else {
10639 PyErr_Clear(); // clear the failure of the wxPyConvert above
10640 arg1 = wxPyCBInputStream_create(obj0, false);
10641 if (arg1 == NULL) {
10642 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10643 SWIG_fail;
10644 }
10645 created1 = true;
10646 }
10647 }
10648 if (obj1) {
10649 {
10650 arg2 = (long)(SWIG_As_long(obj1));
10651 if (SWIG_arg_fail(2)) SWIG_fail;
10652 }
10653 }
10654 if (obj2) {
10655 {
10656 arg3 = (int)(SWIG_As_int(obj2));
10657 if (SWIG_arg_fail(3)) SWIG_fail;
10658 }
10659 }
10660 {
10661 PyThreadState* __tstate = wxPyBeginAllowThreads();
10662 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10663
10664 wxPyEndAllowThreads(__tstate);
10665 if (PyErr_Occurred()) SWIG_fail;
10666 }
10667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10668 {
10669 if (created1) delete arg1;
10670 }
10671 return resultobj;
10672 fail:
10673 {
10674 if (created1) delete arg1;
10675 }
10676 return NULL;
10677 }
10678
10679
10680 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10681 PyObject *resultobj;
10682 wxInputStream *arg1 = 0 ;
10683 wxString *arg2 = 0 ;
10684 int arg3 = (int) -1 ;
10685 wxImage *result;
10686 wxPyInputStream *temp1 ;
10687 bool created1 ;
10688 bool temp2 = false ;
10689 PyObject * obj0 = 0 ;
10690 PyObject * obj1 = 0 ;
10691 PyObject * obj2 = 0 ;
10692 char *kwnames[] = {
10693 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10694 };
10695
10696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10697 {
10698 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10699 arg1 = temp1->m_wxis;
10700 created1 = false;
10701 } else {
10702 PyErr_Clear(); // clear the failure of the wxPyConvert above
10703 arg1 = wxPyCBInputStream_create(obj0, false);
10704 if (arg1 == NULL) {
10705 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10706 SWIG_fail;
10707 }
10708 created1 = true;
10709 }
10710 }
10711 {
10712 arg2 = wxString_in_helper(obj1);
10713 if (arg2 == NULL) SWIG_fail;
10714 temp2 = true;
10715 }
10716 if (obj2) {
10717 {
10718 arg3 = (int)(SWIG_As_int(obj2));
10719 if (SWIG_arg_fail(3)) SWIG_fail;
10720 }
10721 }
10722 {
10723 PyThreadState* __tstate = wxPyBeginAllowThreads();
10724 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10725
10726 wxPyEndAllowThreads(__tstate);
10727 if (PyErr_Occurred()) SWIG_fail;
10728 }
10729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10730 {
10731 if (created1) delete arg1;
10732 }
10733 {
10734 if (temp2)
10735 delete arg2;
10736 }
10737 return resultobj;
10738 fail:
10739 {
10740 if (created1) delete arg1;
10741 }
10742 {
10743 if (temp2)
10744 delete arg2;
10745 }
10746 return NULL;
10747 }
10748
10749
10750 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10751 PyObject *resultobj;
10752 int arg1 = (int) 0 ;
10753 int arg2 = (int) 0 ;
10754 bool arg3 = (bool) true ;
10755 wxImage *result;
10756 PyObject * obj0 = 0 ;
10757 PyObject * obj1 = 0 ;
10758 PyObject * obj2 = 0 ;
10759 char *kwnames[] = {
10760 (char *) "width",(char *) "height",(char *) "clear", NULL
10761 };
10762
10763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10764 if (obj0) {
10765 {
10766 arg1 = (int)(SWIG_As_int(obj0));
10767 if (SWIG_arg_fail(1)) SWIG_fail;
10768 }
10769 }
10770 if (obj1) {
10771 {
10772 arg2 = (int)(SWIG_As_int(obj1));
10773 if (SWIG_arg_fail(2)) SWIG_fail;
10774 }
10775 }
10776 if (obj2) {
10777 {
10778 arg3 = (bool)(SWIG_As_bool(obj2));
10779 if (SWIG_arg_fail(3)) SWIG_fail;
10780 }
10781 }
10782 {
10783 PyThreadState* __tstate = wxPyBeginAllowThreads();
10784 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10785
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10790 return resultobj;
10791 fail:
10792 return NULL;
10793 }
10794
10795
10796 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10797 PyObject *resultobj;
10798 wxBitmap *arg1 = 0 ;
10799 wxImage *result;
10800 PyObject * obj0 = 0 ;
10801 char *kwnames[] = {
10802 (char *) "bitmap", NULL
10803 };
10804
10805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10806 {
10807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10808 if (SWIG_arg_fail(1)) SWIG_fail;
10809 if (arg1 == NULL) {
10810 SWIG_null_ref("wxBitmap");
10811 }
10812 if (SWIG_arg_fail(1)) SWIG_fail;
10813 }
10814 {
10815 if (!wxPyCheckForApp()) SWIG_fail;
10816 PyThreadState* __tstate = wxPyBeginAllowThreads();
10817 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10818
10819 wxPyEndAllowThreads(__tstate);
10820 if (PyErr_Occurred()) SWIG_fail;
10821 }
10822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10823 return resultobj;
10824 fail:
10825 return NULL;
10826 }
10827
10828
10829 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10830 PyObject *resultobj;
10831 int arg1 ;
10832 int arg2 ;
10833 buffer arg3 ;
10834 int arg4 ;
10835 wxImage *result;
10836 PyObject * obj0 = 0 ;
10837 PyObject * obj1 = 0 ;
10838 PyObject * obj2 = 0 ;
10839 char *kwnames[] = {
10840 (char *) "width",(char *) "height",(char *) "data", NULL
10841 };
10842
10843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10844 {
10845 arg1 = (int)(SWIG_As_int(obj0));
10846 if (SWIG_arg_fail(1)) SWIG_fail;
10847 }
10848 {
10849 arg2 = (int)(SWIG_As_int(obj1));
10850 if (SWIG_arg_fail(2)) SWIG_fail;
10851 }
10852 {
10853 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10854 }
10855 {
10856 PyThreadState* __tstate = wxPyBeginAllowThreads();
10857 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10858
10859 wxPyEndAllowThreads(__tstate);
10860 if (PyErr_Occurred()) SWIG_fail;
10861 }
10862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10863 return resultobj;
10864 fail:
10865 return NULL;
10866 }
10867
10868
10869 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10870 PyObject *resultobj;
10871 int arg1 ;
10872 int arg2 ;
10873 buffer arg3 ;
10874 int arg4 ;
10875 buffer arg5 ;
10876 int arg6 ;
10877 wxImage *result;
10878 PyObject * obj0 = 0 ;
10879 PyObject * obj1 = 0 ;
10880 PyObject * obj2 = 0 ;
10881 PyObject * obj3 = 0 ;
10882 char *kwnames[] = {
10883 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10884 };
10885
10886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10887 {
10888 arg1 = (int)(SWIG_As_int(obj0));
10889 if (SWIG_arg_fail(1)) SWIG_fail;
10890 }
10891 {
10892 arg2 = (int)(SWIG_As_int(obj1));
10893 if (SWIG_arg_fail(2)) SWIG_fail;
10894 }
10895 {
10896 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10897 }
10898 {
10899 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10900 }
10901 {
10902 PyThreadState* __tstate = wxPyBeginAllowThreads();
10903 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10904
10905 wxPyEndAllowThreads(__tstate);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10909 return resultobj;
10910 fail:
10911 return NULL;
10912 }
10913
10914
10915 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10916 PyObject *resultobj;
10917 wxImage *arg1 = (wxImage *) 0 ;
10918 int arg2 ;
10919 int arg3 ;
10920 PyObject * obj0 = 0 ;
10921 PyObject * obj1 = 0 ;
10922 PyObject * obj2 = 0 ;
10923 char *kwnames[] = {
10924 (char *) "self",(char *) "width",(char *) "height", NULL
10925 };
10926
10927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10929 if (SWIG_arg_fail(1)) SWIG_fail;
10930 {
10931 arg2 = (int)(SWIG_As_int(obj1));
10932 if (SWIG_arg_fail(2)) SWIG_fail;
10933 }
10934 {
10935 arg3 = (int)(SWIG_As_int(obj2));
10936 if (SWIG_arg_fail(3)) SWIG_fail;
10937 }
10938 {
10939 PyThreadState* __tstate = wxPyBeginAllowThreads();
10940 (arg1)->Create(arg2,arg3);
10941
10942 wxPyEndAllowThreads(__tstate);
10943 if (PyErr_Occurred()) SWIG_fail;
10944 }
10945 Py_INCREF(Py_None); resultobj = Py_None;
10946 return resultobj;
10947 fail:
10948 return NULL;
10949 }
10950
10951
10952 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10953 PyObject *resultobj;
10954 wxImage *arg1 = (wxImage *) 0 ;
10955 PyObject * obj0 = 0 ;
10956 char *kwnames[] = {
10957 (char *) "self", NULL
10958 };
10959
10960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10962 if (SWIG_arg_fail(1)) SWIG_fail;
10963 {
10964 PyThreadState* __tstate = wxPyBeginAllowThreads();
10965 (arg1)->Destroy();
10966
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 Py_INCREF(Py_None); resultobj = Py_None;
10971 return resultobj;
10972 fail:
10973 return NULL;
10974 }
10975
10976
10977 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10978 PyObject *resultobj;
10979 wxImage *arg1 = (wxImage *) 0 ;
10980 int arg2 ;
10981 int arg3 ;
10982 SwigValueWrapper<wxImage > result;
10983 PyObject * obj0 = 0 ;
10984 PyObject * obj1 = 0 ;
10985 PyObject * obj2 = 0 ;
10986 char *kwnames[] = {
10987 (char *) "self",(char *) "width",(char *) "height", NULL
10988 };
10989
10990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10992 if (SWIG_arg_fail(1)) SWIG_fail;
10993 {
10994 arg2 = (int)(SWIG_As_int(obj1));
10995 if (SWIG_arg_fail(2)) SWIG_fail;
10996 }
10997 {
10998 arg3 = (int)(SWIG_As_int(obj2));
10999 if (SWIG_arg_fail(3)) SWIG_fail;
11000 }
11001 {
11002 PyThreadState* __tstate = wxPyBeginAllowThreads();
11003 result = (arg1)->Scale(arg2,arg3);
11004
11005 wxPyEndAllowThreads(__tstate);
11006 if (PyErr_Occurred()) SWIG_fail;
11007 }
11008 {
11009 wxImage * resultptr;
11010 resultptr = new wxImage((wxImage &)(result));
11011 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11012 }
11013 return resultobj;
11014 fail:
11015 return NULL;
11016 }
11017
11018
11019 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11020 PyObject *resultobj;
11021 wxImage *arg1 = (wxImage *) 0 ;
11022 int arg2 ;
11023 int arg3 ;
11024 SwigValueWrapper<wxImage > result;
11025 PyObject * obj0 = 0 ;
11026 PyObject * obj1 = 0 ;
11027 PyObject * obj2 = 0 ;
11028 char *kwnames[] = {
11029 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11030 };
11031
11032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11034 if (SWIG_arg_fail(1)) SWIG_fail;
11035 {
11036 arg2 = (int)(SWIG_As_int(obj1));
11037 if (SWIG_arg_fail(2)) SWIG_fail;
11038 }
11039 {
11040 arg3 = (int)(SWIG_As_int(obj2));
11041 if (SWIG_arg_fail(3)) SWIG_fail;
11042 }
11043 {
11044 PyThreadState* __tstate = wxPyBeginAllowThreads();
11045 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11046
11047 wxPyEndAllowThreads(__tstate);
11048 if (PyErr_Occurred()) SWIG_fail;
11049 }
11050 {
11051 wxImage * resultptr;
11052 resultptr = new wxImage((wxImage &)(result));
11053 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11054 }
11055 return resultobj;
11056 fail:
11057 return NULL;
11058 }
11059
11060
11061 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11062 PyObject *resultobj;
11063 wxImage *arg1 = (wxImage *) 0 ;
11064 int arg2 ;
11065 int arg3 ;
11066 wxImage *result;
11067 PyObject * obj0 = 0 ;
11068 PyObject * obj1 = 0 ;
11069 PyObject * obj2 = 0 ;
11070 char *kwnames[] = {
11071 (char *) "self",(char *) "width",(char *) "height", NULL
11072 };
11073
11074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11076 if (SWIG_arg_fail(1)) SWIG_fail;
11077 {
11078 arg2 = (int)(SWIG_As_int(obj1));
11079 if (SWIG_arg_fail(2)) SWIG_fail;
11080 }
11081 {
11082 arg3 = (int)(SWIG_As_int(obj2));
11083 if (SWIG_arg_fail(3)) SWIG_fail;
11084 }
11085 {
11086 PyThreadState* __tstate = wxPyBeginAllowThreads();
11087 {
11088 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11089 result = (wxImage *) &_result_ref;
11090 }
11091
11092 wxPyEndAllowThreads(__tstate);
11093 if (PyErr_Occurred()) SWIG_fail;
11094 }
11095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11096 return resultobj;
11097 fail:
11098 return NULL;
11099 }
11100
11101
11102 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11103 PyObject *resultobj;
11104 wxImage *arg1 = (wxImage *) 0 ;
11105 wxSize *arg2 = 0 ;
11106 wxPoint *arg3 = 0 ;
11107 int arg4 = (int) -1 ;
11108 int arg5 = (int) -1 ;
11109 int arg6 = (int) -1 ;
11110 wxImage *result;
11111 wxSize temp2 ;
11112 wxPoint temp3 ;
11113 PyObject * obj0 = 0 ;
11114 PyObject * obj1 = 0 ;
11115 PyObject * obj2 = 0 ;
11116 PyObject * obj3 = 0 ;
11117 PyObject * obj4 = 0 ;
11118 PyObject * obj5 = 0 ;
11119 char *kwnames[] = {
11120 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11121 };
11122
11123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11125 if (SWIG_arg_fail(1)) SWIG_fail;
11126 {
11127 arg2 = &temp2;
11128 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11129 }
11130 {
11131 arg3 = &temp3;
11132 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11133 }
11134 if (obj3) {
11135 {
11136 arg4 = (int)(SWIG_As_int(obj3));
11137 if (SWIG_arg_fail(4)) SWIG_fail;
11138 }
11139 }
11140 if (obj4) {
11141 {
11142 arg5 = (int)(SWIG_As_int(obj4));
11143 if (SWIG_arg_fail(5)) SWIG_fail;
11144 }
11145 }
11146 if (obj5) {
11147 {
11148 arg6 = (int)(SWIG_As_int(obj5));
11149 if (SWIG_arg_fail(6)) SWIG_fail;
11150 }
11151 }
11152 {
11153 PyThreadState* __tstate = wxPyBeginAllowThreads();
11154 {
11155 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11156 result = (wxImage *) &_result_ref;
11157 }
11158
11159 wxPyEndAllowThreads(__tstate);
11160 if (PyErr_Occurred()) SWIG_fail;
11161 }
11162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11163 return resultobj;
11164 fail:
11165 return NULL;
11166 }
11167
11168
11169 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11170 PyObject *resultobj;
11171 wxImage *arg1 = (wxImage *) 0 ;
11172 int arg2 ;
11173 int arg3 ;
11174 unsigned char arg4 ;
11175 unsigned char arg5 ;
11176 unsigned char arg6 ;
11177 PyObject * obj0 = 0 ;
11178 PyObject * obj1 = 0 ;
11179 PyObject * obj2 = 0 ;
11180 PyObject * obj3 = 0 ;
11181 PyObject * obj4 = 0 ;
11182 PyObject * obj5 = 0 ;
11183 char *kwnames[] = {
11184 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11185 };
11186
11187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11189 if (SWIG_arg_fail(1)) SWIG_fail;
11190 {
11191 arg2 = (int)(SWIG_As_int(obj1));
11192 if (SWIG_arg_fail(2)) SWIG_fail;
11193 }
11194 {
11195 arg3 = (int)(SWIG_As_int(obj2));
11196 if (SWIG_arg_fail(3)) SWIG_fail;
11197 }
11198 {
11199 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11200 if (SWIG_arg_fail(4)) SWIG_fail;
11201 }
11202 {
11203 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11204 if (SWIG_arg_fail(5)) SWIG_fail;
11205 }
11206 {
11207 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11208 if (SWIG_arg_fail(6)) SWIG_fail;
11209 }
11210 {
11211 PyThreadState* __tstate = wxPyBeginAllowThreads();
11212 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11213
11214 wxPyEndAllowThreads(__tstate);
11215 if (PyErr_Occurred()) SWIG_fail;
11216 }
11217 Py_INCREF(Py_None); resultobj = Py_None;
11218 return resultobj;
11219 fail:
11220 return NULL;
11221 }
11222
11223
11224 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11225 PyObject *resultobj;
11226 wxImage *arg1 = (wxImage *) 0 ;
11227 wxRect *arg2 = 0 ;
11228 unsigned char arg3 ;
11229 unsigned char arg4 ;
11230 unsigned char arg5 ;
11231 wxRect temp2 ;
11232 PyObject * obj0 = 0 ;
11233 PyObject * obj1 = 0 ;
11234 PyObject * obj2 = 0 ;
11235 PyObject * obj3 = 0 ;
11236 PyObject * obj4 = 0 ;
11237 char *kwnames[] = {
11238 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11239 };
11240
11241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11243 if (SWIG_arg_fail(1)) SWIG_fail;
11244 {
11245 arg2 = &temp2;
11246 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11247 }
11248 {
11249 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11250 if (SWIG_arg_fail(3)) SWIG_fail;
11251 }
11252 {
11253 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11254 if (SWIG_arg_fail(4)) SWIG_fail;
11255 }
11256 {
11257 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11258 if (SWIG_arg_fail(5)) SWIG_fail;
11259 }
11260 {
11261 PyThreadState* __tstate = wxPyBeginAllowThreads();
11262 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11263
11264 wxPyEndAllowThreads(__tstate);
11265 if (PyErr_Occurred()) SWIG_fail;
11266 }
11267 Py_INCREF(Py_None); resultobj = Py_None;
11268 return resultobj;
11269 fail:
11270 return NULL;
11271 }
11272
11273
11274 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11275 PyObject *resultobj;
11276 wxImage *arg1 = (wxImage *) 0 ;
11277 int arg2 ;
11278 int arg3 ;
11279 unsigned char result;
11280 PyObject * obj0 = 0 ;
11281 PyObject * obj1 = 0 ;
11282 PyObject * obj2 = 0 ;
11283 char *kwnames[] = {
11284 (char *) "self",(char *) "x",(char *) "y", NULL
11285 };
11286
11287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11289 if (SWIG_arg_fail(1)) SWIG_fail;
11290 {
11291 arg2 = (int)(SWIG_As_int(obj1));
11292 if (SWIG_arg_fail(2)) SWIG_fail;
11293 }
11294 {
11295 arg3 = (int)(SWIG_As_int(obj2));
11296 if (SWIG_arg_fail(3)) SWIG_fail;
11297 }
11298 {
11299 PyThreadState* __tstate = wxPyBeginAllowThreads();
11300 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11301
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 {
11306 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11307 }
11308 return resultobj;
11309 fail:
11310 return NULL;
11311 }
11312
11313
11314 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11315 PyObject *resultobj;
11316 wxImage *arg1 = (wxImage *) 0 ;
11317 int arg2 ;
11318 int arg3 ;
11319 unsigned char result;
11320 PyObject * obj0 = 0 ;
11321 PyObject * obj1 = 0 ;
11322 PyObject * obj2 = 0 ;
11323 char *kwnames[] = {
11324 (char *) "self",(char *) "x",(char *) "y", NULL
11325 };
11326
11327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11329 if (SWIG_arg_fail(1)) SWIG_fail;
11330 {
11331 arg2 = (int)(SWIG_As_int(obj1));
11332 if (SWIG_arg_fail(2)) SWIG_fail;
11333 }
11334 {
11335 arg3 = (int)(SWIG_As_int(obj2));
11336 if (SWIG_arg_fail(3)) SWIG_fail;
11337 }
11338 {
11339 PyThreadState* __tstate = wxPyBeginAllowThreads();
11340 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11341
11342 wxPyEndAllowThreads(__tstate);
11343 if (PyErr_Occurred()) SWIG_fail;
11344 }
11345 {
11346 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11347 }
11348 return resultobj;
11349 fail:
11350 return NULL;
11351 }
11352
11353
11354 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11355 PyObject *resultobj;
11356 wxImage *arg1 = (wxImage *) 0 ;
11357 int arg2 ;
11358 int arg3 ;
11359 unsigned char result;
11360 PyObject * obj0 = 0 ;
11361 PyObject * obj1 = 0 ;
11362 PyObject * obj2 = 0 ;
11363 char *kwnames[] = {
11364 (char *) "self",(char *) "x",(char *) "y", NULL
11365 };
11366
11367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11369 if (SWIG_arg_fail(1)) SWIG_fail;
11370 {
11371 arg2 = (int)(SWIG_As_int(obj1));
11372 if (SWIG_arg_fail(2)) SWIG_fail;
11373 }
11374 {
11375 arg3 = (int)(SWIG_As_int(obj2));
11376 if (SWIG_arg_fail(3)) SWIG_fail;
11377 }
11378 {
11379 PyThreadState* __tstate = wxPyBeginAllowThreads();
11380 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11381
11382 wxPyEndAllowThreads(__tstate);
11383 if (PyErr_Occurred()) SWIG_fail;
11384 }
11385 {
11386 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11387 }
11388 return resultobj;
11389 fail:
11390 return NULL;
11391 }
11392
11393
11394 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11395 PyObject *resultobj;
11396 wxImage *arg1 = (wxImage *) 0 ;
11397 int arg2 ;
11398 int arg3 ;
11399 unsigned char arg4 ;
11400 PyObject * obj0 = 0 ;
11401 PyObject * obj1 = 0 ;
11402 PyObject * obj2 = 0 ;
11403 PyObject * obj3 = 0 ;
11404 char *kwnames[] = {
11405 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11406 };
11407
11408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11410 if (SWIG_arg_fail(1)) SWIG_fail;
11411 {
11412 arg2 = (int)(SWIG_As_int(obj1));
11413 if (SWIG_arg_fail(2)) SWIG_fail;
11414 }
11415 {
11416 arg3 = (int)(SWIG_As_int(obj2));
11417 if (SWIG_arg_fail(3)) SWIG_fail;
11418 }
11419 {
11420 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11421 if (SWIG_arg_fail(4)) SWIG_fail;
11422 }
11423 {
11424 PyThreadState* __tstate = wxPyBeginAllowThreads();
11425 (arg1)->SetAlpha(arg2,arg3,arg4);
11426
11427 wxPyEndAllowThreads(__tstate);
11428 if (PyErr_Occurred()) SWIG_fail;
11429 }
11430 Py_INCREF(Py_None); resultobj = Py_None;
11431 return resultobj;
11432 fail:
11433 return NULL;
11434 }
11435
11436
11437 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11438 PyObject *resultobj;
11439 wxImage *arg1 = (wxImage *) 0 ;
11440 int arg2 ;
11441 int arg3 ;
11442 unsigned char result;
11443 PyObject * obj0 = 0 ;
11444 PyObject * obj1 = 0 ;
11445 PyObject * obj2 = 0 ;
11446 char *kwnames[] = {
11447 (char *) "self",(char *) "x",(char *) "y", NULL
11448 };
11449
11450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11452 if (SWIG_arg_fail(1)) SWIG_fail;
11453 {
11454 arg2 = (int)(SWIG_As_int(obj1));
11455 if (SWIG_arg_fail(2)) SWIG_fail;
11456 }
11457 {
11458 arg3 = (int)(SWIG_As_int(obj2));
11459 if (SWIG_arg_fail(3)) SWIG_fail;
11460 }
11461 {
11462 PyThreadState* __tstate = wxPyBeginAllowThreads();
11463 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11464
11465 wxPyEndAllowThreads(__tstate);
11466 if (PyErr_Occurred()) SWIG_fail;
11467 }
11468 {
11469 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11470 }
11471 return resultobj;
11472 fail:
11473 return NULL;
11474 }
11475
11476
11477 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11478 PyObject *resultobj;
11479 wxImage *arg1 = (wxImage *) 0 ;
11480 bool result;
11481 PyObject * obj0 = 0 ;
11482 char *kwnames[] = {
11483 (char *) "self", NULL
11484 };
11485
11486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11488 if (SWIG_arg_fail(1)) SWIG_fail;
11489 {
11490 PyThreadState* __tstate = wxPyBeginAllowThreads();
11491 result = (bool)(arg1)->HasAlpha();
11492
11493 wxPyEndAllowThreads(__tstate);
11494 if (PyErr_Occurred()) SWIG_fail;
11495 }
11496 {
11497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11498 }
11499 return resultobj;
11500 fail:
11501 return NULL;
11502 }
11503
11504
11505 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11506 PyObject *resultobj;
11507 wxImage *arg1 = (wxImage *) 0 ;
11508 PyObject * obj0 = 0 ;
11509 char *kwnames[] = {
11510 (char *) "self", NULL
11511 };
11512
11513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11515 if (SWIG_arg_fail(1)) SWIG_fail;
11516 {
11517 PyThreadState* __tstate = wxPyBeginAllowThreads();
11518 (arg1)->InitAlpha();
11519
11520 wxPyEndAllowThreads(__tstate);
11521 if (PyErr_Occurred()) SWIG_fail;
11522 }
11523 Py_INCREF(Py_None); resultobj = Py_None;
11524 return resultobj;
11525 fail:
11526 return NULL;
11527 }
11528
11529
11530 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11531 PyObject *resultobj;
11532 wxImage *arg1 = (wxImage *) 0 ;
11533 int arg2 ;
11534 int arg3 ;
11535 unsigned char arg4 = (unsigned char) wxIMAGE_ALPHA_THRESHOLD ;
11536 bool result;
11537 PyObject * obj0 = 0 ;
11538 PyObject * obj1 = 0 ;
11539 PyObject * obj2 = 0 ;
11540 PyObject * obj3 = 0 ;
11541 char *kwnames[] = {
11542 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11543 };
11544
11545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11547 if (SWIG_arg_fail(1)) SWIG_fail;
11548 {
11549 arg2 = (int)(SWIG_As_int(obj1));
11550 if (SWIG_arg_fail(2)) SWIG_fail;
11551 }
11552 {
11553 arg3 = (int)(SWIG_As_int(obj2));
11554 if (SWIG_arg_fail(3)) SWIG_fail;
11555 }
11556 if (obj3) {
11557 {
11558 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11559 if (SWIG_arg_fail(4)) SWIG_fail;
11560 }
11561 }
11562 {
11563 PyThreadState* __tstate = wxPyBeginAllowThreads();
11564 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11565
11566 wxPyEndAllowThreads(__tstate);
11567 if (PyErr_Occurred()) SWIG_fail;
11568 }
11569 {
11570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11571 }
11572 return resultobj;
11573 fail:
11574 return NULL;
11575 }
11576
11577
11578 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11579 PyObject *resultobj;
11580 wxImage *arg1 = (wxImage *) 0 ;
11581 byte *arg2 = (byte *) 0 ;
11582 byte *arg3 = (byte *) 0 ;
11583 byte *arg4 = (byte *) 0 ;
11584 byte arg5 = (byte) 0 ;
11585 byte arg6 = (byte) 0 ;
11586 byte arg7 = (byte) 0 ;
11587 bool result;
11588 byte temp2 ;
11589 int res2 = 0 ;
11590 byte temp3 ;
11591 int res3 = 0 ;
11592 byte temp4 ;
11593 int res4 = 0 ;
11594 PyObject * obj0 = 0 ;
11595 PyObject * obj1 = 0 ;
11596 PyObject * obj2 = 0 ;
11597 PyObject * obj3 = 0 ;
11598 char *kwnames[] = {
11599 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11600 };
11601
11602 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11603 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11604 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11607 if (SWIG_arg_fail(1)) SWIG_fail;
11608 if (obj1) {
11609 {
11610 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11611 if (SWIG_arg_fail(5)) SWIG_fail;
11612 }
11613 }
11614 if (obj2) {
11615 {
11616 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11617 if (SWIG_arg_fail(6)) SWIG_fail;
11618 }
11619 }
11620 if (obj3) {
11621 {
11622 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11623 if (SWIG_arg_fail(7)) SWIG_fail;
11624 }
11625 }
11626 {
11627 PyThreadState* __tstate = wxPyBeginAllowThreads();
11628 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11629
11630 wxPyEndAllowThreads(__tstate);
11631 if (PyErr_Occurred()) SWIG_fail;
11632 }
11633 {
11634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11635 }
11636 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11637 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11638 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11639 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11640 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11641 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11642 return resultobj;
11643 fail:
11644 return NULL;
11645 }
11646
11647
11648 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11649 PyObject *resultobj;
11650 wxImage *arg1 = (wxImage *) 0 ;
11651 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11652 bool result;
11653 PyObject * obj0 = 0 ;
11654 PyObject * obj1 = 0 ;
11655 char *kwnames[] = {
11656 (char *) "self",(char *) "threshold", NULL
11657 };
11658
11659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11661 if (SWIG_arg_fail(1)) SWIG_fail;
11662 if (obj1) {
11663 {
11664 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11665 if (SWIG_arg_fail(2)) SWIG_fail;
11666 }
11667 }
11668 {
11669 PyThreadState* __tstate = wxPyBeginAllowThreads();
11670 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11671
11672 wxPyEndAllowThreads(__tstate);
11673 if (PyErr_Occurred()) SWIG_fail;
11674 }
11675 {
11676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11677 }
11678 return resultobj;
11679 fail:
11680 return NULL;
11681 }
11682
11683
11684 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11685 PyObject *resultobj;
11686 wxImage *arg1 = (wxImage *) 0 ;
11687 unsigned char arg2 ;
11688 unsigned char arg3 ;
11689 unsigned char arg4 ;
11690 bool result;
11691 PyObject * obj0 = 0 ;
11692 PyObject * obj1 = 0 ;
11693 PyObject * obj2 = 0 ;
11694 PyObject * obj3 = 0 ;
11695 char *kwnames[] = {
11696 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11697 };
11698
11699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11701 if (SWIG_arg_fail(1)) SWIG_fail;
11702 {
11703 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11704 if (SWIG_arg_fail(2)) SWIG_fail;
11705 }
11706 {
11707 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11708 if (SWIG_arg_fail(3)) SWIG_fail;
11709 }
11710 {
11711 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11712 if (SWIG_arg_fail(4)) SWIG_fail;
11713 }
11714 {
11715 PyThreadState* __tstate = wxPyBeginAllowThreads();
11716 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11717
11718 wxPyEndAllowThreads(__tstate);
11719 if (PyErr_Occurred()) SWIG_fail;
11720 }
11721 {
11722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11723 }
11724 return resultobj;
11725 fail:
11726 return NULL;
11727 }
11728
11729
11730 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11731 PyObject *resultobj;
11732 wxImage *arg1 = (wxImage *) 0 ;
11733 wxImage *arg2 = 0 ;
11734 byte arg3 ;
11735 byte arg4 ;
11736 byte arg5 ;
11737 bool result;
11738 PyObject * obj0 = 0 ;
11739 PyObject * obj1 = 0 ;
11740 PyObject * obj2 = 0 ;
11741 PyObject * obj3 = 0 ;
11742 PyObject * obj4 = 0 ;
11743 char *kwnames[] = {
11744 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11745 };
11746
11747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11749 if (SWIG_arg_fail(1)) SWIG_fail;
11750 {
11751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11752 if (SWIG_arg_fail(2)) SWIG_fail;
11753 if (arg2 == NULL) {
11754 SWIG_null_ref("wxImage");
11755 }
11756 if (SWIG_arg_fail(2)) SWIG_fail;
11757 }
11758 {
11759 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11760 if (SWIG_arg_fail(3)) SWIG_fail;
11761 }
11762 {
11763 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11764 if (SWIG_arg_fail(4)) SWIG_fail;
11765 }
11766 {
11767 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11768 if (SWIG_arg_fail(5)) SWIG_fail;
11769 }
11770 {
11771 PyThreadState* __tstate = wxPyBeginAllowThreads();
11772 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11773
11774 wxPyEndAllowThreads(__tstate);
11775 if (PyErr_Occurred()) SWIG_fail;
11776 }
11777 {
11778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11779 }
11780 return resultobj;
11781 fail:
11782 return NULL;
11783 }
11784
11785
11786 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11787 PyObject *resultobj;
11788 wxString *arg1 = 0 ;
11789 bool result;
11790 bool temp1 = false ;
11791 PyObject * obj0 = 0 ;
11792 char *kwnames[] = {
11793 (char *) "name", NULL
11794 };
11795
11796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11797 {
11798 arg1 = wxString_in_helper(obj0);
11799 if (arg1 == NULL) SWIG_fail;
11800 temp1 = true;
11801 }
11802 {
11803 PyThreadState* __tstate = wxPyBeginAllowThreads();
11804 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11805
11806 wxPyEndAllowThreads(__tstate);
11807 if (PyErr_Occurred()) SWIG_fail;
11808 }
11809 {
11810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11811 }
11812 {
11813 if (temp1)
11814 delete arg1;
11815 }
11816 return resultobj;
11817 fail:
11818 {
11819 if (temp1)
11820 delete arg1;
11821 }
11822 return NULL;
11823 }
11824
11825
11826 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11827 PyObject *resultobj;
11828 wxString *arg1 = 0 ;
11829 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11830 int result;
11831 bool temp1 = false ;
11832 PyObject * obj0 = 0 ;
11833 PyObject * obj1 = 0 ;
11834 char *kwnames[] = {
11835 (char *) "name",(char *) "type", NULL
11836 };
11837
11838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11839 {
11840 arg1 = wxString_in_helper(obj0);
11841 if (arg1 == NULL) SWIG_fail;
11842 temp1 = true;
11843 }
11844 if (obj1) {
11845 {
11846 arg2 = (long)(SWIG_As_long(obj1));
11847 if (SWIG_arg_fail(2)) SWIG_fail;
11848 }
11849 }
11850 {
11851 PyThreadState* __tstate = wxPyBeginAllowThreads();
11852 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11853
11854 wxPyEndAllowThreads(__tstate);
11855 if (PyErr_Occurred()) SWIG_fail;
11856 }
11857 {
11858 resultobj = SWIG_From_int((int)(result));
11859 }
11860 {
11861 if (temp1)
11862 delete arg1;
11863 }
11864 return resultobj;
11865 fail:
11866 {
11867 if (temp1)
11868 delete arg1;
11869 }
11870 return NULL;
11871 }
11872
11873
11874 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11875 PyObject *resultobj;
11876 wxImage *arg1 = (wxImage *) 0 ;
11877 wxString *arg2 = 0 ;
11878 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11879 int arg4 = (int) -1 ;
11880 bool result;
11881 bool temp2 = false ;
11882 PyObject * obj0 = 0 ;
11883 PyObject * obj1 = 0 ;
11884 PyObject * obj2 = 0 ;
11885 PyObject * obj3 = 0 ;
11886 char *kwnames[] = {
11887 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11888 };
11889
11890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11892 if (SWIG_arg_fail(1)) SWIG_fail;
11893 {
11894 arg2 = wxString_in_helper(obj1);
11895 if (arg2 == NULL) SWIG_fail;
11896 temp2 = true;
11897 }
11898 if (obj2) {
11899 {
11900 arg3 = (long)(SWIG_As_long(obj2));
11901 if (SWIG_arg_fail(3)) SWIG_fail;
11902 }
11903 }
11904 if (obj3) {
11905 {
11906 arg4 = (int)(SWIG_As_int(obj3));
11907 if (SWIG_arg_fail(4)) SWIG_fail;
11908 }
11909 }
11910 {
11911 PyThreadState* __tstate = wxPyBeginAllowThreads();
11912 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11913
11914 wxPyEndAllowThreads(__tstate);
11915 if (PyErr_Occurred()) SWIG_fail;
11916 }
11917 {
11918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11919 }
11920 {
11921 if (temp2)
11922 delete arg2;
11923 }
11924 return resultobj;
11925 fail:
11926 {
11927 if (temp2)
11928 delete arg2;
11929 }
11930 return NULL;
11931 }
11932
11933
11934 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11935 PyObject *resultobj;
11936 wxImage *arg1 = (wxImage *) 0 ;
11937 wxString *arg2 = 0 ;
11938 wxString *arg3 = 0 ;
11939 int arg4 = (int) -1 ;
11940 bool result;
11941 bool temp2 = false ;
11942 bool temp3 = false ;
11943 PyObject * obj0 = 0 ;
11944 PyObject * obj1 = 0 ;
11945 PyObject * obj2 = 0 ;
11946 PyObject * obj3 = 0 ;
11947 char *kwnames[] = {
11948 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11949 };
11950
11951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11953 if (SWIG_arg_fail(1)) SWIG_fail;
11954 {
11955 arg2 = wxString_in_helper(obj1);
11956 if (arg2 == NULL) SWIG_fail;
11957 temp2 = true;
11958 }
11959 {
11960 arg3 = wxString_in_helper(obj2);
11961 if (arg3 == NULL) SWIG_fail;
11962 temp3 = true;
11963 }
11964 if (obj3) {
11965 {
11966 arg4 = (int)(SWIG_As_int(obj3));
11967 if (SWIG_arg_fail(4)) SWIG_fail;
11968 }
11969 }
11970 {
11971 PyThreadState* __tstate = wxPyBeginAllowThreads();
11972 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11973
11974 wxPyEndAllowThreads(__tstate);
11975 if (PyErr_Occurred()) SWIG_fail;
11976 }
11977 {
11978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11979 }
11980 {
11981 if (temp2)
11982 delete arg2;
11983 }
11984 {
11985 if (temp3)
11986 delete arg3;
11987 }
11988 return resultobj;
11989 fail:
11990 {
11991 if (temp2)
11992 delete arg2;
11993 }
11994 {
11995 if (temp3)
11996 delete arg3;
11997 }
11998 return NULL;
11999 }
12000
12001
12002 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12003 PyObject *resultobj;
12004 wxImage *arg1 = (wxImage *) 0 ;
12005 wxString *arg2 = 0 ;
12006 int arg3 ;
12007 bool result;
12008 bool temp2 = false ;
12009 PyObject * obj0 = 0 ;
12010 PyObject * obj1 = 0 ;
12011 PyObject * obj2 = 0 ;
12012 char *kwnames[] = {
12013 (char *) "self",(char *) "name",(char *) "type", NULL
12014 };
12015
12016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12018 if (SWIG_arg_fail(1)) SWIG_fail;
12019 {
12020 arg2 = wxString_in_helper(obj1);
12021 if (arg2 == NULL) SWIG_fail;
12022 temp2 = true;
12023 }
12024 {
12025 arg3 = (int)(SWIG_As_int(obj2));
12026 if (SWIG_arg_fail(3)) SWIG_fail;
12027 }
12028 {
12029 PyThreadState* __tstate = wxPyBeginAllowThreads();
12030 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12031
12032 wxPyEndAllowThreads(__tstate);
12033 if (PyErr_Occurred()) SWIG_fail;
12034 }
12035 {
12036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12037 }
12038 {
12039 if (temp2)
12040 delete arg2;
12041 }
12042 return resultobj;
12043 fail:
12044 {
12045 if (temp2)
12046 delete arg2;
12047 }
12048 return NULL;
12049 }
12050
12051
12052 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12053 PyObject *resultobj;
12054 wxImage *arg1 = (wxImage *) 0 ;
12055 wxString *arg2 = 0 ;
12056 wxString *arg3 = 0 ;
12057 bool result;
12058 bool temp2 = false ;
12059 bool temp3 = false ;
12060 PyObject * obj0 = 0 ;
12061 PyObject * obj1 = 0 ;
12062 PyObject * obj2 = 0 ;
12063 char *kwnames[] = {
12064 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12065 };
12066
12067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12069 if (SWIG_arg_fail(1)) SWIG_fail;
12070 {
12071 arg2 = wxString_in_helper(obj1);
12072 if (arg2 == NULL) SWIG_fail;
12073 temp2 = true;
12074 }
12075 {
12076 arg3 = wxString_in_helper(obj2);
12077 if (arg3 == NULL) SWIG_fail;
12078 temp3 = true;
12079 }
12080 {
12081 PyThreadState* __tstate = wxPyBeginAllowThreads();
12082 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12083
12084 wxPyEndAllowThreads(__tstate);
12085 if (PyErr_Occurred()) SWIG_fail;
12086 }
12087 {
12088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12089 }
12090 {
12091 if (temp2)
12092 delete arg2;
12093 }
12094 {
12095 if (temp3)
12096 delete arg3;
12097 }
12098 return resultobj;
12099 fail:
12100 {
12101 if (temp2)
12102 delete arg2;
12103 }
12104 {
12105 if (temp3)
12106 delete arg3;
12107 }
12108 return NULL;
12109 }
12110
12111
12112 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12113 PyObject *resultobj;
12114 wxInputStream *arg1 = 0 ;
12115 bool result;
12116 wxPyInputStream *temp1 ;
12117 bool created1 ;
12118 PyObject * obj0 = 0 ;
12119 char *kwnames[] = {
12120 (char *) "stream", NULL
12121 };
12122
12123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12124 {
12125 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12126 arg1 = temp1->m_wxis;
12127 created1 = false;
12128 } else {
12129 PyErr_Clear(); // clear the failure of the wxPyConvert above
12130 arg1 = wxPyCBInputStream_create(obj0, false);
12131 if (arg1 == NULL) {
12132 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12133 SWIG_fail;
12134 }
12135 created1 = true;
12136 }
12137 }
12138 {
12139 PyThreadState* __tstate = wxPyBeginAllowThreads();
12140 result = (bool)wxImage::CanRead(*arg1);
12141
12142 wxPyEndAllowThreads(__tstate);
12143 if (PyErr_Occurred()) SWIG_fail;
12144 }
12145 {
12146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12147 }
12148 {
12149 if (created1) delete arg1;
12150 }
12151 return resultobj;
12152 fail:
12153 {
12154 if (created1) delete arg1;
12155 }
12156 return NULL;
12157 }
12158
12159
12160 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12161 PyObject *resultobj;
12162 wxImage *arg1 = (wxImage *) 0 ;
12163 wxInputStream *arg2 = 0 ;
12164 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12165 int arg4 = (int) -1 ;
12166 bool result;
12167 wxPyInputStream *temp2 ;
12168 bool created2 ;
12169 PyObject * obj0 = 0 ;
12170 PyObject * obj1 = 0 ;
12171 PyObject * obj2 = 0 ;
12172 PyObject * obj3 = 0 ;
12173 char *kwnames[] = {
12174 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12175 };
12176
12177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12179 if (SWIG_arg_fail(1)) SWIG_fail;
12180 {
12181 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12182 arg2 = temp2->m_wxis;
12183 created2 = false;
12184 } else {
12185 PyErr_Clear(); // clear the failure of the wxPyConvert above
12186 arg2 = wxPyCBInputStream_create(obj1, false);
12187 if (arg2 == NULL) {
12188 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12189 SWIG_fail;
12190 }
12191 created2 = true;
12192 }
12193 }
12194 if (obj2) {
12195 {
12196 arg3 = (long)(SWIG_As_long(obj2));
12197 if (SWIG_arg_fail(3)) SWIG_fail;
12198 }
12199 }
12200 if (obj3) {
12201 {
12202 arg4 = (int)(SWIG_As_int(obj3));
12203 if (SWIG_arg_fail(4)) SWIG_fail;
12204 }
12205 }
12206 {
12207 PyThreadState* __tstate = wxPyBeginAllowThreads();
12208 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12209
12210 wxPyEndAllowThreads(__tstate);
12211 if (PyErr_Occurred()) SWIG_fail;
12212 }
12213 {
12214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12215 }
12216 {
12217 if (created2) delete arg2;
12218 }
12219 return resultobj;
12220 fail:
12221 {
12222 if (created2) delete arg2;
12223 }
12224 return NULL;
12225 }
12226
12227
12228 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12229 PyObject *resultobj;
12230 wxImage *arg1 = (wxImage *) 0 ;
12231 wxInputStream *arg2 = 0 ;
12232 wxString *arg3 = 0 ;
12233 int arg4 = (int) -1 ;
12234 bool result;
12235 wxPyInputStream *temp2 ;
12236 bool created2 ;
12237 bool temp3 = false ;
12238 PyObject * obj0 = 0 ;
12239 PyObject * obj1 = 0 ;
12240 PyObject * obj2 = 0 ;
12241 PyObject * obj3 = 0 ;
12242 char *kwnames[] = {
12243 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12244 };
12245
12246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12248 if (SWIG_arg_fail(1)) SWIG_fail;
12249 {
12250 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12251 arg2 = temp2->m_wxis;
12252 created2 = false;
12253 } else {
12254 PyErr_Clear(); // clear the failure of the wxPyConvert above
12255 arg2 = wxPyCBInputStream_create(obj1, false);
12256 if (arg2 == NULL) {
12257 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12258 SWIG_fail;
12259 }
12260 created2 = true;
12261 }
12262 }
12263 {
12264 arg3 = wxString_in_helper(obj2);
12265 if (arg3 == NULL) SWIG_fail;
12266 temp3 = true;
12267 }
12268 if (obj3) {
12269 {
12270 arg4 = (int)(SWIG_As_int(obj3));
12271 if (SWIG_arg_fail(4)) SWIG_fail;
12272 }
12273 }
12274 {
12275 PyThreadState* __tstate = wxPyBeginAllowThreads();
12276 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12277
12278 wxPyEndAllowThreads(__tstate);
12279 if (PyErr_Occurred()) SWIG_fail;
12280 }
12281 {
12282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12283 }
12284 {
12285 if (created2) delete arg2;
12286 }
12287 {
12288 if (temp3)
12289 delete arg3;
12290 }
12291 return resultobj;
12292 fail:
12293 {
12294 if (created2) delete arg2;
12295 }
12296 {
12297 if (temp3)
12298 delete arg3;
12299 }
12300 return NULL;
12301 }
12302
12303
12304 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12305 PyObject *resultobj;
12306 wxImage *arg1 = (wxImage *) 0 ;
12307 bool result;
12308 PyObject * obj0 = 0 ;
12309 char *kwnames[] = {
12310 (char *) "self", NULL
12311 };
12312
12313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12315 if (SWIG_arg_fail(1)) SWIG_fail;
12316 {
12317 PyThreadState* __tstate = wxPyBeginAllowThreads();
12318 result = (bool)(arg1)->Ok();
12319
12320 wxPyEndAllowThreads(__tstate);
12321 if (PyErr_Occurred()) SWIG_fail;
12322 }
12323 {
12324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12325 }
12326 return resultobj;
12327 fail:
12328 return NULL;
12329 }
12330
12331
12332 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12333 PyObject *resultobj;
12334 wxImage *arg1 = (wxImage *) 0 ;
12335 int result;
12336 PyObject * obj0 = 0 ;
12337 char *kwnames[] = {
12338 (char *) "self", NULL
12339 };
12340
12341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12343 if (SWIG_arg_fail(1)) SWIG_fail;
12344 {
12345 PyThreadState* __tstate = wxPyBeginAllowThreads();
12346 result = (int)(arg1)->GetWidth();
12347
12348 wxPyEndAllowThreads(__tstate);
12349 if (PyErr_Occurred()) SWIG_fail;
12350 }
12351 {
12352 resultobj = SWIG_From_int((int)(result));
12353 }
12354 return resultobj;
12355 fail:
12356 return NULL;
12357 }
12358
12359
12360 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12361 PyObject *resultobj;
12362 wxImage *arg1 = (wxImage *) 0 ;
12363 int result;
12364 PyObject * obj0 = 0 ;
12365 char *kwnames[] = {
12366 (char *) "self", NULL
12367 };
12368
12369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12371 if (SWIG_arg_fail(1)) SWIG_fail;
12372 {
12373 PyThreadState* __tstate = wxPyBeginAllowThreads();
12374 result = (int)(arg1)->GetHeight();
12375
12376 wxPyEndAllowThreads(__tstate);
12377 if (PyErr_Occurred()) SWIG_fail;
12378 }
12379 {
12380 resultobj = SWIG_From_int((int)(result));
12381 }
12382 return resultobj;
12383 fail:
12384 return NULL;
12385 }
12386
12387
12388 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12389 PyObject *resultobj;
12390 wxImage *arg1 = (wxImage *) 0 ;
12391 wxSize result;
12392 PyObject * obj0 = 0 ;
12393 char *kwnames[] = {
12394 (char *) "self", NULL
12395 };
12396
12397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12399 if (SWIG_arg_fail(1)) SWIG_fail;
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = wxImage_GetSize(arg1);
12403
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 {
12408 wxSize * resultptr;
12409 resultptr = new wxSize((wxSize &)(result));
12410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12411 }
12412 return resultobj;
12413 fail:
12414 return NULL;
12415 }
12416
12417
12418 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12419 PyObject *resultobj;
12420 wxImage *arg1 = (wxImage *) 0 ;
12421 wxRect *arg2 = 0 ;
12422 SwigValueWrapper<wxImage > result;
12423 wxRect temp2 ;
12424 PyObject * obj0 = 0 ;
12425 PyObject * obj1 = 0 ;
12426 char *kwnames[] = {
12427 (char *) "self",(char *) "rect", NULL
12428 };
12429
12430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12432 if (SWIG_arg_fail(1)) SWIG_fail;
12433 {
12434 arg2 = &temp2;
12435 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12436 }
12437 {
12438 PyThreadState* __tstate = wxPyBeginAllowThreads();
12439 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12440
12441 wxPyEndAllowThreads(__tstate);
12442 if (PyErr_Occurred()) SWIG_fail;
12443 }
12444 {
12445 wxImage * resultptr;
12446 resultptr = new wxImage((wxImage &)(result));
12447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12448 }
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj;
12457 wxImage *arg1 = (wxImage *) 0 ;
12458 wxSize *arg2 = 0 ;
12459 wxPoint *arg3 = 0 ;
12460 int arg4 = (int) -1 ;
12461 int arg5 = (int) -1 ;
12462 int arg6 = (int) -1 ;
12463 SwigValueWrapper<wxImage > result;
12464 wxSize temp2 ;
12465 wxPoint temp3 ;
12466 PyObject * obj0 = 0 ;
12467 PyObject * obj1 = 0 ;
12468 PyObject * obj2 = 0 ;
12469 PyObject * obj3 = 0 ;
12470 PyObject * obj4 = 0 ;
12471 PyObject * obj5 = 0 ;
12472 char *kwnames[] = {
12473 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12474 };
12475
12476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12478 if (SWIG_arg_fail(1)) SWIG_fail;
12479 {
12480 arg2 = &temp2;
12481 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12482 }
12483 {
12484 arg3 = &temp3;
12485 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12486 }
12487 if (obj3) {
12488 {
12489 arg4 = (int)(SWIG_As_int(obj3));
12490 if (SWIG_arg_fail(4)) SWIG_fail;
12491 }
12492 }
12493 if (obj4) {
12494 {
12495 arg5 = (int)(SWIG_As_int(obj4));
12496 if (SWIG_arg_fail(5)) SWIG_fail;
12497 }
12498 }
12499 if (obj5) {
12500 {
12501 arg6 = (int)(SWIG_As_int(obj5));
12502 if (SWIG_arg_fail(6)) SWIG_fail;
12503 }
12504 }
12505 {
12506 PyThreadState* __tstate = wxPyBeginAllowThreads();
12507 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12508
12509 wxPyEndAllowThreads(__tstate);
12510 if (PyErr_Occurred()) SWIG_fail;
12511 }
12512 {
12513 wxImage * resultptr;
12514 resultptr = new wxImage((wxImage &)(result));
12515 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12516 }
12517 return resultobj;
12518 fail:
12519 return NULL;
12520 }
12521
12522
12523 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12524 PyObject *resultobj;
12525 wxImage *arg1 = (wxImage *) 0 ;
12526 SwigValueWrapper<wxImage > result;
12527 PyObject * obj0 = 0 ;
12528 char *kwnames[] = {
12529 (char *) "self", NULL
12530 };
12531
12532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12534 if (SWIG_arg_fail(1)) SWIG_fail;
12535 {
12536 PyThreadState* __tstate = wxPyBeginAllowThreads();
12537 result = (arg1)->Copy();
12538
12539 wxPyEndAllowThreads(__tstate);
12540 if (PyErr_Occurred()) SWIG_fail;
12541 }
12542 {
12543 wxImage * resultptr;
12544 resultptr = new wxImage((wxImage &)(result));
12545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12546 }
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12554 PyObject *resultobj;
12555 wxImage *arg1 = (wxImage *) 0 ;
12556 wxImage *arg2 = 0 ;
12557 int arg3 ;
12558 int arg4 ;
12559 PyObject * obj0 = 0 ;
12560 PyObject * obj1 = 0 ;
12561 PyObject * obj2 = 0 ;
12562 PyObject * obj3 = 0 ;
12563 char *kwnames[] = {
12564 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12565 };
12566
12567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12569 if (SWIG_arg_fail(1)) SWIG_fail;
12570 {
12571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12572 if (SWIG_arg_fail(2)) SWIG_fail;
12573 if (arg2 == NULL) {
12574 SWIG_null_ref("wxImage");
12575 }
12576 if (SWIG_arg_fail(2)) SWIG_fail;
12577 }
12578 {
12579 arg3 = (int)(SWIG_As_int(obj2));
12580 if (SWIG_arg_fail(3)) SWIG_fail;
12581 }
12582 {
12583 arg4 = (int)(SWIG_As_int(obj3));
12584 if (SWIG_arg_fail(4)) SWIG_fail;
12585 }
12586 {
12587 PyThreadState* __tstate = wxPyBeginAllowThreads();
12588 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12589
12590 wxPyEndAllowThreads(__tstate);
12591 if (PyErr_Occurred()) SWIG_fail;
12592 }
12593 Py_INCREF(Py_None); resultobj = Py_None;
12594 return resultobj;
12595 fail:
12596 return NULL;
12597 }
12598
12599
12600 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12601 PyObject *resultobj;
12602 wxImage *arg1 = (wxImage *) 0 ;
12603 PyObject *result;
12604 PyObject * obj0 = 0 ;
12605 char *kwnames[] = {
12606 (char *) "self", NULL
12607 };
12608
12609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12611 if (SWIG_arg_fail(1)) SWIG_fail;
12612 {
12613 PyThreadState* __tstate = wxPyBeginAllowThreads();
12614 result = (PyObject *)wxImage_GetData(arg1);
12615
12616 wxPyEndAllowThreads(__tstate);
12617 if (PyErr_Occurred()) SWIG_fail;
12618 }
12619 resultobj = result;
12620 return resultobj;
12621 fail:
12622 return NULL;
12623 }
12624
12625
12626 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12627 PyObject *resultobj;
12628 wxImage *arg1 = (wxImage *) 0 ;
12629 buffer arg2 ;
12630 int arg3 ;
12631 PyObject * obj0 = 0 ;
12632 PyObject * obj1 = 0 ;
12633 char *kwnames[] = {
12634 (char *) "self",(char *) "data", NULL
12635 };
12636
12637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",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 {
12641 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12642 }
12643 {
12644 PyThreadState* __tstate = wxPyBeginAllowThreads();
12645 wxImage_SetData(arg1,arg2,arg3);
12646
12647 wxPyEndAllowThreads(__tstate);
12648 if (PyErr_Occurred()) SWIG_fail;
12649 }
12650 Py_INCREF(Py_None); resultobj = Py_None;
12651 return resultobj;
12652 fail:
12653 return NULL;
12654 }
12655
12656
12657 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12658 PyObject *resultobj;
12659 wxImage *arg1 = (wxImage *) 0 ;
12660 PyObject *result;
12661 PyObject * obj0 = 0 ;
12662 char *kwnames[] = {
12663 (char *) "self", NULL
12664 };
12665
12666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12668 if (SWIG_arg_fail(1)) SWIG_fail;
12669 {
12670 PyThreadState* __tstate = wxPyBeginAllowThreads();
12671 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12672
12673 wxPyEndAllowThreads(__tstate);
12674 if (PyErr_Occurred()) SWIG_fail;
12675 }
12676 resultobj = result;
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12684 PyObject *resultobj;
12685 wxImage *arg1 = (wxImage *) 0 ;
12686 buffer arg2 ;
12687 int arg3 ;
12688 PyObject * obj0 = 0 ;
12689 PyObject * obj1 = 0 ;
12690 char *kwnames[] = {
12691 (char *) "self",(char *) "data", NULL
12692 };
12693
12694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12696 if (SWIG_arg_fail(1)) SWIG_fail;
12697 {
12698 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12699 }
12700 {
12701 PyThreadState* __tstate = wxPyBeginAllowThreads();
12702 wxImage_SetDataBuffer(arg1,arg2,arg3);
12703
12704 wxPyEndAllowThreads(__tstate);
12705 if (PyErr_Occurred()) SWIG_fail;
12706 }
12707 Py_INCREF(Py_None); resultobj = Py_None;
12708 return resultobj;
12709 fail:
12710 return NULL;
12711 }
12712
12713
12714 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12715 PyObject *resultobj;
12716 wxImage *arg1 = (wxImage *) 0 ;
12717 PyObject *result;
12718 PyObject * obj0 = 0 ;
12719 char *kwnames[] = {
12720 (char *) "self", NULL
12721 };
12722
12723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12725 if (SWIG_arg_fail(1)) SWIG_fail;
12726 {
12727 PyThreadState* __tstate = wxPyBeginAllowThreads();
12728 result = (PyObject *)wxImage_GetAlphaData(arg1);
12729
12730 wxPyEndAllowThreads(__tstate);
12731 if (PyErr_Occurred()) SWIG_fail;
12732 }
12733 resultobj = result;
12734 return resultobj;
12735 fail:
12736 return NULL;
12737 }
12738
12739
12740 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12741 PyObject *resultobj;
12742 wxImage *arg1 = (wxImage *) 0 ;
12743 buffer arg2 ;
12744 int arg3 ;
12745 PyObject * obj0 = 0 ;
12746 PyObject * obj1 = 0 ;
12747 char *kwnames[] = {
12748 (char *) "self",(char *) "alpha", NULL
12749 };
12750
12751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12753 if (SWIG_arg_fail(1)) SWIG_fail;
12754 {
12755 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12756 }
12757 {
12758 PyThreadState* __tstate = wxPyBeginAllowThreads();
12759 wxImage_SetAlphaData(arg1,arg2,arg3);
12760
12761 wxPyEndAllowThreads(__tstate);
12762 if (PyErr_Occurred()) SWIG_fail;
12763 }
12764 Py_INCREF(Py_None); resultobj = Py_None;
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12772 PyObject *resultobj;
12773 wxImage *arg1 = (wxImage *) 0 ;
12774 PyObject *result;
12775 PyObject * obj0 = 0 ;
12776 char *kwnames[] = {
12777 (char *) "self", NULL
12778 };
12779
12780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12782 if (SWIG_arg_fail(1)) SWIG_fail;
12783 {
12784 PyThreadState* __tstate = wxPyBeginAllowThreads();
12785 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12786
12787 wxPyEndAllowThreads(__tstate);
12788 if (PyErr_Occurred()) SWIG_fail;
12789 }
12790 resultobj = result;
12791 return resultobj;
12792 fail:
12793 return NULL;
12794 }
12795
12796
12797 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12798 PyObject *resultobj;
12799 wxImage *arg1 = (wxImage *) 0 ;
12800 buffer arg2 ;
12801 int arg3 ;
12802 PyObject * obj0 = 0 ;
12803 PyObject * obj1 = 0 ;
12804 char *kwnames[] = {
12805 (char *) "self",(char *) "alpha", NULL
12806 };
12807
12808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12810 if (SWIG_arg_fail(1)) SWIG_fail;
12811 {
12812 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12813 }
12814 {
12815 PyThreadState* __tstate = wxPyBeginAllowThreads();
12816 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12817
12818 wxPyEndAllowThreads(__tstate);
12819 if (PyErr_Occurred()) SWIG_fail;
12820 }
12821 Py_INCREF(Py_None); resultobj = Py_None;
12822 return resultobj;
12823 fail:
12824 return NULL;
12825 }
12826
12827
12828 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12829 PyObject *resultobj;
12830 wxImage *arg1 = (wxImage *) 0 ;
12831 unsigned char arg2 ;
12832 unsigned char arg3 ;
12833 unsigned char arg4 ;
12834 PyObject * obj0 = 0 ;
12835 PyObject * obj1 = 0 ;
12836 PyObject * obj2 = 0 ;
12837 PyObject * obj3 = 0 ;
12838 char *kwnames[] = {
12839 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12840 };
12841
12842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12844 if (SWIG_arg_fail(1)) SWIG_fail;
12845 {
12846 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12847 if (SWIG_arg_fail(2)) SWIG_fail;
12848 }
12849 {
12850 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12851 if (SWIG_arg_fail(3)) SWIG_fail;
12852 }
12853 {
12854 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12855 if (SWIG_arg_fail(4)) SWIG_fail;
12856 }
12857 {
12858 PyThreadState* __tstate = wxPyBeginAllowThreads();
12859 (arg1)->SetMaskColour(arg2,arg3,arg4);
12860
12861 wxPyEndAllowThreads(__tstate);
12862 if (PyErr_Occurred()) SWIG_fail;
12863 }
12864 Py_INCREF(Py_None); resultobj = Py_None;
12865 return resultobj;
12866 fail:
12867 return NULL;
12868 }
12869
12870
12871 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12872 PyObject *resultobj;
12873 wxImage *arg1 = (wxImage *) 0 ;
12874 unsigned char *arg2 = (unsigned char *) 0 ;
12875 unsigned char *arg3 = (unsigned char *) 0 ;
12876 unsigned char *arg4 = (unsigned char *) 0 ;
12877 unsigned char temp2 ;
12878 int res2 = 0 ;
12879 unsigned char temp3 ;
12880 int res3 = 0 ;
12881 unsigned char temp4 ;
12882 int res4 = 0 ;
12883 PyObject * obj0 = 0 ;
12884 char *kwnames[] = {
12885 (char *) "self", NULL
12886 };
12887
12888 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12889 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12890 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12893 if (SWIG_arg_fail(1)) SWIG_fail;
12894 {
12895 PyThreadState* __tstate = wxPyBeginAllowThreads();
12896 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12897
12898 wxPyEndAllowThreads(__tstate);
12899 if (PyErr_Occurred()) SWIG_fail;
12900 }
12901 Py_INCREF(Py_None); resultobj = Py_None;
12902 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12903 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12904 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12905 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12906 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12907 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12908 return resultobj;
12909 fail:
12910 return NULL;
12911 }
12912
12913
12914 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12915 PyObject *resultobj;
12916 wxImage *arg1 = (wxImage *) 0 ;
12917 unsigned char result;
12918 PyObject * obj0 = 0 ;
12919 char *kwnames[] = {
12920 (char *) "self", NULL
12921 };
12922
12923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12925 if (SWIG_arg_fail(1)) SWIG_fail;
12926 {
12927 PyThreadState* __tstate = wxPyBeginAllowThreads();
12928 result = (unsigned char)(arg1)->GetMaskRed();
12929
12930 wxPyEndAllowThreads(__tstate);
12931 if (PyErr_Occurred()) SWIG_fail;
12932 }
12933 {
12934 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12935 }
12936 return resultobj;
12937 fail:
12938 return NULL;
12939 }
12940
12941
12942 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12943 PyObject *resultobj;
12944 wxImage *arg1 = (wxImage *) 0 ;
12945 unsigned char result;
12946 PyObject * obj0 = 0 ;
12947 char *kwnames[] = {
12948 (char *) "self", NULL
12949 };
12950
12951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12953 if (SWIG_arg_fail(1)) SWIG_fail;
12954 {
12955 PyThreadState* __tstate = wxPyBeginAllowThreads();
12956 result = (unsigned char)(arg1)->GetMaskGreen();
12957
12958 wxPyEndAllowThreads(__tstate);
12959 if (PyErr_Occurred()) SWIG_fail;
12960 }
12961 {
12962 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12963 }
12964 return resultobj;
12965 fail:
12966 return NULL;
12967 }
12968
12969
12970 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12971 PyObject *resultobj;
12972 wxImage *arg1 = (wxImage *) 0 ;
12973 unsigned char result;
12974 PyObject * obj0 = 0 ;
12975 char *kwnames[] = {
12976 (char *) "self", NULL
12977 };
12978
12979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12981 if (SWIG_arg_fail(1)) SWIG_fail;
12982 {
12983 PyThreadState* __tstate = wxPyBeginAllowThreads();
12984 result = (unsigned char)(arg1)->GetMaskBlue();
12985
12986 wxPyEndAllowThreads(__tstate);
12987 if (PyErr_Occurred()) SWIG_fail;
12988 }
12989 {
12990 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12991 }
12992 return resultobj;
12993 fail:
12994 return NULL;
12995 }
12996
12997
12998 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12999 PyObject *resultobj;
13000 wxImage *arg1 = (wxImage *) 0 ;
13001 bool arg2 = (bool) true ;
13002 PyObject * obj0 = 0 ;
13003 PyObject * obj1 = 0 ;
13004 char *kwnames[] = {
13005 (char *) "self",(char *) "mask", NULL
13006 };
13007
13008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13010 if (SWIG_arg_fail(1)) SWIG_fail;
13011 if (obj1) {
13012 {
13013 arg2 = (bool)(SWIG_As_bool(obj1));
13014 if (SWIG_arg_fail(2)) SWIG_fail;
13015 }
13016 }
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 (arg1)->SetMask(arg2);
13020
13021 wxPyEndAllowThreads(__tstate);
13022 if (PyErr_Occurred()) SWIG_fail;
13023 }
13024 Py_INCREF(Py_None); resultobj = Py_None;
13025 return resultobj;
13026 fail:
13027 return NULL;
13028 }
13029
13030
13031 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13032 PyObject *resultobj;
13033 wxImage *arg1 = (wxImage *) 0 ;
13034 bool result;
13035 PyObject * obj0 = 0 ;
13036 char *kwnames[] = {
13037 (char *) "self", NULL
13038 };
13039
13040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13042 if (SWIG_arg_fail(1)) SWIG_fail;
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 result = (bool)(arg1)->HasMask();
13046
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 {
13051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13052 }
13053 return resultobj;
13054 fail:
13055 return NULL;
13056 }
13057
13058
13059 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13060 PyObject *resultobj;
13061 wxImage *arg1 = (wxImage *) 0 ;
13062 double arg2 ;
13063 wxPoint *arg3 = 0 ;
13064 bool arg4 = (bool) true ;
13065 wxPoint *arg5 = (wxPoint *) NULL ;
13066 SwigValueWrapper<wxImage > result;
13067 wxPoint temp3 ;
13068 PyObject * obj0 = 0 ;
13069 PyObject * obj1 = 0 ;
13070 PyObject * obj2 = 0 ;
13071 PyObject * obj3 = 0 ;
13072 PyObject * obj4 = 0 ;
13073 char *kwnames[] = {
13074 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13075 };
13076
13077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13079 if (SWIG_arg_fail(1)) SWIG_fail;
13080 {
13081 arg2 = (double)(SWIG_As_double(obj1));
13082 if (SWIG_arg_fail(2)) SWIG_fail;
13083 }
13084 {
13085 arg3 = &temp3;
13086 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13087 }
13088 if (obj3) {
13089 {
13090 arg4 = (bool)(SWIG_As_bool(obj3));
13091 if (SWIG_arg_fail(4)) SWIG_fail;
13092 }
13093 }
13094 if (obj4) {
13095 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13096 if (SWIG_arg_fail(5)) SWIG_fail;
13097 }
13098 {
13099 PyThreadState* __tstate = wxPyBeginAllowThreads();
13100 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13101
13102 wxPyEndAllowThreads(__tstate);
13103 if (PyErr_Occurred()) SWIG_fail;
13104 }
13105 {
13106 wxImage * resultptr;
13107 resultptr = new wxImage((wxImage &)(result));
13108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13109 }
13110 return resultobj;
13111 fail:
13112 return NULL;
13113 }
13114
13115
13116 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13117 PyObject *resultobj;
13118 wxImage *arg1 = (wxImage *) 0 ;
13119 bool arg2 = (bool) true ;
13120 SwigValueWrapper<wxImage > result;
13121 PyObject * obj0 = 0 ;
13122 PyObject * obj1 = 0 ;
13123 char *kwnames[] = {
13124 (char *) "self",(char *) "clockwise", NULL
13125 };
13126
13127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13129 if (SWIG_arg_fail(1)) SWIG_fail;
13130 if (obj1) {
13131 {
13132 arg2 = (bool)(SWIG_As_bool(obj1));
13133 if (SWIG_arg_fail(2)) SWIG_fail;
13134 }
13135 }
13136 {
13137 PyThreadState* __tstate = wxPyBeginAllowThreads();
13138 result = (arg1)->Rotate90(arg2);
13139
13140 wxPyEndAllowThreads(__tstate);
13141 if (PyErr_Occurred()) SWIG_fail;
13142 }
13143 {
13144 wxImage * resultptr;
13145 resultptr = new wxImage((wxImage &)(result));
13146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13147 }
13148 return resultobj;
13149 fail:
13150 return NULL;
13151 }
13152
13153
13154 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13155 PyObject *resultobj;
13156 wxImage *arg1 = (wxImage *) 0 ;
13157 bool arg2 = (bool) true ;
13158 SwigValueWrapper<wxImage > result;
13159 PyObject * obj0 = 0 ;
13160 PyObject * obj1 = 0 ;
13161 char *kwnames[] = {
13162 (char *) "self",(char *) "horizontally", NULL
13163 };
13164
13165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13167 if (SWIG_arg_fail(1)) SWIG_fail;
13168 if (obj1) {
13169 {
13170 arg2 = (bool)(SWIG_As_bool(obj1));
13171 if (SWIG_arg_fail(2)) SWIG_fail;
13172 }
13173 }
13174 {
13175 PyThreadState* __tstate = wxPyBeginAllowThreads();
13176 result = (arg1)->Mirror(arg2);
13177
13178 wxPyEndAllowThreads(__tstate);
13179 if (PyErr_Occurred()) SWIG_fail;
13180 }
13181 {
13182 wxImage * resultptr;
13183 resultptr = new wxImage((wxImage &)(result));
13184 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13185 }
13186 return resultobj;
13187 fail:
13188 return NULL;
13189 }
13190
13191
13192 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13193 PyObject *resultobj;
13194 wxImage *arg1 = (wxImage *) 0 ;
13195 unsigned char arg2 ;
13196 unsigned char arg3 ;
13197 unsigned char arg4 ;
13198 unsigned char arg5 ;
13199 unsigned char arg6 ;
13200 unsigned char arg7 ;
13201 PyObject * obj0 = 0 ;
13202 PyObject * obj1 = 0 ;
13203 PyObject * obj2 = 0 ;
13204 PyObject * obj3 = 0 ;
13205 PyObject * obj4 = 0 ;
13206 PyObject * obj5 = 0 ;
13207 PyObject * obj6 = 0 ;
13208 char *kwnames[] = {
13209 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13210 };
13211
13212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13214 if (SWIG_arg_fail(1)) SWIG_fail;
13215 {
13216 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13217 if (SWIG_arg_fail(2)) SWIG_fail;
13218 }
13219 {
13220 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13221 if (SWIG_arg_fail(3)) SWIG_fail;
13222 }
13223 {
13224 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13225 if (SWIG_arg_fail(4)) SWIG_fail;
13226 }
13227 {
13228 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13229 if (SWIG_arg_fail(5)) SWIG_fail;
13230 }
13231 {
13232 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13233 if (SWIG_arg_fail(6)) SWIG_fail;
13234 }
13235 {
13236 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13237 if (SWIG_arg_fail(7)) SWIG_fail;
13238 }
13239 {
13240 PyThreadState* __tstate = wxPyBeginAllowThreads();
13241 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13242
13243 wxPyEndAllowThreads(__tstate);
13244 if (PyErr_Occurred()) SWIG_fail;
13245 }
13246 Py_INCREF(Py_None); resultobj = Py_None;
13247 return resultobj;
13248 fail:
13249 return NULL;
13250 }
13251
13252
13253 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13254 PyObject *resultobj;
13255 wxImage *arg1 = (wxImage *) 0 ;
13256 unsigned char arg2 ;
13257 unsigned char arg3 ;
13258 unsigned char arg4 ;
13259 SwigValueWrapper<wxImage > result;
13260 PyObject * obj0 = 0 ;
13261 PyObject * obj1 = 0 ;
13262 PyObject * obj2 = 0 ;
13263 PyObject * obj3 = 0 ;
13264 char *kwnames[] = {
13265 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13266 };
13267
13268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13270 if (SWIG_arg_fail(1)) SWIG_fail;
13271 {
13272 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13273 if (SWIG_arg_fail(2)) SWIG_fail;
13274 }
13275 {
13276 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13277 if (SWIG_arg_fail(3)) SWIG_fail;
13278 }
13279 {
13280 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13281 if (SWIG_arg_fail(4)) SWIG_fail;
13282 }
13283 {
13284 PyThreadState* __tstate = wxPyBeginAllowThreads();
13285 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13286
13287 wxPyEndAllowThreads(__tstate);
13288 if (PyErr_Occurred()) SWIG_fail;
13289 }
13290 {
13291 wxImage * resultptr;
13292 resultptr = new wxImage((wxImage &)(result));
13293 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13294 }
13295 return resultobj;
13296 fail:
13297 return NULL;
13298 }
13299
13300
13301 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13302 PyObject *resultobj;
13303 wxImage *arg1 = (wxImage *) 0 ;
13304 wxString *arg2 = 0 ;
13305 wxString *arg3 = 0 ;
13306 bool temp2 = false ;
13307 bool temp3 = false ;
13308 PyObject * obj0 = 0 ;
13309 PyObject * obj1 = 0 ;
13310 PyObject * obj2 = 0 ;
13311 char *kwnames[] = {
13312 (char *) "self",(char *) "name",(char *) "value", NULL
13313 };
13314
13315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13317 if (SWIG_arg_fail(1)) SWIG_fail;
13318 {
13319 arg2 = wxString_in_helper(obj1);
13320 if (arg2 == NULL) SWIG_fail;
13321 temp2 = true;
13322 }
13323 {
13324 arg3 = wxString_in_helper(obj2);
13325 if (arg3 == NULL) SWIG_fail;
13326 temp3 = true;
13327 }
13328 {
13329 PyThreadState* __tstate = wxPyBeginAllowThreads();
13330 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13331
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 Py_INCREF(Py_None); resultobj = Py_None;
13336 {
13337 if (temp2)
13338 delete arg2;
13339 }
13340 {
13341 if (temp3)
13342 delete arg3;
13343 }
13344 return resultobj;
13345 fail:
13346 {
13347 if (temp2)
13348 delete arg2;
13349 }
13350 {
13351 if (temp3)
13352 delete arg3;
13353 }
13354 return NULL;
13355 }
13356
13357
13358 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13359 PyObject *resultobj;
13360 wxImage *arg1 = (wxImage *) 0 ;
13361 wxString *arg2 = 0 ;
13362 int arg3 ;
13363 bool temp2 = false ;
13364 PyObject * obj0 = 0 ;
13365 PyObject * obj1 = 0 ;
13366 PyObject * obj2 = 0 ;
13367 char *kwnames[] = {
13368 (char *) "self",(char *) "name",(char *) "value", NULL
13369 };
13370
13371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13373 if (SWIG_arg_fail(1)) SWIG_fail;
13374 {
13375 arg2 = wxString_in_helper(obj1);
13376 if (arg2 == NULL) SWIG_fail;
13377 temp2 = true;
13378 }
13379 {
13380 arg3 = (int)(SWIG_As_int(obj2));
13381 if (SWIG_arg_fail(3)) SWIG_fail;
13382 }
13383 {
13384 PyThreadState* __tstate = wxPyBeginAllowThreads();
13385 (arg1)->SetOption((wxString const &)*arg2,arg3);
13386
13387 wxPyEndAllowThreads(__tstate);
13388 if (PyErr_Occurred()) SWIG_fail;
13389 }
13390 Py_INCREF(Py_None); resultobj = Py_None;
13391 {
13392 if (temp2)
13393 delete arg2;
13394 }
13395 return resultobj;
13396 fail:
13397 {
13398 if (temp2)
13399 delete arg2;
13400 }
13401 return NULL;
13402 }
13403
13404
13405 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13406 PyObject *resultobj;
13407 wxImage *arg1 = (wxImage *) 0 ;
13408 wxString *arg2 = 0 ;
13409 wxString result;
13410 bool temp2 = false ;
13411 PyObject * obj0 = 0 ;
13412 PyObject * obj1 = 0 ;
13413 char *kwnames[] = {
13414 (char *) "self",(char *) "name", NULL
13415 };
13416
13417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13419 if (SWIG_arg_fail(1)) SWIG_fail;
13420 {
13421 arg2 = wxString_in_helper(obj1);
13422 if (arg2 == NULL) SWIG_fail;
13423 temp2 = true;
13424 }
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13428
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 {
13433 #if wxUSE_UNICODE
13434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13435 #else
13436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13437 #endif
13438 }
13439 {
13440 if (temp2)
13441 delete arg2;
13442 }
13443 return resultobj;
13444 fail:
13445 {
13446 if (temp2)
13447 delete arg2;
13448 }
13449 return NULL;
13450 }
13451
13452
13453 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13454 PyObject *resultobj;
13455 wxImage *arg1 = (wxImage *) 0 ;
13456 wxString *arg2 = 0 ;
13457 int result;
13458 bool temp2 = false ;
13459 PyObject * obj0 = 0 ;
13460 PyObject * obj1 = 0 ;
13461 char *kwnames[] = {
13462 (char *) "self",(char *) "name", NULL
13463 };
13464
13465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13467 if (SWIG_arg_fail(1)) SWIG_fail;
13468 {
13469 arg2 = wxString_in_helper(obj1);
13470 if (arg2 == NULL) SWIG_fail;
13471 temp2 = true;
13472 }
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13476
13477 wxPyEndAllowThreads(__tstate);
13478 if (PyErr_Occurred()) SWIG_fail;
13479 }
13480 {
13481 resultobj = SWIG_From_int((int)(result));
13482 }
13483 {
13484 if (temp2)
13485 delete arg2;
13486 }
13487 return resultobj;
13488 fail:
13489 {
13490 if (temp2)
13491 delete arg2;
13492 }
13493 return NULL;
13494 }
13495
13496
13497 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13498 PyObject *resultobj;
13499 wxImage *arg1 = (wxImage *) 0 ;
13500 wxString *arg2 = 0 ;
13501 bool result;
13502 bool temp2 = false ;
13503 PyObject * obj0 = 0 ;
13504 PyObject * obj1 = 0 ;
13505 char *kwnames[] = {
13506 (char *) "self",(char *) "name", NULL
13507 };
13508
13509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13511 if (SWIG_arg_fail(1)) SWIG_fail;
13512 {
13513 arg2 = wxString_in_helper(obj1);
13514 if (arg2 == NULL) SWIG_fail;
13515 temp2 = true;
13516 }
13517 {
13518 PyThreadState* __tstate = wxPyBeginAllowThreads();
13519 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13520
13521 wxPyEndAllowThreads(__tstate);
13522 if (PyErr_Occurred()) SWIG_fail;
13523 }
13524 {
13525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13526 }
13527 {
13528 if (temp2)
13529 delete arg2;
13530 }
13531 return resultobj;
13532 fail:
13533 {
13534 if (temp2)
13535 delete arg2;
13536 }
13537 return NULL;
13538 }
13539
13540
13541 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj;
13543 wxImage *arg1 = (wxImage *) 0 ;
13544 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13545 unsigned long result;
13546 PyObject * obj0 = 0 ;
13547 PyObject * obj1 = 0 ;
13548 char *kwnames[] = {
13549 (char *) "self",(char *) "stopafter", NULL
13550 };
13551
13552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13554 if (SWIG_arg_fail(1)) SWIG_fail;
13555 if (obj1) {
13556 {
13557 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13558 if (SWIG_arg_fail(2)) SWIG_fail;
13559 }
13560 }
13561 {
13562 PyThreadState* __tstate = wxPyBeginAllowThreads();
13563 result = (unsigned long)(arg1)->CountColours(arg2);
13564
13565 wxPyEndAllowThreads(__tstate);
13566 if (PyErr_Occurred()) SWIG_fail;
13567 }
13568 {
13569 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13570 }
13571 return resultobj;
13572 fail:
13573 return NULL;
13574 }
13575
13576
13577 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13578 PyObject *resultobj;
13579 wxImage *arg1 = (wxImage *) 0 ;
13580 wxImageHistogram *arg2 = 0 ;
13581 unsigned long result;
13582 PyObject * obj0 = 0 ;
13583 PyObject * obj1 = 0 ;
13584 char *kwnames[] = {
13585 (char *) "self",(char *) "h", NULL
13586 };
13587
13588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13590 if (SWIG_arg_fail(1)) SWIG_fail;
13591 {
13592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13593 if (SWIG_arg_fail(2)) SWIG_fail;
13594 if (arg2 == NULL) {
13595 SWIG_null_ref("wxImageHistogram");
13596 }
13597 if (SWIG_arg_fail(2)) SWIG_fail;
13598 }
13599 {
13600 PyThreadState* __tstate = wxPyBeginAllowThreads();
13601 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13602
13603 wxPyEndAllowThreads(__tstate);
13604 if (PyErr_Occurred()) SWIG_fail;
13605 }
13606 {
13607 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13608 }
13609 return resultobj;
13610 fail:
13611 return NULL;
13612 }
13613
13614
13615 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13616 PyObject *resultobj;
13617 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13618 PyObject * obj0 = 0 ;
13619 char *kwnames[] = {
13620 (char *) "handler", NULL
13621 };
13622
13623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13625 if (SWIG_arg_fail(1)) SWIG_fail;
13626 {
13627 PyThreadState* __tstate = wxPyBeginAllowThreads();
13628 wxImage::AddHandler(arg1);
13629
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 Py_INCREF(Py_None); resultobj = Py_None;
13634 return resultobj;
13635 fail:
13636 return NULL;
13637 }
13638
13639
13640 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13641 PyObject *resultobj;
13642 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13643 PyObject * obj0 = 0 ;
13644 char *kwnames[] = {
13645 (char *) "handler", NULL
13646 };
13647
13648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13650 if (SWIG_arg_fail(1)) SWIG_fail;
13651 {
13652 PyThreadState* __tstate = wxPyBeginAllowThreads();
13653 wxImage::InsertHandler(arg1);
13654
13655 wxPyEndAllowThreads(__tstate);
13656 if (PyErr_Occurred()) SWIG_fail;
13657 }
13658 Py_INCREF(Py_None); resultobj = Py_None;
13659 return resultobj;
13660 fail:
13661 return NULL;
13662 }
13663
13664
13665 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13666 PyObject *resultobj;
13667 wxString *arg1 = 0 ;
13668 bool result;
13669 bool temp1 = false ;
13670 PyObject * obj0 = 0 ;
13671 char *kwnames[] = {
13672 (char *) "name", NULL
13673 };
13674
13675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13676 {
13677 arg1 = wxString_in_helper(obj0);
13678 if (arg1 == NULL) SWIG_fail;
13679 temp1 = true;
13680 }
13681 {
13682 PyThreadState* __tstate = wxPyBeginAllowThreads();
13683 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13684
13685 wxPyEndAllowThreads(__tstate);
13686 if (PyErr_Occurred()) SWIG_fail;
13687 }
13688 {
13689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13690 }
13691 {
13692 if (temp1)
13693 delete arg1;
13694 }
13695 return resultobj;
13696 fail:
13697 {
13698 if (temp1)
13699 delete arg1;
13700 }
13701 return NULL;
13702 }
13703
13704
13705 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13706 PyObject *resultobj;
13707 wxString result;
13708 char *kwnames[] = {
13709 NULL
13710 };
13711
13712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13713 {
13714 PyThreadState* __tstate = wxPyBeginAllowThreads();
13715 result = wxImage::GetImageExtWildcard();
13716
13717 wxPyEndAllowThreads(__tstate);
13718 if (PyErr_Occurred()) SWIG_fail;
13719 }
13720 {
13721 #if wxUSE_UNICODE
13722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13723 #else
13724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13725 #endif
13726 }
13727 return resultobj;
13728 fail:
13729 return NULL;
13730 }
13731
13732
13733 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj;
13735 wxImage *arg1 = (wxImage *) 0 ;
13736 int arg2 = (int) -1 ;
13737 wxBitmap result;
13738 PyObject * obj0 = 0 ;
13739 PyObject * obj1 = 0 ;
13740 char *kwnames[] = {
13741 (char *) "self",(char *) "depth", NULL
13742 };
13743
13744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13746 if (SWIG_arg_fail(1)) SWIG_fail;
13747 if (obj1) {
13748 {
13749 arg2 = (int)(SWIG_As_int(obj1));
13750 if (SWIG_arg_fail(2)) SWIG_fail;
13751 }
13752 }
13753 {
13754 if (!wxPyCheckForApp()) SWIG_fail;
13755 PyThreadState* __tstate = wxPyBeginAllowThreads();
13756 result = wxImage_ConvertToBitmap(arg1,arg2);
13757
13758 wxPyEndAllowThreads(__tstate);
13759 if (PyErr_Occurred()) SWIG_fail;
13760 }
13761 {
13762 wxBitmap * resultptr;
13763 resultptr = new wxBitmap((wxBitmap &)(result));
13764 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13765 }
13766 return resultobj;
13767 fail:
13768 return NULL;
13769 }
13770
13771
13772 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13773 PyObject *resultobj;
13774 wxImage *arg1 = (wxImage *) 0 ;
13775 unsigned char arg2 ;
13776 unsigned char arg3 ;
13777 unsigned char arg4 ;
13778 wxBitmap result;
13779 PyObject * obj0 = 0 ;
13780 PyObject * obj1 = 0 ;
13781 PyObject * obj2 = 0 ;
13782 PyObject * obj3 = 0 ;
13783 char *kwnames[] = {
13784 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13785 };
13786
13787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13789 if (SWIG_arg_fail(1)) SWIG_fail;
13790 {
13791 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13792 if (SWIG_arg_fail(2)) SWIG_fail;
13793 }
13794 {
13795 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13796 if (SWIG_arg_fail(3)) SWIG_fail;
13797 }
13798 {
13799 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13800 if (SWIG_arg_fail(4)) SWIG_fail;
13801 }
13802 {
13803 if (!wxPyCheckForApp()) SWIG_fail;
13804 PyThreadState* __tstate = wxPyBeginAllowThreads();
13805 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13806
13807 wxPyEndAllowThreads(__tstate);
13808 if (PyErr_Occurred()) SWIG_fail;
13809 }
13810 {
13811 wxBitmap * resultptr;
13812 resultptr = new wxBitmap((wxBitmap &)(result));
13813 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13814 }
13815 return resultobj;
13816 fail:
13817 return NULL;
13818 }
13819
13820
13821 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13822 PyObject *obj;
13823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13824 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13825 Py_INCREF(obj);
13826 return Py_BuildValue((char *)"");
13827 }
13828 static int _wrap_NullImage_set(PyObject *) {
13829 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13830 return 1;
13831 }
13832
13833
13834 static PyObject *_wrap_NullImage_get(void) {
13835 PyObject *pyobj;
13836
13837 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13838 return pyobj;
13839 }
13840
13841
13842 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13843 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13844 return 1;
13845 }
13846
13847
13848 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13849 PyObject *pyobj;
13850
13851 {
13852 #if wxUSE_UNICODE
13853 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13854 #else
13855 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13856 #endif
13857 }
13858 return pyobj;
13859 }
13860
13861
13862 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13863 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13864 return 1;
13865 }
13866
13867
13868 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13869 PyObject *pyobj;
13870
13871 {
13872 #if wxUSE_UNICODE
13873 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13874 #else
13875 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13876 #endif
13877 }
13878 return pyobj;
13879 }
13880
13881
13882 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13883 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13884 return 1;
13885 }
13886
13887
13888 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13889 PyObject *pyobj;
13890
13891 {
13892 #if wxUSE_UNICODE
13893 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13894 #else
13895 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13896 #endif
13897 }
13898 return pyobj;
13899 }
13900
13901
13902 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13903 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13904 return 1;
13905 }
13906
13907
13908 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13909 PyObject *pyobj;
13910
13911 {
13912 #if wxUSE_UNICODE
13913 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13914 #else
13915 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13916 #endif
13917 }
13918 return pyobj;
13919 }
13920
13921
13922 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13923 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13924 return 1;
13925 }
13926
13927
13928 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13929 PyObject *pyobj;
13930
13931 {
13932 #if wxUSE_UNICODE
13933 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13934 #else
13935 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13936 #endif
13937 }
13938 return pyobj;
13939 }
13940
13941
13942 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13943 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13944 return 1;
13945 }
13946
13947
13948 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13949 PyObject *pyobj;
13950
13951 {
13952 #if wxUSE_UNICODE
13953 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13954 #else
13955 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13956 #endif
13957 }
13958 return pyobj;
13959 }
13960
13961
13962 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13963 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13964 return 1;
13965 }
13966
13967
13968 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13969 PyObject *pyobj;
13970
13971 {
13972 #if wxUSE_UNICODE
13973 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13974 #else
13975 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13976 #endif
13977 }
13978 return pyobj;
13979 }
13980
13981
13982 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13983 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13984 return 1;
13985 }
13986
13987
13988 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13989 PyObject *pyobj;
13990
13991 {
13992 #if wxUSE_UNICODE
13993 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13994 #else
13995 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13996 #endif
13997 }
13998 return pyobj;
13999 }
14000
14001
14002 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14003 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14004 return 1;
14005 }
14006
14007
14008 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14009 PyObject *pyobj;
14010
14011 {
14012 #if wxUSE_UNICODE
14013 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14014 #else
14015 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14016 #endif
14017 }
14018 return pyobj;
14019 }
14020
14021
14022 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14023 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14024 return 1;
14025 }
14026
14027
14028 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14029 PyObject *pyobj;
14030
14031 {
14032 #if wxUSE_UNICODE
14033 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14034 #else
14035 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14036 #endif
14037 }
14038 return pyobj;
14039 }
14040
14041
14042 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14043 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14044 return 1;
14045 }
14046
14047
14048 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14049 PyObject *pyobj;
14050
14051 {
14052 #if wxUSE_UNICODE
14053 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14054 #else
14055 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14056 #endif
14057 }
14058 return pyobj;
14059 }
14060
14061
14062 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14063 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14064 return 1;
14065 }
14066
14067
14068 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14069 PyObject *pyobj;
14070
14071 {
14072 #if wxUSE_UNICODE
14073 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14074 #else
14075 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14076 #endif
14077 }
14078 return pyobj;
14079 }
14080
14081
14082 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14083 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14084 return 1;
14085 }
14086
14087
14088 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14089 PyObject *pyobj;
14090
14091 {
14092 #if wxUSE_UNICODE
14093 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14094 #else
14095 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14096 #endif
14097 }
14098 return pyobj;
14099 }
14100
14101
14102 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14103 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14104 return 1;
14105 }
14106
14107
14108 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14109 PyObject *pyobj;
14110
14111 {
14112 #if wxUSE_UNICODE
14113 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14114 #else
14115 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14116 #endif
14117 }
14118 return pyobj;
14119 }
14120
14121
14122 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14123 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14124 return 1;
14125 }
14126
14127
14128 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14129 PyObject *pyobj;
14130
14131 {
14132 #if wxUSE_UNICODE
14133 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14134 #else
14135 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14136 #endif
14137 }
14138 return pyobj;
14139 }
14140
14141
14142 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj;
14144 wxBMPHandler *result;
14145 char *kwnames[] = {
14146 NULL
14147 };
14148
14149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14150 {
14151 PyThreadState* __tstate = wxPyBeginAllowThreads();
14152 result = (wxBMPHandler *)new wxBMPHandler();
14153
14154 wxPyEndAllowThreads(__tstate);
14155 if (PyErr_Occurred()) SWIG_fail;
14156 }
14157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14158 return resultobj;
14159 fail:
14160 return NULL;
14161 }
14162
14163
14164 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14165 PyObject *obj;
14166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14167 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14168 Py_INCREF(obj);
14169 return Py_BuildValue((char *)"");
14170 }
14171 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14172 PyObject *resultobj;
14173 wxICOHandler *result;
14174 char *kwnames[] = {
14175 NULL
14176 };
14177
14178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14179 {
14180 PyThreadState* __tstate = wxPyBeginAllowThreads();
14181 result = (wxICOHandler *)new wxICOHandler();
14182
14183 wxPyEndAllowThreads(__tstate);
14184 if (PyErr_Occurred()) SWIG_fail;
14185 }
14186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14187 return resultobj;
14188 fail:
14189 return NULL;
14190 }
14191
14192
14193 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14194 PyObject *obj;
14195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14196 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14197 Py_INCREF(obj);
14198 return Py_BuildValue((char *)"");
14199 }
14200 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14201 PyObject *resultobj;
14202 wxCURHandler *result;
14203 char *kwnames[] = {
14204 NULL
14205 };
14206
14207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 result = (wxCURHandler *)new wxCURHandler();
14211
14212 wxPyEndAllowThreads(__tstate);
14213 if (PyErr_Occurred()) SWIG_fail;
14214 }
14215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14216 return resultobj;
14217 fail:
14218 return NULL;
14219 }
14220
14221
14222 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14223 PyObject *obj;
14224 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14225 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14226 Py_INCREF(obj);
14227 return Py_BuildValue((char *)"");
14228 }
14229 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14230 PyObject *resultobj;
14231 wxANIHandler *result;
14232 char *kwnames[] = {
14233 NULL
14234 };
14235
14236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14237 {
14238 PyThreadState* __tstate = wxPyBeginAllowThreads();
14239 result = (wxANIHandler *)new wxANIHandler();
14240
14241 wxPyEndAllowThreads(__tstate);
14242 if (PyErr_Occurred()) SWIG_fail;
14243 }
14244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14245 return resultobj;
14246 fail:
14247 return NULL;
14248 }
14249
14250
14251 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14252 PyObject *obj;
14253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14254 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14255 Py_INCREF(obj);
14256 return Py_BuildValue((char *)"");
14257 }
14258 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14259 PyObject *resultobj;
14260 wxPNGHandler *result;
14261 char *kwnames[] = {
14262 NULL
14263 };
14264
14265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14266 {
14267 PyThreadState* __tstate = wxPyBeginAllowThreads();
14268 result = (wxPNGHandler *)new wxPNGHandler();
14269
14270 wxPyEndAllowThreads(__tstate);
14271 if (PyErr_Occurred()) SWIG_fail;
14272 }
14273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14274 return resultobj;
14275 fail:
14276 return NULL;
14277 }
14278
14279
14280 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14281 PyObject *obj;
14282 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14283 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14284 Py_INCREF(obj);
14285 return Py_BuildValue((char *)"");
14286 }
14287 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14288 PyObject *resultobj;
14289 wxGIFHandler *result;
14290 char *kwnames[] = {
14291 NULL
14292 };
14293
14294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14295 {
14296 PyThreadState* __tstate = wxPyBeginAllowThreads();
14297 result = (wxGIFHandler *)new wxGIFHandler();
14298
14299 wxPyEndAllowThreads(__tstate);
14300 if (PyErr_Occurred()) SWIG_fail;
14301 }
14302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14303 return resultobj;
14304 fail:
14305 return NULL;
14306 }
14307
14308
14309 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14310 PyObject *obj;
14311 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14312 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14313 Py_INCREF(obj);
14314 return Py_BuildValue((char *)"");
14315 }
14316 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14317 PyObject *resultobj;
14318 wxPCXHandler *result;
14319 char *kwnames[] = {
14320 NULL
14321 };
14322
14323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 result = (wxPCXHandler *)new wxPCXHandler();
14327
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14332 return resultobj;
14333 fail:
14334 return NULL;
14335 }
14336
14337
14338 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14339 PyObject *obj;
14340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14341 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14342 Py_INCREF(obj);
14343 return Py_BuildValue((char *)"");
14344 }
14345 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14346 PyObject *resultobj;
14347 wxJPEGHandler *result;
14348 char *kwnames[] = {
14349 NULL
14350 };
14351
14352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14353 {
14354 PyThreadState* __tstate = wxPyBeginAllowThreads();
14355 result = (wxJPEGHandler *)new wxJPEGHandler();
14356
14357 wxPyEndAllowThreads(__tstate);
14358 if (PyErr_Occurred()) SWIG_fail;
14359 }
14360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14361 return resultobj;
14362 fail:
14363 return NULL;
14364 }
14365
14366
14367 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14368 PyObject *obj;
14369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14370 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14371 Py_INCREF(obj);
14372 return Py_BuildValue((char *)"");
14373 }
14374 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14375 PyObject *resultobj;
14376 wxPNMHandler *result;
14377 char *kwnames[] = {
14378 NULL
14379 };
14380
14381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14382 {
14383 PyThreadState* __tstate = wxPyBeginAllowThreads();
14384 result = (wxPNMHandler *)new wxPNMHandler();
14385
14386 wxPyEndAllowThreads(__tstate);
14387 if (PyErr_Occurred()) SWIG_fail;
14388 }
14389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14390 return resultobj;
14391 fail:
14392 return NULL;
14393 }
14394
14395
14396 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14397 PyObject *obj;
14398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14399 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14400 Py_INCREF(obj);
14401 return Py_BuildValue((char *)"");
14402 }
14403 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14404 PyObject *resultobj;
14405 wxXPMHandler *result;
14406 char *kwnames[] = {
14407 NULL
14408 };
14409
14410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14411 {
14412 PyThreadState* __tstate = wxPyBeginAllowThreads();
14413 result = (wxXPMHandler *)new wxXPMHandler();
14414
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14419 return resultobj;
14420 fail:
14421 return NULL;
14422 }
14423
14424
14425 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14426 PyObject *obj;
14427 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14428 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14429 Py_INCREF(obj);
14430 return Py_BuildValue((char *)"");
14431 }
14432 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14433 PyObject *resultobj;
14434 wxTIFFHandler *result;
14435 char *kwnames[] = {
14436 NULL
14437 };
14438
14439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14440 {
14441 PyThreadState* __tstate = wxPyBeginAllowThreads();
14442 result = (wxTIFFHandler *)new wxTIFFHandler();
14443
14444 wxPyEndAllowThreads(__tstate);
14445 if (PyErr_Occurred()) SWIG_fail;
14446 }
14447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14448 return resultobj;
14449 fail:
14450 return NULL;
14451 }
14452
14453
14454 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14455 PyObject *obj;
14456 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14457 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14458 Py_INCREF(obj);
14459 return Py_BuildValue((char *)"");
14460 }
14461 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14462 PyObject *resultobj;
14463 wxImage *arg1 = 0 ;
14464 wxImage *arg2 = 0 ;
14465 int arg3 = (int) 236 ;
14466 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14467 bool result;
14468 PyObject * obj0 = 0 ;
14469 PyObject * obj1 = 0 ;
14470 PyObject * obj2 = 0 ;
14471 PyObject * obj3 = 0 ;
14472 char *kwnames[] = {
14473 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14474 };
14475
14476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14477 {
14478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14479 if (SWIG_arg_fail(1)) SWIG_fail;
14480 if (arg1 == NULL) {
14481 SWIG_null_ref("wxImage");
14482 }
14483 if (SWIG_arg_fail(1)) SWIG_fail;
14484 }
14485 {
14486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14487 if (SWIG_arg_fail(2)) SWIG_fail;
14488 if (arg2 == NULL) {
14489 SWIG_null_ref("wxImage");
14490 }
14491 if (SWIG_arg_fail(2)) SWIG_fail;
14492 }
14493 if (obj2) {
14494 {
14495 arg3 = (int)(SWIG_As_int(obj2));
14496 if (SWIG_arg_fail(3)) SWIG_fail;
14497 }
14498 }
14499 if (obj3) {
14500 {
14501 arg4 = (int)(SWIG_As_int(obj3));
14502 if (SWIG_arg_fail(4)) SWIG_fail;
14503 }
14504 }
14505 {
14506 PyThreadState* __tstate = wxPyBeginAllowThreads();
14507 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14508
14509 wxPyEndAllowThreads(__tstate);
14510 if (PyErr_Occurred()) SWIG_fail;
14511 }
14512 {
14513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14514 }
14515 return resultobj;
14516 fail:
14517 return NULL;
14518 }
14519
14520
14521 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14522 PyObject *obj;
14523 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14524 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14525 Py_INCREF(obj);
14526 return Py_BuildValue((char *)"");
14527 }
14528 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14529 PyObject *resultobj;
14530 wxEvtHandler *result;
14531 char *kwnames[] = {
14532 NULL
14533 };
14534
14535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14536 {
14537 PyThreadState* __tstate = wxPyBeginAllowThreads();
14538 result = (wxEvtHandler *)new wxEvtHandler();
14539
14540 wxPyEndAllowThreads(__tstate);
14541 if (PyErr_Occurred()) SWIG_fail;
14542 }
14543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14544 return resultobj;
14545 fail:
14546 return NULL;
14547 }
14548
14549
14550 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14551 PyObject *resultobj;
14552 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14553 wxEvtHandler *result;
14554 PyObject * obj0 = 0 ;
14555 char *kwnames[] = {
14556 (char *) "self", NULL
14557 };
14558
14559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14561 if (SWIG_arg_fail(1)) SWIG_fail;
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14565
14566 wxPyEndAllowThreads(__tstate);
14567 if (PyErr_Occurred()) SWIG_fail;
14568 }
14569 {
14570 resultobj = wxPyMake_wxObject(result, 0);
14571 }
14572 return resultobj;
14573 fail:
14574 return NULL;
14575 }
14576
14577
14578 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14579 PyObject *resultobj;
14580 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14581 wxEvtHandler *result;
14582 PyObject * obj0 = 0 ;
14583 char *kwnames[] = {
14584 (char *) "self", NULL
14585 };
14586
14587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14589 if (SWIG_arg_fail(1)) SWIG_fail;
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14593
14594 wxPyEndAllowThreads(__tstate);
14595 if (PyErr_Occurred()) SWIG_fail;
14596 }
14597 {
14598 resultobj = wxPyMake_wxObject(result, 0);
14599 }
14600 return resultobj;
14601 fail:
14602 return NULL;
14603 }
14604
14605
14606 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14607 PyObject *resultobj;
14608 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14609 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14610 PyObject * obj0 = 0 ;
14611 PyObject * obj1 = 0 ;
14612 char *kwnames[] = {
14613 (char *) "self",(char *) "handler", NULL
14614 };
14615
14616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14618 if (SWIG_arg_fail(1)) SWIG_fail;
14619 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14620 if (SWIG_arg_fail(2)) SWIG_fail;
14621 {
14622 PyThreadState* __tstate = wxPyBeginAllowThreads();
14623 (arg1)->SetNextHandler(arg2);
14624
14625 wxPyEndAllowThreads(__tstate);
14626 if (PyErr_Occurred()) SWIG_fail;
14627 }
14628 Py_INCREF(Py_None); resultobj = Py_None;
14629 return resultobj;
14630 fail:
14631 return NULL;
14632 }
14633
14634
14635 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14636 PyObject *resultobj;
14637 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14638 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14639 PyObject * obj0 = 0 ;
14640 PyObject * obj1 = 0 ;
14641 char *kwnames[] = {
14642 (char *) "self",(char *) "handler", NULL
14643 };
14644
14645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14647 if (SWIG_arg_fail(1)) SWIG_fail;
14648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14649 if (SWIG_arg_fail(2)) SWIG_fail;
14650 {
14651 PyThreadState* __tstate = wxPyBeginAllowThreads();
14652 (arg1)->SetPreviousHandler(arg2);
14653
14654 wxPyEndAllowThreads(__tstate);
14655 if (PyErr_Occurred()) SWIG_fail;
14656 }
14657 Py_INCREF(Py_None); resultobj = Py_None;
14658 return resultobj;
14659 fail:
14660 return NULL;
14661 }
14662
14663
14664 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14665 PyObject *resultobj;
14666 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14667 bool result;
14668 PyObject * obj0 = 0 ;
14669 char *kwnames[] = {
14670 (char *) "self", NULL
14671 };
14672
14673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14675 if (SWIG_arg_fail(1)) SWIG_fail;
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 result = (bool)(arg1)->GetEvtHandlerEnabled();
14679
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 {
14684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14685 }
14686 return resultobj;
14687 fail:
14688 return NULL;
14689 }
14690
14691
14692 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14693 PyObject *resultobj;
14694 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14695 bool arg2 ;
14696 PyObject * obj0 = 0 ;
14697 PyObject * obj1 = 0 ;
14698 char *kwnames[] = {
14699 (char *) "self",(char *) "enabled", NULL
14700 };
14701
14702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14704 if (SWIG_arg_fail(1)) SWIG_fail;
14705 {
14706 arg2 = (bool)(SWIG_As_bool(obj1));
14707 if (SWIG_arg_fail(2)) SWIG_fail;
14708 }
14709 {
14710 PyThreadState* __tstate = wxPyBeginAllowThreads();
14711 (arg1)->SetEvtHandlerEnabled(arg2);
14712
14713 wxPyEndAllowThreads(__tstate);
14714 if (PyErr_Occurred()) SWIG_fail;
14715 }
14716 Py_INCREF(Py_None); resultobj = Py_None;
14717 return resultobj;
14718 fail:
14719 return NULL;
14720 }
14721
14722
14723 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14724 PyObject *resultobj;
14725 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14726 wxEvent *arg2 = 0 ;
14727 bool result;
14728 PyObject * obj0 = 0 ;
14729 PyObject * obj1 = 0 ;
14730 char *kwnames[] = {
14731 (char *) "self",(char *) "event", NULL
14732 };
14733
14734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14736 if (SWIG_arg_fail(1)) SWIG_fail;
14737 {
14738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14739 if (SWIG_arg_fail(2)) SWIG_fail;
14740 if (arg2 == NULL) {
14741 SWIG_null_ref("wxEvent");
14742 }
14743 if (SWIG_arg_fail(2)) SWIG_fail;
14744 }
14745 {
14746 PyThreadState* __tstate = wxPyBeginAllowThreads();
14747 result = (bool)(arg1)->ProcessEvent(*arg2);
14748
14749 wxPyEndAllowThreads(__tstate);
14750 if (PyErr_Occurred()) SWIG_fail;
14751 }
14752 {
14753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14754 }
14755 return resultobj;
14756 fail:
14757 return NULL;
14758 }
14759
14760
14761 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14762 PyObject *resultobj;
14763 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14764 wxEvent *arg2 = 0 ;
14765 PyObject * obj0 = 0 ;
14766 PyObject * obj1 = 0 ;
14767 char *kwnames[] = {
14768 (char *) "self",(char *) "event", NULL
14769 };
14770
14771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14773 if (SWIG_arg_fail(1)) SWIG_fail;
14774 {
14775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14776 if (SWIG_arg_fail(2)) SWIG_fail;
14777 if (arg2 == NULL) {
14778 SWIG_null_ref("wxEvent");
14779 }
14780 if (SWIG_arg_fail(2)) SWIG_fail;
14781 }
14782 {
14783 PyThreadState* __tstate = wxPyBeginAllowThreads();
14784 (arg1)->AddPendingEvent(*arg2);
14785
14786 wxPyEndAllowThreads(__tstate);
14787 if (PyErr_Occurred()) SWIG_fail;
14788 }
14789 Py_INCREF(Py_None); resultobj = Py_None;
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj;
14798 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14799 PyObject * obj0 = 0 ;
14800 char *kwnames[] = {
14801 (char *) "self", NULL
14802 };
14803
14804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14806 if (SWIG_arg_fail(1)) SWIG_fail;
14807 {
14808 PyThreadState* __tstate = wxPyBeginAllowThreads();
14809 (arg1)->ProcessPendingEvents();
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 *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14822 PyObject *resultobj;
14823 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14824 int arg2 ;
14825 int arg3 ;
14826 int arg4 ;
14827 PyObject *arg5 = (PyObject *) 0 ;
14828 PyObject * obj0 = 0 ;
14829 PyObject * obj1 = 0 ;
14830 PyObject * obj2 = 0 ;
14831 PyObject * obj3 = 0 ;
14832 PyObject * obj4 = 0 ;
14833 char *kwnames[] = {
14834 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14835 };
14836
14837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14839 if (SWIG_arg_fail(1)) SWIG_fail;
14840 {
14841 arg2 = (int)(SWIG_As_int(obj1));
14842 if (SWIG_arg_fail(2)) SWIG_fail;
14843 }
14844 {
14845 arg3 = (int)(SWIG_As_int(obj2));
14846 if (SWIG_arg_fail(3)) SWIG_fail;
14847 }
14848 {
14849 arg4 = (int)(SWIG_As_int(obj3));
14850 if (SWIG_arg_fail(4)) SWIG_fail;
14851 }
14852 arg5 = obj4;
14853 {
14854 PyThreadState* __tstate = wxPyBeginAllowThreads();
14855 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14856
14857 wxPyEndAllowThreads(__tstate);
14858 if (PyErr_Occurred()) SWIG_fail;
14859 }
14860 Py_INCREF(Py_None); resultobj = Py_None;
14861 return resultobj;
14862 fail:
14863 return NULL;
14864 }
14865
14866
14867 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14868 PyObject *resultobj;
14869 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14870 int arg2 ;
14871 int arg3 = (int) -1 ;
14872 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14873 bool result;
14874 PyObject * obj0 = 0 ;
14875 PyObject * obj1 = 0 ;
14876 PyObject * obj2 = 0 ;
14877 PyObject * obj3 = 0 ;
14878 char *kwnames[] = {
14879 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14880 };
14881
14882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14884 if (SWIG_arg_fail(1)) SWIG_fail;
14885 {
14886 arg2 = (int)(SWIG_As_int(obj1));
14887 if (SWIG_arg_fail(2)) SWIG_fail;
14888 }
14889 if (obj2) {
14890 {
14891 arg3 = (int)(SWIG_As_int(obj2));
14892 if (SWIG_arg_fail(3)) SWIG_fail;
14893 }
14894 }
14895 if (obj3) {
14896 {
14897 arg4 = (wxEventType)(SWIG_As_int(obj3));
14898 if (SWIG_arg_fail(4)) SWIG_fail;
14899 }
14900 }
14901 {
14902 PyThreadState* __tstate = wxPyBeginAllowThreads();
14903 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14904
14905 wxPyEndAllowThreads(__tstate);
14906 if (PyErr_Occurred()) SWIG_fail;
14907 }
14908 {
14909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14910 }
14911 return resultobj;
14912 fail:
14913 return NULL;
14914 }
14915
14916
14917 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14918 PyObject *resultobj;
14919 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14920 PyObject *arg2 = (PyObject *) 0 ;
14921 bool arg3 = (bool) true ;
14922 PyObject * obj0 = 0 ;
14923 PyObject * obj1 = 0 ;
14924 PyObject * obj2 = 0 ;
14925 char *kwnames[] = {
14926 (char *) "self",(char *) "_self",(char *) "incref", NULL
14927 };
14928
14929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14931 if (SWIG_arg_fail(1)) SWIG_fail;
14932 arg2 = obj1;
14933 if (obj2) {
14934 {
14935 arg3 = (bool)(SWIG_As_bool(obj2));
14936 if (SWIG_arg_fail(3)) SWIG_fail;
14937 }
14938 }
14939 {
14940 PyThreadState* __tstate = wxPyBeginAllowThreads();
14941 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14942
14943 wxPyEndAllowThreads(__tstate);
14944 if (PyErr_Occurred()) SWIG_fail;
14945 }
14946 Py_INCREF(Py_None); resultobj = Py_None;
14947 return resultobj;
14948 fail:
14949 return NULL;
14950 }
14951
14952
14953 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14954 PyObject *obj;
14955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14956 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14957 Py_INCREF(obj);
14958 return Py_BuildValue((char *)"");
14959 }
14960 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14961 PyObject *resultobj;
14962 wxEventType result;
14963 char *kwnames[] = {
14964 NULL
14965 };
14966
14967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14968 {
14969 PyThreadState* __tstate = wxPyBeginAllowThreads();
14970 result = (wxEventType)wxNewEventType();
14971
14972 wxPyEndAllowThreads(__tstate);
14973 if (PyErr_Occurred()) SWIG_fail;
14974 }
14975 {
14976 resultobj = SWIG_From_int((int)(result));
14977 }
14978 return resultobj;
14979 fail:
14980 return NULL;
14981 }
14982
14983
14984 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14985 PyObject *resultobj;
14986 wxEvent *arg1 = (wxEvent *) 0 ;
14987 PyObject * obj0 = 0 ;
14988 char *kwnames[] = {
14989 (char *) "self", NULL
14990 };
14991
14992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14994 if (SWIG_arg_fail(1)) SWIG_fail;
14995 {
14996 PyThreadState* __tstate = wxPyBeginAllowThreads();
14997 delete arg1;
14998
14999 wxPyEndAllowThreads(__tstate);
15000 if (PyErr_Occurred()) SWIG_fail;
15001 }
15002 Py_INCREF(Py_None); resultobj = Py_None;
15003 return resultobj;
15004 fail:
15005 return NULL;
15006 }
15007
15008
15009 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15010 PyObject *resultobj;
15011 wxEvent *arg1 = (wxEvent *) 0 ;
15012 wxEventType arg2 ;
15013 PyObject * obj0 = 0 ;
15014 PyObject * obj1 = 0 ;
15015 char *kwnames[] = {
15016 (char *) "self",(char *) "typ", NULL
15017 };
15018
15019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15021 if (SWIG_arg_fail(1)) SWIG_fail;
15022 {
15023 arg2 = (wxEventType)(SWIG_As_int(obj1));
15024 if (SWIG_arg_fail(2)) SWIG_fail;
15025 }
15026 {
15027 PyThreadState* __tstate = wxPyBeginAllowThreads();
15028 (arg1)->SetEventType(arg2);
15029
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 Py_INCREF(Py_None); resultobj = Py_None;
15034 return resultobj;
15035 fail:
15036 return NULL;
15037 }
15038
15039
15040 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15041 PyObject *resultobj;
15042 wxEvent *arg1 = (wxEvent *) 0 ;
15043 wxEventType result;
15044 PyObject * obj0 = 0 ;
15045 char *kwnames[] = {
15046 (char *) "self", NULL
15047 };
15048
15049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15051 if (SWIG_arg_fail(1)) SWIG_fail;
15052 {
15053 PyThreadState* __tstate = wxPyBeginAllowThreads();
15054 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15055
15056 wxPyEndAllowThreads(__tstate);
15057 if (PyErr_Occurred()) SWIG_fail;
15058 }
15059 {
15060 resultobj = SWIG_From_int((int)(result));
15061 }
15062 return resultobj;
15063 fail:
15064 return NULL;
15065 }
15066
15067
15068 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15069 PyObject *resultobj;
15070 wxEvent *arg1 = (wxEvent *) 0 ;
15071 wxObject *result;
15072 PyObject * obj0 = 0 ;
15073 char *kwnames[] = {
15074 (char *) "self", NULL
15075 };
15076
15077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15079 if (SWIG_arg_fail(1)) SWIG_fail;
15080 {
15081 PyThreadState* __tstate = wxPyBeginAllowThreads();
15082 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15083
15084 wxPyEndAllowThreads(__tstate);
15085 if (PyErr_Occurred()) SWIG_fail;
15086 }
15087 {
15088 resultobj = wxPyMake_wxObject(result, 0);
15089 }
15090 return resultobj;
15091 fail:
15092 return NULL;
15093 }
15094
15095
15096 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15097 PyObject *resultobj;
15098 wxEvent *arg1 = (wxEvent *) 0 ;
15099 wxObject *arg2 = (wxObject *) 0 ;
15100 PyObject * obj0 = 0 ;
15101 PyObject * obj1 = 0 ;
15102 char *kwnames[] = {
15103 (char *) "self",(char *) "obj", NULL
15104 };
15105
15106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15108 if (SWIG_arg_fail(1)) SWIG_fail;
15109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15110 if (SWIG_arg_fail(2)) SWIG_fail;
15111 {
15112 PyThreadState* __tstate = wxPyBeginAllowThreads();
15113 (arg1)->SetEventObject(arg2);
15114
15115 wxPyEndAllowThreads(__tstate);
15116 if (PyErr_Occurred()) SWIG_fail;
15117 }
15118 Py_INCREF(Py_None); resultobj = Py_None;
15119 return resultobj;
15120 fail:
15121 return NULL;
15122 }
15123
15124
15125 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15126 PyObject *resultobj;
15127 wxEvent *arg1 = (wxEvent *) 0 ;
15128 long result;
15129 PyObject * obj0 = 0 ;
15130 char *kwnames[] = {
15131 (char *) "self", NULL
15132 };
15133
15134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15136 if (SWIG_arg_fail(1)) SWIG_fail;
15137 {
15138 PyThreadState* __tstate = wxPyBeginAllowThreads();
15139 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15140
15141 wxPyEndAllowThreads(__tstate);
15142 if (PyErr_Occurred()) SWIG_fail;
15143 }
15144 {
15145 resultobj = SWIG_From_long((long)(result));
15146 }
15147 return resultobj;
15148 fail:
15149 return NULL;
15150 }
15151
15152
15153 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15154 PyObject *resultobj;
15155 wxEvent *arg1 = (wxEvent *) 0 ;
15156 long arg2 = (long) 0 ;
15157 PyObject * obj0 = 0 ;
15158 PyObject * obj1 = 0 ;
15159 char *kwnames[] = {
15160 (char *) "self",(char *) "ts", NULL
15161 };
15162
15163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15165 if (SWIG_arg_fail(1)) SWIG_fail;
15166 if (obj1) {
15167 {
15168 arg2 = (long)(SWIG_As_long(obj1));
15169 if (SWIG_arg_fail(2)) SWIG_fail;
15170 }
15171 }
15172 {
15173 PyThreadState* __tstate = wxPyBeginAllowThreads();
15174 (arg1)->SetTimestamp(arg2);
15175
15176 wxPyEndAllowThreads(__tstate);
15177 if (PyErr_Occurred()) SWIG_fail;
15178 }
15179 Py_INCREF(Py_None); resultobj = Py_None;
15180 return resultobj;
15181 fail:
15182 return NULL;
15183 }
15184
15185
15186 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15187 PyObject *resultobj;
15188 wxEvent *arg1 = (wxEvent *) 0 ;
15189 int result;
15190 PyObject * obj0 = 0 ;
15191 char *kwnames[] = {
15192 (char *) "self", NULL
15193 };
15194
15195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15197 if (SWIG_arg_fail(1)) SWIG_fail;
15198 {
15199 PyThreadState* __tstate = wxPyBeginAllowThreads();
15200 result = (int)((wxEvent const *)arg1)->GetId();
15201
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 {
15206 resultobj = SWIG_From_int((int)(result));
15207 }
15208 return resultobj;
15209 fail:
15210 return NULL;
15211 }
15212
15213
15214 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15215 PyObject *resultobj;
15216 wxEvent *arg1 = (wxEvent *) 0 ;
15217 int arg2 ;
15218 PyObject * obj0 = 0 ;
15219 PyObject * obj1 = 0 ;
15220 char *kwnames[] = {
15221 (char *) "self",(char *) "Id", NULL
15222 };
15223
15224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15226 if (SWIG_arg_fail(1)) SWIG_fail;
15227 {
15228 arg2 = (int)(SWIG_As_int(obj1));
15229 if (SWIG_arg_fail(2)) SWIG_fail;
15230 }
15231 {
15232 PyThreadState* __tstate = wxPyBeginAllowThreads();
15233 (arg1)->SetId(arg2);
15234
15235 wxPyEndAllowThreads(__tstate);
15236 if (PyErr_Occurred()) SWIG_fail;
15237 }
15238 Py_INCREF(Py_None); resultobj = Py_None;
15239 return resultobj;
15240 fail:
15241 return NULL;
15242 }
15243
15244
15245 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15246 PyObject *resultobj;
15247 wxEvent *arg1 = (wxEvent *) 0 ;
15248 bool result;
15249 PyObject * obj0 = 0 ;
15250 char *kwnames[] = {
15251 (char *) "self", NULL
15252 };
15253
15254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15256 if (SWIG_arg_fail(1)) SWIG_fail;
15257 {
15258 PyThreadState* __tstate = wxPyBeginAllowThreads();
15259 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15260
15261 wxPyEndAllowThreads(__tstate);
15262 if (PyErr_Occurred()) SWIG_fail;
15263 }
15264 {
15265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15266 }
15267 return resultobj;
15268 fail:
15269 return NULL;
15270 }
15271
15272
15273 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15274 PyObject *resultobj;
15275 wxEvent *arg1 = (wxEvent *) 0 ;
15276 bool arg2 = (bool) true ;
15277 PyObject * obj0 = 0 ;
15278 PyObject * obj1 = 0 ;
15279 char *kwnames[] = {
15280 (char *) "self",(char *) "skip", NULL
15281 };
15282
15283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15285 if (SWIG_arg_fail(1)) SWIG_fail;
15286 if (obj1) {
15287 {
15288 arg2 = (bool)(SWIG_As_bool(obj1));
15289 if (SWIG_arg_fail(2)) SWIG_fail;
15290 }
15291 }
15292 {
15293 PyThreadState* __tstate = wxPyBeginAllowThreads();
15294 (arg1)->Skip(arg2);
15295
15296 wxPyEndAllowThreads(__tstate);
15297 if (PyErr_Occurred()) SWIG_fail;
15298 }
15299 Py_INCREF(Py_None); resultobj = Py_None;
15300 return resultobj;
15301 fail:
15302 return NULL;
15303 }
15304
15305
15306 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15307 PyObject *resultobj;
15308 wxEvent *arg1 = (wxEvent *) 0 ;
15309 bool result;
15310 PyObject * obj0 = 0 ;
15311 char *kwnames[] = {
15312 (char *) "self", NULL
15313 };
15314
15315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15317 if (SWIG_arg_fail(1)) SWIG_fail;
15318 {
15319 PyThreadState* __tstate = wxPyBeginAllowThreads();
15320 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15321
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 {
15326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15327 }
15328 return resultobj;
15329 fail:
15330 return NULL;
15331 }
15332
15333
15334 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15335 PyObject *resultobj;
15336 wxEvent *arg1 = (wxEvent *) 0 ;
15337 bool result;
15338 PyObject * obj0 = 0 ;
15339 char *kwnames[] = {
15340 (char *) "self", NULL
15341 };
15342
15343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15345 if (SWIG_arg_fail(1)) SWIG_fail;
15346 {
15347 PyThreadState* __tstate = wxPyBeginAllowThreads();
15348 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15349
15350 wxPyEndAllowThreads(__tstate);
15351 if (PyErr_Occurred()) SWIG_fail;
15352 }
15353 {
15354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15355 }
15356 return resultobj;
15357 fail:
15358 return NULL;
15359 }
15360
15361
15362 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15363 PyObject *resultobj;
15364 wxEvent *arg1 = (wxEvent *) 0 ;
15365 int result;
15366 PyObject * obj0 = 0 ;
15367 char *kwnames[] = {
15368 (char *) "self", NULL
15369 };
15370
15371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15373 if (SWIG_arg_fail(1)) SWIG_fail;
15374 {
15375 PyThreadState* __tstate = wxPyBeginAllowThreads();
15376 result = (int)(arg1)->StopPropagation();
15377
15378 wxPyEndAllowThreads(__tstate);
15379 if (PyErr_Occurred()) SWIG_fail;
15380 }
15381 {
15382 resultobj = SWIG_From_int((int)(result));
15383 }
15384 return resultobj;
15385 fail:
15386 return NULL;
15387 }
15388
15389
15390 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15391 PyObject *resultobj;
15392 wxEvent *arg1 = (wxEvent *) 0 ;
15393 int arg2 ;
15394 PyObject * obj0 = 0 ;
15395 PyObject * obj1 = 0 ;
15396 char *kwnames[] = {
15397 (char *) "self",(char *) "propagationLevel", NULL
15398 };
15399
15400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15402 if (SWIG_arg_fail(1)) SWIG_fail;
15403 {
15404 arg2 = (int)(SWIG_As_int(obj1));
15405 if (SWIG_arg_fail(2)) SWIG_fail;
15406 }
15407 {
15408 PyThreadState* __tstate = wxPyBeginAllowThreads();
15409 (arg1)->ResumePropagation(arg2);
15410
15411 wxPyEndAllowThreads(__tstate);
15412 if (PyErr_Occurred()) SWIG_fail;
15413 }
15414 Py_INCREF(Py_None); resultobj = Py_None;
15415 return resultobj;
15416 fail:
15417 return NULL;
15418 }
15419
15420
15421 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15422 PyObject *resultobj;
15423 wxEvent *arg1 = (wxEvent *) 0 ;
15424 wxEvent *result;
15425 PyObject * obj0 = 0 ;
15426 char *kwnames[] = {
15427 (char *) "self", NULL
15428 };
15429
15430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15432 if (SWIG_arg_fail(1)) SWIG_fail;
15433 {
15434 PyThreadState* __tstate = wxPyBeginAllowThreads();
15435 result = (wxEvent *)(arg1)->Clone();
15436
15437 wxPyEndAllowThreads(__tstate);
15438 if (PyErr_Occurred()) SWIG_fail;
15439 }
15440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15441 return resultobj;
15442 fail:
15443 return NULL;
15444 }
15445
15446
15447 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15448 PyObject *obj;
15449 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15450 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15451 Py_INCREF(obj);
15452 return Py_BuildValue((char *)"");
15453 }
15454 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15455 PyObject *resultobj;
15456 wxEvent *arg1 = 0 ;
15457 wxPropagationDisabler *result;
15458 PyObject * obj0 = 0 ;
15459 char *kwnames[] = {
15460 (char *) "event", NULL
15461 };
15462
15463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15464 {
15465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15466 if (SWIG_arg_fail(1)) SWIG_fail;
15467 if (arg1 == NULL) {
15468 SWIG_null_ref("wxEvent");
15469 }
15470 if (SWIG_arg_fail(1)) SWIG_fail;
15471 }
15472 {
15473 PyThreadState* __tstate = wxPyBeginAllowThreads();
15474 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15475
15476 wxPyEndAllowThreads(__tstate);
15477 if (PyErr_Occurred()) SWIG_fail;
15478 }
15479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15480 return resultobj;
15481 fail:
15482 return NULL;
15483 }
15484
15485
15486 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj;
15488 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15489 PyObject * obj0 = 0 ;
15490 char *kwnames[] = {
15491 (char *) "self", NULL
15492 };
15493
15494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15496 if (SWIG_arg_fail(1)) SWIG_fail;
15497 {
15498 PyThreadState* __tstate = wxPyBeginAllowThreads();
15499 delete arg1;
15500
15501 wxPyEndAllowThreads(__tstate);
15502 if (PyErr_Occurred()) SWIG_fail;
15503 }
15504 Py_INCREF(Py_None); resultobj = Py_None;
15505 return resultobj;
15506 fail:
15507 return NULL;
15508 }
15509
15510
15511 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15512 PyObject *obj;
15513 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15514 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15515 Py_INCREF(obj);
15516 return Py_BuildValue((char *)"");
15517 }
15518 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15519 PyObject *resultobj;
15520 wxEvent *arg1 = 0 ;
15521 wxPropagateOnce *result;
15522 PyObject * obj0 = 0 ;
15523 char *kwnames[] = {
15524 (char *) "event", NULL
15525 };
15526
15527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15528 {
15529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15530 if (SWIG_arg_fail(1)) SWIG_fail;
15531 if (arg1 == NULL) {
15532 SWIG_null_ref("wxEvent");
15533 }
15534 if (SWIG_arg_fail(1)) SWIG_fail;
15535 }
15536 {
15537 PyThreadState* __tstate = wxPyBeginAllowThreads();
15538 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15539
15540 wxPyEndAllowThreads(__tstate);
15541 if (PyErr_Occurred()) SWIG_fail;
15542 }
15543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15544 return resultobj;
15545 fail:
15546 return NULL;
15547 }
15548
15549
15550 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15551 PyObject *resultobj;
15552 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15553 PyObject * obj0 = 0 ;
15554 char *kwnames[] = {
15555 (char *) "self", NULL
15556 };
15557
15558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15560 if (SWIG_arg_fail(1)) SWIG_fail;
15561 {
15562 PyThreadState* __tstate = wxPyBeginAllowThreads();
15563 delete arg1;
15564
15565 wxPyEndAllowThreads(__tstate);
15566 if (PyErr_Occurred()) SWIG_fail;
15567 }
15568 Py_INCREF(Py_None); resultobj = Py_None;
15569 return resultobj;
15570 fail:
15571 return NULL;
15572 }
15573
15574
15575 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15576 PyObject *obj;
15577 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15578 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15579 Py_INCREF(obj);
15580 return Py_BuildValue((char *)"");
15581 }
15582 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15583 PyObject *resultobj;
15584 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15585 int arg2 = (int) 0 ;
15586 wxCommandEvent *result;
15587 PyObject * obj0 = 0 ;
15588 PyObject * obj1 = 0 ;
15589 char *kwnames[] = {
15590 (char *) "commandType",(char *) "winid", NULL
15591 };
15592
15593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15594 if (obj0) {
15595 {
15596 arg1 = (wxEventType)(SWIG_As_int(obj0));
15597 if (SWIG_arg_fail(1)) SWIG_fail;
15598 }
15599 }
15600 if (obj1) {
15601 {
15602 arg2 = (int)(SWIG_As_int(obj1));
15603 if (SWIG_arg_fail(2)) SWIG_fail;
15604 }
15605 }
15606 {
15607 PyThreadState* __tstate = wxPyBeginAllowThreads();
15608 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15609
15610 wxPyEndAllowThreads(__tstate);
15611 if (PyErr_Occurred()) SWIG_fail;
15612 }
15613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15614 return resultobj;
15615 fail:
15616 return NULL;
15617 }
15618
15619
15620 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15621 PyObject *resultobj;
15622 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15623 int result;
15624 PyObject * obj0 = 0 ;
15625 char *kwnames[] = {
15626 (char *) "self", NULL
15627 };
15628
15629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15631 if (SWIG_arg_fail(1)) SWIG_fail;
15632 {
15633 PyThreadState* __tstate = wxPyBeginAllowThreads();
15634 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15635
15636 wxPyEndAllowThreads(__tstate);
15637 if (PyErr_Occurred()) SWIG_fail;
15638 }
15639 {
15640 resultobj = SWIG_From_int((int)(result));
15641 }
15642 return resultobj;
15643 fail:
15644 return NULL;
15645 }
15646
15647
15648 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15649 PyObject *resultobj;
15650 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15651 wxString *arg2 = 0 ;
15652 bool temp2 = false ;
15653 PyObject * obj0 = 0 ;
15654 PyObject * obj1 = 0 ;
15655 char *kwnames[] = {
15656 (char *) "self",(char *) "s", NULL
15657 };
15658
15659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15661 if (SWIG_arg_fail(1)) SWIG_fail;
15662 {
15663 arg2 = wxString_in_helper(obj1);
15664 if (arg2 == NULL) SWIG_fail;
15665 temp2 = true;
15666 }
15667 {
15668 PyThreadState* __tstate = wxPyBeginAllowThreads();
15669 (arg1)->SetString((wxString const &)*arg2);
15670
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 Py_INCREF(Py_None); resultobj = Py_None;
15675 {
15676 if (temp2)
15677 delete arg2;
15678 }
15679 return resultobj;
15680 fail:
15681 {
15682 if (temp2)
15683 delete arg2;
15684 }
15685 return NULL;
15686 }
15687
15688
15689 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15690 PyObject *resultobj;
15691 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15692 wxString result;
15693 PyObject * obj0 = 0 ;
15694 char *kwnames[] = {
15695 (char *) "self", NULL
15696 };
15697
15698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15700 if (SWIG_arg_fail(1)) SWIG_fail;
15701 {
15702 PyThreadState* __tstate = wxPyBeginAllowThreads();
15703 result = ((wxCommandEvent const *)arg1)->GetString();
15704
15705 wxPyEndAllowThreads(__tstate);
15706 if (PyErr_Occurred()) SWIG_fail;
15707 }
15708 {
15709 #if wxUSE_UNICODE
15710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15711 #else
15712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15713 #endif
15714 }
15715 return resultobj;
15716 fail:
15717 return NULL;
15718 }
15719
15720
15721 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15722 PyObject *resultobj;
15723 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15724 bool result;
15725 PyObject * obj0 = 0 ;
15726 char *kwnames[] = {
15727 (char *) "self", NULL
15728 };
15729
15730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15732 if (SWIG_arg_fail(1)) SWIG_fail;
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15736
15737 wxPyEndAllowThreads(__tstate);
15738 if (PyErr_Occurred()) SWIG_fail;
15739 }
15740 {
15741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15742 }
15743 return resultobj;
15744 fail:
15745 return NULL;
15746 }
15747
15748
15749 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15750 PyObject *resultobj;
15751 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15752 bool result;
15753 PyObject * obj0 = 0 ;
15754 char *kwnames[] = {
15755 (char *) "self", NULL
15756 };
15757
15758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15760 if (SWIG_arg_fail(1)) SWIG_fail;
15761 {
15762 PyThreadState* __tstate = wxPyBeginAllowThreads();
15763 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15764
15765 wxPyEndAllowThreads(__tstate);
15766 if (PyErr_Occurred()) SWIG_fail;
15767 }
15768 {
15769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15770 }
15771 return resultobj;
15772 fail:
15773 return NULL;
15774 }
15775
15776
15777 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15778 PyObject *resultobj;
15779 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15780 long arg2 ;
15781 PyObject * obj0 = 0 ;
15782 PyObject * obj1 = 0 ;
15783 char *kwnames[] = {
15784 (char *) "self",(char *) "extraLong", NULL
15785 };
15786
15787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15789 if (SWIG_arg_fail(1)) SWIG_fail;
15790 {
15791 arg2 = (long)(SWIG_As_long(obj1));
15792 if (SWIG_arg_fail(2)) SWIG_fail;
15793 }
15794 {
15795 PyThreadState* __tstate = wxPyBeginAllowThreads();
15796 (arg1)->SetExtraLong(arg2);
15797
15798 wxPyEndAllowThreads(__tstate);
15799 if (PyErr_Occurred()) SWIG_fail;
15800 }
15801 Py_INCREF(Py_None); resultobj = Py_None;
15802 return resultobj;
15803 fail:
15804 return NULL;
15805 }
15806
15807
15808 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15809 PyObject *resultobj;
15810 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15811 long result;
15812 PyObject * obj0 = 0 ;
15813 char *kwnames[] = {
15814 (char *) "self", NULL
15815 };
15816
15817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15819 if (SWIG_arg_fail(1)) SWIG_fail;
15820 {
15821 PyThreadState* __tstate = wxPyBeginAllowThreads();
15822 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15823
15824 wxPyEndAllowThreads(__tstate);
15825 if (PyErr_Occurred()) SWIG_fail;
15826 }
15827 {
15828 resultobj = SWIG_From_long((long)(result));
15829 }
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15837 PyObject *resultobj;
15838 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15839 int arg2 ;
15840 PyObject * obj0 = 0 ;
15841 PyObject * obj1 = 0 ;
15842 char *kwnames[] = {
15843 (char *) "self",(char *) "i", NULL
15844 };
15845
15846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15848 if (SWIG_arg_fail(1)) SWIG_fail;
15849 {
15850 arg2 = (int)(SWIG_As_int(obj1));
15851 if (SWIG_arg_fail(2)) SWIG_fail;
15852 }
15853 {
15854 PyThreadState* __tstate = wxPyBeginAllowThreads();
15855 (arg1)->SetInt(arg2);
15856
15857 wxPyEndAllowThreads(__tstate);
15858 if (PyErr_Occurred()) SWIG_fail;
15859 }
15860 Py_INCREF(Py_None); resultobj = Py_None;
15861 return resultobj;
15862 fail:
15863 return NULL;
15864 }
15865
15866
15867 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15868 PyObject *resultobj;
15869 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15870 long result;
15871 PyObject * obj0 = 0 ;
15872 char *kwnames[] = {
15873 (char *) "self", NULL
15874 };
15875
15876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15878 if (SWIG_arg_fail(1)) SWIG_fail;
15879 {
15880 PyThreadState* __tstate = wxPyBeginAllowThreads();
15881 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15882
15883 wxPyEndAllowThreads(__tstate);
15884 if (PyErr_Occurred()) SWIG_fail;
15885 }
15886 {
15887 resultobj = SWIG_From_long((long)(result));
15888 }
15889 return resultobj;
15890 fail:
15891 return NULL;
15892 }
15893
15894
15895 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15896 PyObject *resultobj;
15897 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15898 wxEvent *result;
15899 PyObject * obj0 = 0 ;
15900 char *kwnames[] = {
15901 (char *) "self", NULL
15902 };
15903
15904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15906 if (SWIG_arg_fail(1)) SWIG_fail;
15907 {
15908 PyThreadState* __tstate = wxPyBeginAllowThreads();
15909 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15910
15911 wxPyEndAllowThreads(__tstate);
15912 if (PyErr_Occurred()) SWIG_fail;
15913 }
15914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15915 return resultobj;
15916 fail:
15917 return NULL;
15918 }
15919
15920
15921 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15922 PyObject *obj;
15923 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15924 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15925 Py_INCREF(obj);
15926 return Py_BuildValue((char *)"");
15927 }
15928 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15929 PyObject *resultobj;
15930 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15931 int arg2 = (int) 0 ;
15932 wxNotifyEvent *result;
15933 PyObject * obj0 = 0 ;
15934 PyObject * obj1 = 0 ;
15935 char *kwnames[] = {
15936 (char *) "commandType",(char *) "winid", NULL
15937 };
15938
15939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15940 if (obj0) {
15941 {
15942 arg1 = (wxEventType)(SWIG_As_int(obj0));
15943 if (SWIG_arg_fail(1)) SWIG_fail;
15944 }
15945 }
15946 if (obj1) {
15947 {
15948 arg2 = (int)(SWIG_As_int(obj1));
15949 if (SWIG_arg_fail(2)) SWIG_fail;
15950 }
15951 }
15952 {
15953 PyThreadState* __tstate = wxPyBeginAllowThreads();
15954 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15955
15956 wxPyEndAllowThreads(__tstate);
15957 if (PyErr_Occurred()) SWIG_fail;
15958 }
15959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15960 return resultobj;
15961 fail:
15962 return NULL;
15963 }
15964
15965
15966 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15967 PyObject *resultobj;
15968 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15969 PyObject * obj0 = 0 ;
15970 char *kwnames[] = {
15971 (char *) "self", NULL
15972 };
15973
15974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15976 if (SWIG_arg_fail(1)) SWIG_fail;
15977 {
15978 PyThreadState* __tstate = wxPyBeginAllowThreads();
15979 (arg1)->Veto();
15980
15981 wxPyEndAllowThreads(__tstate);
15982 if (PyErr_Occurred()) SWIG_fail;
15983 }
15984 Py_INCREF(Py_None); resultobj = Py_None;
15985 return resultobj;
15986 fail:
15987 return NULL;
15988 }
15989
15990
15991 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15992 PyObject *resultobj;
15993 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15994 PyObject * obj0 = 0 ;
15995 char *kwnames[] = {
15996 (char *) "self", NULL
15997 };
15998
15999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16001 if (SWIG_arg_fail(1)) SWIG_fail;
16002 {
16003 PyThreadState* __tstate = wxPyBeginAllowThreads();
16004 (arg1)->Allow();
16005
16006 wxPyEndAllowThreads(__tstate);
16007 if (PyErr_Occurred()) SWIG_fail;
16008 }
16009 Py_INCREF(Py_None); resultobj = Py_None;
16010 return resultobj;
16011 fail:
16012 return NULL;
16013 }
16014
16015
16016 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16017 PyObject *resultobj;
16018 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16019 bool result;
16020 PyObject * obj0 = 0 ;
16021 char *kwnames[] = {
16022 (char *) "self", NULL
16023 };
16024
16025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16027 if (SWIG_arg_fail(1)) SWIG_fail;
16028 {
16029 PyThreadState* __tstate = wxPyBeginAllowThreads();
16030 result = (bool)(arg1)->IsAllowed();
16031
16032 wxPyEndAllowThreads(__tstate);
16033 if (PyErr_Occurred()) SWIG_fail;
16034 }
16035 {
16036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16037 }
16038 return resultobj;
16039 fail:
16040 return NULL;
16041 }
16042
16043
16044 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16045 PyObject *obj;
16046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16047 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16048 Py_INCREF(obj);
16049 return Py_BuildValue((char *)"");
16050 }
16051 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16052 PyObject *resultobj;
16053 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16054 int arg2 = (int) 0 ;
16055 int arg3 = (int) 0 ;
16056 int arg4 = (int) 0 ;
16057 wxScrollEvent *result;
16058 PyObject * obj0 = 0 ;
16059 PyObject * obj1 = 0 ;
16060 PyObject * obj2 = 0 ;
16061 PyObject * obj3 = 0 ;
16062 char *kwnames[] = {
16063 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16064 };
16065
16066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16067 if (obj0) {
16068 {
16069 arg1 = (wxEventType)(SWIG_As_int(obj0));
16070 if (SWIG_arg_fail(1)) SWIG_fail;
16071 }
16072 }
16073 if (obj1) {
16074 {
16075 arg2 = (int)(SWIG_As_int(obj1));
16076 if (SWIG_arg_fail(2)) SWIG_fail;
16077 }
16078 }
16079 if (obj2) {
16080 {
16081 arg3 = (int)(SWIG_As_int(obj2));
16082 if (SWIG_arg_fail(3)) SWIG_fail;
16083 }
16084 }
16085 if (obj3) {
16086 {
16087 arg4 = (int)(SWIG_As_int(obj3));
16088 if (SWIG_arg_fail(4)) SWIG_fail;
16089 }
16090 }
16091 {
16092 PyThreadState* __tstate = wxPyBeginAllowThreads();
16093 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16094
16095 wxPyEndAllowThreads(__tstate);
16096 if (PyErr_Occurred()) SWIG_fail;
16097 }
16098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16099 return resultobj;
16100 fail:
16101 return NULL;
16102 }
16103
16104
16105 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16106 PyObject *resultobj;
16107 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16108 int result;
16109 PyObject * obj0 = 0 ;
16110 char *kwnames[] = {
16111 (char *) "self", NULL
16112 };
16113
16114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16116 if (SWIG_arg_fail(1)) SWIG_fail;
16117 {
16118 PyThreadState* __tstate = wxPyBeginAllowThreads();
16119 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16120
16121 wxPyEndAllowThreads(__tstate);
16122 if (PyErr_Occurred()) SWIG_fail;
16123 }
16124 {
16125 resultobj = SWIG_From_int((int)(result));
16126 }
16127 return resultobj;
16128 fail:
16129 return NULL;
16130 }
16131
16132
16133 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16134 PyObject *resultobj;
16135 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16136 int result;
16137 PyObject * obj0 = 0 ;
16138 char *kwnames[] = {
16139 (char *) "self", NULL
16140 };
16141
16142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16144 if (SWIG_arg_fail(1)) SWIG_fail;
16145 {
16146 PyThreadState* __tstate = wxPyBeginAllowThreads();
16147 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16148
16149 wxPyEndAllowThreads(__tstate);
16150 if (PyErr_Occurred()) SWIG_fail;
16151 }
16152 {
16153 resultobj = SWIG_From_int((int)(result));
16154 }
16155 return resultobj;
16156 fail:
16157 return NULL;
16158 }
16159
16160
16161 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16162 PyObject *resultobj;
16163 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16164 int arg2 ;
16165 PyObject * obj0 = 0 ;
16166 PyObject * obj1 = 0 ;
16167 char *kwnames[] = {
16168 (char *) "self",(char *) "orient", NULL
16169 };
16170
16171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16173 if (SWIG_arg_fail(1)) SWIG_fail;
16174 {
16175 arg2 = (int)(SWIG_As_int(obj1));
16176 if (SWIG_arg_fail(2)) SWIG_fail;
16177 }
16178 {
16179 PyThreadState* __tstate = wxPyBeginAllowThreads();
16180 (arg1)->SetOrientation(arg2);
16181
16182 wxPyEndAllowThreads(__tstate);
16183 if (PyErr_Occurred()) SWIG_fail;
16184 }
16185 Py_INCREF(Py_None); resultobj = Py_None;
16186 return resultobj;
16187 fail:
16188 return NULL;
16189 }
16190
16191
16192 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16193 PyObject *resultobj;
16194 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16195 int arg2 ;
16196 PyObject * obj0 = 0 ;
16197 PyObject * obj1 = 0 ;
16198 char *kwnames[] = {
16199 (char *) "self",(char *) "pos", NULL
16200 };
16201
16202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16204 if (SWIG_arg_fail(1)) SWIG_fail;
16205 {
16206 arg2 = (int)(SWIG_As_int(obj1));
16207 if (SWIG_arg_fail(2)) SWIG_fail;
16208 }
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 (arg1)->SetPosition(arg2);
16212
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 Py_INCREF(Py_None); resultobj = Py_None;
16217 return resultobj;
16218 fail:
16219 return NULL;
16220 }
16221
16222
16223 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16224 PyObject *obj;
16225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16226 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16227 Py_INCREF(obj);
16228 return Py_BuildValue((char *)"");
16229 }
16230 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16231 PyObject *resultobj;
16232 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16233 int arg2 = (int) 0 ;
16234 int arg3 = (int) 0 ;
16235 wxScrollWinEvent *result;
16236 PyObject * obj0 = 0 ;
16237 PyObject * obj1 = 0 ;
16238 PyObject * obj2 = 0 ;
16239 char *kwnames[] = {
16240 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16241 };
16242
16243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16244 if (obj0) {
16245 {
16246 arg1 = (wxEventType)(SWIG_As_int(obj0));
16247 if (SWIG_arg_fail(1)) SWIG_fail;
16248 }
16249 }
16250 if (obj1) {
16251 {
16252 arg2 = (int)(SWIG_As_int(obj1));
16253 if (SWIG_arg_fail(2)) SWIG_fail;
16254 }
16255 }
16256 if (obj2) {
16257 {
16258 arg3 = (int)(SWIG_As_int(obj2));
16259 if (SWIG_arg_fail(3)) SWIG_fail;
16260 }
16261 }
16262 {
16263 PyThreadState* __tstate = wxPyBeginAllowThreads();
16264 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16265
16266 wxPyEndAllowThreads(__tstate);
16267 if (PyErr_Occurred()) SWIG_fail;
16268 }
16269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16270 return resultobj;
16271 fail:
16272 return NULL;
16273 }
16274
16275
16276 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16277 PyObject *resultobj;
16278 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16279 int result;
16280 PyObject * obj0 = 0 ;
16281 char *kwnames[] = {
16282 (char *) "self", NULL
16283 };
16284
16285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16287 if (SWIG_arg_fail(1)) SWIG_fail;
16288 {
16289 PyThreadState* __tstate = wxPyBeginAllowThreads();
16290 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16291
16292 wxPyEndAllowThreads(__tstate);
16293 if (PyErr_Occurred()) SWIG_fail;
16294 }
16295 {
16296 resultobj = SWIG_From_int((int)(result));
16297 }
16298 return resultobj;
16299 fail:
16300 return NULL;
16301 }
16302
16303
16304 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16305 PyObject *resultobj;
16306 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16307 int result;
16308 PyObject * obj0 = 0 ;
16309 char *kwnames[] = {
16310 (char *) "self", NULL
16311 };
16312
16313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16315 if (SWIG_arg_fail(1)) SWIG_fail;
16316 {
16317 PyThreadState* __tstate = wxPyBeginAllowThreads();
16318 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16319
16320 wxPyEndAllowThreads(__tstate);
16321 if (PyErr_Occurred()) SWIG_fail;
16322 }
16323 {
16324 resultobj = SWIG_From_int((int)(result));
16325 }
16326 return resultobj;
16327 fail:
16328 return NULL;
16329 }
16330
16331
16332 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16333 PyObject *resultobj;
16334 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16335 int arg2 ;
16336 PyObject * obj0 = 0 ;
16337 PyObject * obj1 = 0 ;
16338 char *kwnames[] = {
16339 (char *) "self",(char *) "orient", NULL
16340 };
16341
16342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16344 if (SWIG_arg_fail(1)) SWIG_fail;
16345 {
16346 arg2 = (int)(SWIG_As_int(obj1));
16347 if (SWIG_arg_fail(2)) SWIG_fail;
16348 }
16349 {
16350 PyThreadState* __tstate = wxPyBeginAllowThreads();
16351 (arg1)->SetOrientation(arg2);
16352
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 Py_INCREF(Py_None); resultobj = Py_None;
16357 return resultobj;
16358 fail:
16359 return NULL;
16360 }
16361
16362
16363 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16364 PyObject *resultobj;
16365 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16366 int arg2 ;
16367 PyObject * obj0 = 0 ;
16368 PyObject * obj1 = 0 ;
16369 char *kwnames[] = {
16370 (char *) "self",(char *) "pos", NULL
16371 };
16372
16373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16375 if (SWIG_arg_fail(1)) SWIG_fail;
16376 {
16377 arg2 = (int)(SWIG_As_int(obj1));
16378 if (SWIG_arg_fail(2)) SWIG_fail;
16379 }
16380 {
16381 PyThreadState* __tstate = wxPyBeginAllowThreads();
16382 (arg1)->SetPosition(arg2);
16383
16384 wxPyEndAllowThreads(__tstate);
16385 if (PyErr_Occurred()) SWIG_fail;
16386 }
16387 Py_INCREF(Py_None); resultobj = Py_None;
16388 return resultobj;
16389 fail:
16390 return NULL;
16391 }
16392
16393
16394 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16395 PyObject *obj;
16396 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16397 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16398 Py_INCREF(obj);
16399 return Py_BuildValue((char *)"");
16400 }
16401 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16402 PyObject *resultobj;
16403 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16404 wxMouseEvent *result;
16405 PyObject * obj0 = 0 ;
16406 char *kwnames[] = {
16407 (char *) "mouseType", NULL
16408 };
16409
16410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16411 if (obj0) {
16412 {
16413 arg1 = (wxEventType)(SWIG_As_int(obj0));
16414 if (SWIG_arg_fail(1)) SWIG_fail;
16415 }
16416 }
16417 {
16418 PyThreadState* __tstate = wxPyBeginAllowThreads();
16419 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16420
16421 wxPyEndAllowThreads(__tstate);
16422 if (PyErr_Occurred()) SWIG_fail;
16423 }
16424 {
16425 resultobj = wxPyMake_wxObject(result, 1);
16426 }
16427 return resultobj;
16428 fail:
16429 return NULL;
16430 }
16431
16432
16433 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16434 PyObject *resultobj;
16435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16436 bool result;
16437 PyObject * obj0 = 0 ;
16438 char *kwnames[] = {
16439 (char *) "self", NULL
16440 };
16441
16442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16444 if (SWIG_arg_fail(1)) SWIG_fail;
16445 {
16446 PyThreadState* __tstate = wxPyBeginAllowThreads();
16447 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16448
16449 wxPyEndAllowThreads(__tstate);
16450 if (PyErr_Occurred()) SWIG_fail;
16451 }
16452 {
16453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16454 }
16455 return resultobj;
16456 fail:
16457 return NULL;
16458 }
16459
16460
16461 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16462 PyObject *resultobj;
16463 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16464 int arg2 = (int) wxMOUSE_BTN_ANY ;
16465 bool result;
16466 PyObject * obj0 = 0 ;
16467 PyObject * obj1 = 0 ;
16468 char *kwnames[] = {
16469 (char *) "self",(char *) "but", NULL
16470 };
16471
16472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16474 if (SWIG_arg_fail(1)) SWIG_fail;
16475 if (obj1) {
16476 {
16477 arg2 = (int)(SWIG_As_int(obj1));
16478 if (SWIG_arg_fail(2)) SWIG_fail;
16479 }
16480 }
16481 {
16482 PyThreadState* __tstate = wxPyBeginAllowThreads();
16483 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16484
16485 wxPyEndAllowThreads(__tstate);
16486 if (PyErr_Occurred()) SWIG_fail;
16487 }
16488 {
16489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16490 }
16491 return resultobj;
16492 fail:
16493 return NULL;
16494 }
16495
16496
16497 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16498 PyObject *resultobj;
16499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16500 int arg2 = (int) wxMOUSE_BTN_ANY ;
16501 bool result;
16502 PyObject * obj0 = 0 ;
16503 PyObject * obj1 = 0 ;
16504 char *kwnames[] = {
16505 (char *) "self",(char *) "but", NULL
16506 };
16507
16508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16510 if (SWIG_arg_fail(1)) SWIG_fail;
16511 if (obj1) {
16512 {
16513 arg2 = (int)(SWIG_As_int(obj1));
16514 if (SWIG_arg_fail(2)) SWIG_fail;
16515 }
16516 }
16517 {
16518 PyThreadState* __tstate = wxPyBeginAllowThreads();
16519 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16520
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 {
16525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16526 }
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj;
16535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16536 int arg2 = (int) wxMOUSE_BTN_ANY ;
16537 bool result;
16538 PyObject * obj0 = 0 ;
16539 PyObject * obj1 = 0 ;
16540 char *kwnames[] = {
16541 (char *) "self",(char *) "but", NULL
16542 };
16543
16544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) 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 if (obj1) {
16548 {
16549 arg2 = (int)(SWIG_As_int(obj1));
16550 if (SWIG_arg_fail(2)) SWIG_fail;
16551 }
16552 }
16553 {
16554 PyThreadState* __tstate = wxPyBeginAllowThreads();
16555 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16556
16557 wxPyEndAllowThreads(__tstate);
16558 if (PyErr_Occurred()) SWIG_fail;
16559 }
16560 {
16561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16562 }
16563 return resultobj;
16564 fail:
16565 return NULL;
16566 }
16567
16568
16569 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16570 PyObject *resultobj;
16571 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16572 int arg2 ;
16573 bool result;
16574 PyObject * obj0 = 0 ;
16575 PyObject * obj1 = 0 ;
16576 char *kwnames[] = {
16577 (char *) "self",(char *) "but", NULL
16578 };
16579
16580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16582 if (SWIG_arg_fail(1)) SWIG_fail;
16583 {
16584 arg2 = (int)(SWIG_As_int(obj1));
16585 if (SWIG_arg_fail(2)) SWIG_fail;
16586 }
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16590
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 {
16595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16596 }
16597 return resultobj;
16598 fail:
16599 return NULL;
16600 }
16601
16602
16603 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16604 PyObject *resultobj;
16605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16606 int arg2 ;
16607 bool result;
16608 PyObject * obj0 = 0 ;
16609 PyObject * obj1 = 0 ;
16610 char *kwnames[] = {
16611 (char *) "self",(char *) "but", NULL
16612 };
16613
16614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16616 if (SWIG_arg_fail(1)) SWIG_fail;
16617 {
16618 arg2 = (int)(SWIG_As_int(obj1));
16619 if (SWIG_arg_fail(2)) SWIG_fail;
16620 }
16621 {
16622 PyThreadState* __tstate = wxPyBeginAllowThreads();
16623 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16624
16625 wxPyEndAllowThreads(__tstate);
16626 if (PyErr_Occurred()) SWIG_fail;
16627 }
16628 {
16629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16630 }
16631 return resultobj;
16632 fail:
16633 return NULL;
16634 }
16635
16636
16637 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16638 PyObject *resultobj;
16639 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16640 int result;
16641 PyObject * obj0 = 0 ;
16642 char *kwnames[] = {
16643 (char *) "self", NULL
16644 };
16645
16646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16648 if (SWIG_arg_fail(1)) SWIG_fail;
16649 {
16650 PyThreadState* __tstate = wxPyBeginAllowThreads();
16651 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16652
16653 wxPyEndAllowThreads(__tstate);
16654 if (PyErr_Occurred()) SWIG_fail;
16655 }
16656 {
16657 resultobj = SWIG_From_int((int)(result));
16658 }
16659 return resultobj;
16660 fail:
16661 return NULL;
16662 }
16663
16664
16665 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16666 PyObject *resultobj;
16667 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16668 bool result;
16669 PyObject * obj0 = 0 ;
16670 char *kwnames[] = {
16671 (char *) "self", NULL
16672 };
16673
16674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16676 if (SWIG_arg_fail(1)) SWIG_fail;
16677 {
16678 PyThreadState* __tstate = wxPyBeginAllowThreads();
16679 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16680
16681 wxPyEndAllowThreads(__tstate);
16682 if (PyErr_Occurred()) SWIG_fail;
16683 }
16684 {
16685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16686 }
16687 return resultobj;
16688 fail:
16689 return NULL;
16690 }
16691
16692
16693 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16694 PyObject *resultobj;
16695 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16696 bool result;
16697 PyObject * obj0 = 0 ;
16698 char *kwnames[] = {
16699 (char *) "self", NULL
16700 };
16701
16702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16704 if (SWIG_arg_fail(1)) SWIG_fail;
16705 {
16706 PyThreadState* __tstate = wxPyBeginAllowThreads();
16707 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16708
16709 wxPyEndAllowThreads(__tstate);
16710 if (PyErr_Occurred()) SWIG_fail;
16711 }
16712 {
16713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16714 }
16715 return resultobj;
16716 fail:
16717 return NULL;
16718 }
16719
16720
16721 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16722 PyObject *resultobj;
16723 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16724 bool result;
16725 PyObject * obj0 = 0 ;
16726 char *kwnames[] = {
16727 (char *) "self", NULL
16728 };
16729
16730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16732 if (SWIG_arg_fail(1)) SWIG_fail;
16733 {
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16736
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 {
16741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16742 }
16743 return resultobj;
16744 fail:
16745 return NULL;
16746 }
16747
16748
16749 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16750 PyObject *resultobj;
16751 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16752 bool result;
16753 PyObject * obj0 = 0 ;
16754 char *kwnames[] = {
16755 (char *) "self", NULL
16756 };
16757
16758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16760 if (SWIG_arg_fail(1)) SWIG_fail;
16761 {
16762 PyThreadState* __tstate = wxPyBeginAllowThreads();
16763 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16764
16765 wxPyEndAllowThreads(__tstate);
16766 if (PyErr_Occurred()) SWIG_fail;
16767 }
16768 {
16769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16770 }
16771 return resultobj;
16772 fail:
16773 return NULL;
16774 }
16775
16776
16777 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16778 PyObject *resultobj;
16779 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16780 bool result;
16781 PyObject * obj0 = 0 ;
16782 char *kwnames[] = {
16783 (char *) "self", NULL
16784 };
16785
16786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16788 if (SWIG_arg_fail(1)) SWIG_fail;
16789 {
16790 PyThreadState* __tstate = wxPyBeginAllowThreads();
16791 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16792
16793 wxPyEndAllowThreads(__tstate);
16794 if (PyErr_Occurred()) SWIG_fail;
16795 }
16796 {
16797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16798 }
16799 return resultobj;
16800 fail:
16801 return NULL;
16802 }
16803
16804
16805 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16806 PyObject *resultobj;
16807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16808 bool result;
16809 PyObject * obj0 = 0 ;
16810 char *kwnames[] = {
16811 (char *) "self", NULL
16812 };
16813
16814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16816 if (SWIG_arg_fail(1)) SWIG_fail;
16817 {
16818 PyThreadState* __tstate = wxPyBeginAllowThreads();
16819 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16820
16821 wxPyEndAllowThreads(__tstate);
16822 if (PyErr_Occurred()) SWIG_fail;
16823 }
16824 {
16825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16826 }
16827 return resultobj;
16828 fail:
16829 return NULL;
16830 }
16831
16832
16833 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16834 PyObject *resultobj;
16835 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16836 bool result;
16837 PyObject * obj0 = 0 ;
16838 char *kwnames[] = {
16839 (char *) "self", NULL
16840 };
16841
16842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16844 if (SWIG_arg_fail(1)) SWIG_fail;
16845 {
16846 PyThreadState* __tstate = wxPyBeginAllowThreads();
16847 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16848
16849 wxPyEndAllowThreads(__tstate);
16850 if (PyErr_Occurred()) SWIG_fail;
16851 }
16852 {
16853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16854 }
16855 return resultobj;
16856 fail:
16857 return NULL;
16858 }
16859
16860
16861 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16862 PyObject *resultobj;
16863 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16864 bool result;
16865 PyObject * obj0 = 0 ;
16866 char *kwnames[] = {
16867 (char *) "self", NULL
16868 };
16869
16870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16872 if (SWIG_arg_fail(1)) SWIG_fail;
16873 {
16874 PyThreadState* __tstate = wxPyBeginAllowThreads();
16875 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16876
16877 wxPyEndAllowThreads(__tstate);
16878 if (PyErr_Occurred()) SWIG_fail;
16879 }
16880 {
16881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16882 }
16883 return resultobj;
16884 fail:
16885 return NULL;
16886 }
16887
16888
16889 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16890 PyObject *resultobj;
16891 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16892 bool result;
16893 PyObject * obj0 = 0 ;
16894 char *kwnames[] = {
16895 (char *) "self", NULL
16896 };
16897
16898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16900 if (SWIG_arg_fail(1)) SWIG_fail;
16901 {
16902 PyThreadState* __tstate = wxPyBeginAllowThreads();
16903 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16904
16905 wxPyEndAllowThreads(__tstate);
16906 if (PyErr_Occurred()) SWIG_fail;
16907 }
16908 {
16909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16910 }
16911 return resultobj;
16912 fail:
16913 return NULL;
16914 }
16915
16916
16917 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16918 PyObject *resultobj;
16919 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16920 bool result;
16921 PyObject * obj0 = 0 ;
16922 char *kwnames[] = {
16923 (char *) "self", NULL
16924 };
16925
16926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16928 if (SWIG_arg_fail(1)) SWIG_fail;
16929 {
16930 PyThreadState* __tstate = wxPyBeginAllowThreads();
16931 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16932
16933 wxPyEndAllowThreads(__tstate);
16934 if (PyErr_Occurred()) SWIG_fail;
16935 }
16936 {
16937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16938 }
16939 return resultobj;
16940 fail:
16941 return NULL;
16942 }
16943
16944
16945 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16946 PyObject *resultobj;
16947 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16948 bool result;
16949 PyObject * obj0 = 0 ;
16950 char *kwnames[] = {
16951 (char *) "self", NULL
16952 };
16953
16954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16956 if (SWIG_arg_fail(1)) SWIG_fail;
16957 {
16958 PyThreadState* __tstate = wxPyBeginAllowThreads();
16959 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16960
16961 wxPyEndAllowThreads(__tstate);
16962 if (PyErr_Occurred()) SWIG_fail;
16963 }
16964 {
16965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16966 }
16967 return resultobj;
16968 fail:
16969 return NULL;
16970 }
16971
16972
16973 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16974 PyObject *resultobj;
16975 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16976 bool result;
16977 PyObject * obj0 = 0 ;
16978 char *kwnames[] = {
16979 (char *) "self", NULL
16980 };
16981
16982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16984 if (SWIG_arg_fail(1)) SWIG_fail;
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16988
16989 wxPyEndAllowThreads(__tstate);
16990 if (PyErr_Occurred()) SWIG_fail;
16991 }
16992 {
16993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16994 }
16995 return resultobj;
16996 fail:
16997 return NULL;
16998 }
16999
17000
17001 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17002 PyObject *resultobj;
17003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17004 bool result;
17005 PyObject * obj0 = 0 ;
17006 char *kwnames[] = {
17007 (char *) "self", NULL
17008 };
17009
17010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17012 if (SWIG_arg_fail(1)) SWIG_fail;
17013 {
17014 PyThreadState* __tstate = wxPyBeginAllowThreads();
17015 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17016
17017 wxPyEndAllowThreads(__tstate);
17018 if (PyErr_Occurred()) SWIG_fail;
17019 }
17020 {
17021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17022 }
17023 return resultobj;
17024 fail:
17025 return NULL;
17026 }
17027
17028
17029 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17030 PyObject *resultobj;
17031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17032 bool result;
17033 PyObject * obj0 = 0 ;
17034 char *kwnames[] = {
17035 (char *) "self", NULL
17036 };
17037
17038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17040 if (SWIG_arg_fail(1)) SWIG_fail;
17041 {
17042 PyThreadState* __tstate = wxPyBeginAllowThreads();
17043 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17044
17045 wxPyEndAllowThreads(__tstate);
17046 if (PyErr_Occurred()) SWIG_fail;
17047 }
17048 {
17049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17050 }
17051 return resultobj;
17052 fail:
17053 return NULL;
17054 }
17055
17056
17057 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17058 PyObject *resultobj;
17059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17060 bool result;
17061 PyObject * obj0 = 0 ;
17062 char *kwnames[] = {
17063 (char *) "self", NULL
17064 };
17065
17066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17068 if (SWIG_arg_fail(1)) SWIG_fail;
17069 {
17070 PyThreadState* __tstate = wxPyBeginAllowThreads();
17071 result = (bool)(arg1)->LeftIsDown();
17072
17073 wxPyEndAllowThreads(__tstate);
17074 if (PyErr_Occurred()) SWIG_fail;
17075 }
17076 {
17077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17078 }
17079 return resultobj;
17080 fail:
17081 return NULL;
17082 }
17083
17084
17085 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17086 PyObject *resultobj;
17087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17088 bool result;
17089 PyObject * obj0 = 0 ;
17090 char *kwnames[] = {
17091 (char *) "self", NULL
17092 };
17093
17094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17096 if (SWIG_arg_fail(1)) SWIG_fail;
17097 {
17098 PyThreadState* __tstate = wxPyBeginAllowThreads();
17099 result = (bool)(arg1)->MiddleIsDown();
17100
17101 wxPyEndAllowThreads(__tstate);
17102 if (PyErr_Occurred()) SWIG_fail;
17103 }
17104 {
17105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17106 }
17107 return resultobj;
17108 fail:
17109 return NULL;
17110 }
17111
17112
17113 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17114 PyObject *resultobj;
17115 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17116 bool result;
17117 PyObject * obj0 = 0 ;
17118 char *kwnames[] = {
17119 (char *) "self", NULL
17120 };
17121
17122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17124 if (SWIG_arg_fail(1)) SWIG_fail;
17125 {
17126 PyThreadState* __tstate = wxPyBeginAllowThreads();
17127 result = (bool)(arg1)->RightIsDown();
17128
17129 wxPyEndAllowThreads(__tstate);
17130 if (PyErr_Occurred()) SWIG_fail;
17131 }
17132 {
17133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17134 }
17135 return resultobj;
17136 fail:
17137 return NULL;
17138 }
17139
17140
17141 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17142 PyObject *resultobj;
17143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17144 bool result;
17145 PyObject * obj0 = 0 ;
17146 char *kwnames[] = {
17147 (char *) "self", NULL
17148 };
17149
17150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17152 if (SWIG_arg_fail(1)) SWIG_fail;
17153 {
17154 PyThreadState* __tstate = wxPyBeginAllowThreads();
17155 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17156
17157 wxPyEndAllowThreads(__tstate);
17158 if (PyErr_Occurred()) SWIG_fail;
17159 }
17160 {
17161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17162 }
17163 return resultobj;
17164 fail:
17165 return NULL;
17166 }
17167
17168
17169 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17170 PyObject *resultobj;
17171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17172 bool result;
17173 PyObject * obj0 = 0 ;
17174 char *kwnames[] = {
17175 (char *) "self", NULL
17176 };
17177
17178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17180 if (SWIG_arg_fail(1)) SWIG_fail;
17181 {
17182 PyThreadState* __tstate = wxPyBeginAllowThreads();
17183 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17184
17185 wxPyEndAllowThreads(__tstate);
17186 if (PyErr_Occurred()) SWIG_fail;
17187 }
17188 {
17189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17190 }
17191 return resultobj;
17192 fail:
17193 return NULL;
17194 }
17195
17196
17197 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17198 PyObject *resultobj;
17199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17200 bool result;
17201 PyObject * obj0 = 0 ;
17202 char *kwnames[] = {
17203 (char *) "self", NULL
17204 };
17205
17206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17208 if (SWIG_arg_fail(1)) SWIG_fail;
17209 {
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17212
17213 wxPyEndAllowThreads(__tstate);
17214 if (PyErr_Occurred()) SWIG_fail;
17215 }
17216 {
17217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17218 }
17219 return resultobj;
17220 fail:
17221 return NULL;
17222 }
17223
17224
17225 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17226 PyObject *resultobj;
17227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17228 bool result;
17229 PyObject * obj0 = 0 ;
17230 char *kwnames[] = {
17231 (char *) "self", NULL
17232 };
17233
17234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17236 if (SWIG_arg_fail(1)) SWIG_fail;
17237 {
17238 PyThreadState* __tstate = wxPyBeginAllowThreads();
17239 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17240
17241 wxPyEndAllowThreads(__tstate);
17242 if (PyErr_Occurred()) SWIG_fail;
17243 }
17244 {
17245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17246 }
17247 return resultobj;
17248 fail:
17249 return NULL;
17250 }
17251
17252
17253 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17254 PyObject *resultobj;
17255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17256 wxPoint result;
17257 PyObject * obj0 = 0 ;
17258 char *kwnames[] = {
17259 (char *) "self", NULL
17260 };
17261
17262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17264 if (SWIG_arg_fail(1)) SWIG_fail;
17265 {
17266 PyThreadState* __tstate = wxPyBeginAllowThreads();
17267 result = (arg1)->GetPosition();
17268
17269 wxPyEndAllowThreads(__tstate);
17270 if (PyErr_Occurred()) SWIG_fail;
17271 }
17272 {
17273 wxPoint * resultptr;
17274 resultptr = new wxPoint((wxPoint &)(result));
17275 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17276 }
17277 return resultobj;
17278 fail:
17279 return NULL;
17280 }
17281
17282
17283 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17284 PyObject *resultobj;
17285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17286 long *arg2 = (long *) 0 ;
17287 long *arg3 = (long *) 0 ;
17288 long temp2 ;
17289 int res2 = 0 ;
17290 long temp3 ;
17291 int res3 = 0 ;
17292 PyObject * obj0 = 0 ;
17293 char *kwnames[] = {
17294 (char *) "self", NULL
17295 };
17296
17297 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17298 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17301 if (SWIG_arg_fail(1)) SWIG_fail;
17302 {
17303 PyThreadState* __tstate = wxPyBeginAllowThreads();
17304 (arg1)->GetPosition(arg2,arg3);
17305
17306 wxPyEndAllowThreads(__tstate);
17307 if (PyErr_Occurred()) SWIG_fail;
17308 }
17309 Py_INCREF(Py_None); resultobj = Py_None;
17310 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17311 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17312 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17313 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17314 return resultobj;
17315 fail:
17316 return NULL;
17317 }
17318
17319
17320 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17321 PyObject *resultobj;
17322 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17323 wxDC *arg2 = 0 ;
17324 wxPoint result;
17325 PyObject * obj0 = 0 ;
17326 PyObject * obj1 = 0 ;
17327 char *kwnames[] = {
17328 (char *) "self",(char *) "dc", NULL
17329 };
17330
17331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17333 if (SWIG_arg_fail(1)) SWIG_fail;
17334 {
17335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17336 if (SWIG_arg_fail(2)) SWIG_fail;
17337 if (arg2 == NULL) {
17338 SWIG_null_ref("wxDC");
17339 }
17340 if (SWIG_arg_fail(2)) SWIG_fail;
17341 }
17342 {
17343 PyThreadState* __tstate = wxPyBeginAllowThreads();
17344 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17345
17346 wxPyEndAllowThreads(__tstate);
17347 if (PyErr_Occurred()) SWIG_fail;
17348 }
17349 {
17350 wxPoint * resultptr;
17351 resultptr = new wxPoint((wxPoint &)(result));
17352 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17353 }
17354 return resultobj;
17355 fail:
17356 return NULL;
17357 }
17358
17359
17360 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17361 PyObject *resultobj;
17362 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17363 int result;
17364 PyObject * obj0 = 0 ;
17365 char *kwnames[] = {
17366 (char *) "self", NULL
17367 };
17368
17369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17371 if (SWIG_arg_fail(1)) SWIG_fail;
17372 {
17373 PyThreadState* __tstate = wxPyBeginAllowThreads();
17374 result = (int)((wxMouseEvent const *)arg1)->GetX();
17375
17376 wxPyEndAllowThreads(__tstate);
17377 if (PyErr_Occurred()) SWIG_fail;
17378 }
17379 {
17380 resultobj = SWIG_From_int((int)(result));
17381 }
17382 return resultobj;
17383 fail:
17384 return NULL;
17385 }
17386
17387
17388 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17389 PyObject *resultobj;
17390 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17391 int result;
17392 PyObject * obj0 = 0 ;
17393 char *kwnames[] = {
17394 (char *) "self", NULL
17395 };
17396
17397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17399 if (SWIG_arg_fail(1)) SWIG_fail;
17400 {
17401 PyThreadState* __tstate = wxPyBeginAllowThreads();
17402 result = (int)((wxMouseEvent const *)arg1)->GetY();
17403
17404 wxPyEndAllowThreads(__tstate);
17405 if (PyErr_Occurred()) SWIG_fail;
17406 }
17407 {
17408 resultobj = SWIG_From_int((int)(result));
17409 }
17410 return resultobj;
17411 fail:
17412 return NULL;
17413 }
17414
17415
17416 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17417 PyObject *resultobj;
17418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17419 int result;
17420 PyObject * obj0 = 0 ;
17421 char *kwnames[] = {
17422 (char *) "self", NULL
17423 };
17424
17425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17427 if (SWIG_arg_fail(1)) SWIG_fail;
17428 {
17429 PyThreadState* __tstate = wxPyBeginAllowThreads();
17430 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17431
17432 wxPyEndAllowThreads(__tstate);
17433 if (PyErr_Occurred()) SWIG_fail;
17434 }
17435 {
17436 resultobj = SWIG_From_int((int)(result));
17437 }
17438 return resultobj;
17439 fail:
17440 return NULL;
17441 }
17442
17443
17444 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17445 PyObject *resultobj;
17446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17447 int result;
17448 PyObject * obj0 = 0 ;
17449 char *kwnames[] = {
17450 (char *) "self", NULL
17451 };
17452
17453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17455 if (SWIG_arg_fail(1)) SWIG_fail;
17456 {
17457 PyThreadState* __tstate = wxPyBeginAllowThreads();
17458 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17459
17460 wxPyEndAllowThreads(__tstate);
17461 if (PyErr_Occurred()) SWIG_fail;
17462 }
17463 {
17464 resultobj = SWIG_From_int((int)(result));
17465 }
17466 return resultobj;
17467 fail:
17468 return NULL;
17469 }
17470
17471
17472 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17473 PyObject *resultobj;
17474 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17475 int result;
17476 PyObject * obj0 = 0 ;
17477 char *kwnames[] = {
17478 (char *) "self", NULL
17479 };
17480
17481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17483 if (SWIG_arg_fail(1)) SWIG_fail;
17484 {
17485 PyThreadState* __tstate = wxPyBeginAllowThreads();
17486 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17487
17488 wxPyEndAllowThreads(__tstate);
17489 if (PyErr_Occurred()) SWIG_fail;
17490 }
17491 {
17492 resultobj = SWIG_From_int((int)(result));
17493 }
17494 return resultobj;
17495 fail:
17496 return NULL;
17497 }
17498
17499
17500 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17501 PyObject *resultobj;
17502 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17503 bool result;
17504 PyObject * obj0 = 0 ;
17505 char *kwnames[] = {
17506 (char *) "self", NULL
17507 };
17508
17509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17511 if (SWIG_arg_fail(1)) SWIG_fail;
17512 {
17513 PyThreadState* __tstate = wxPyBeginAllowThreads();
17514 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17515
17516 wxPyEndAllowThreads(__tstate);
17517 if (PyErr_Occurred()) SWIG_fail;
17518 }
17519 {
17520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17521 }
17522 return resultobj;
17523 fail:
17524 return NULL;
17525 }
17526
17527
17528 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17529 PyObject *resultobj;
17530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17531 int arg2 ;
17532 PyObject * obj0 = 0 ;
17533 PyObject * obj1 = 0 ;
17534 char *kwnames[] = {
17535 (char *) "self",(char *) "m_x", NULL
17536 };
17537
17538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17540 if (SWIG_arg_fail(1)) SWIG_fail;
17541 {
17542 arg2 = (int)(SWIG_As_int(obj1));
17543 if (SWIG_arg_fail(2)) SWIG_fail;
17544 }
17545 if (arg1) (arg1)->m_x = arg2;
17546
17547 Py_INCREF(Py_None); resultobj = Py_None;
17548 return resultobj;
17549 fail:
17550 return NULL;
17551 }
17552
17553
17554 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17555 PyObject *resultobj;
17556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17557 int result;
17558 PyObject * obj0 = 0 ;
17559 char *kwnames[] = {
17560 (char *) "self", NULL
17561 };
17562
17563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17565 if (SWIG_arg_fail(1)) SWIG_fail;
17566 result = (int) ((arg1)->m_x);
17567
17568 {
17569 resultobj = SWIG_From_int((int)(result));
17570 }
17571 return resultobj;
17572 fail:
17573 return NULL;
17574 }
17575
17576
17577 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17578 PyObject *resultobj;
17579 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17580 int arg2 ;
17581 PyObject * obj0 = 0 ;
17582 PyObject * obj1 = 0 ;
17583 char *kwnames[] = {
17584 (char *) "self",(char *) "m_y", NULL
17585 };
17586
17587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17589 if (SWIG_arg_fail(1)) SWIG_fail;
17590 {
17591 arg2 = (int)(SWIG_As_int(obj1));
17592 if (SWIG_arg_fail(2)) SWIG_fail;
17593 }
17594 if (arg1) (arg1)->m_y = arg2;
17595
17596 Py_INCREF(Py_None); resultobj = Py_None;
17597 return resultobj;
17598 fail:
17599 return NULL;
17600 }
17601
17602
17603 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17604 PyObject *resultobj;
17605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17606 int result;
17607 PyObject * obj0 = 0 ;
17608 char *kwnames[] = {
17609 (char *) "self", NULL
17610 };
17611
17612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17614 if (SWIG_arg_fail(1)) SWIG_fail;
17615 result = (int) ((arg1)->m_y);
17616
17617 {
17618 resultobj = SWIG_From_int((int)(result));
17619 }
17620 return resultobj;
17621 fail:
17622 return NULL;
17623 }
17624
17625
17626 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17627 PyObject *resultobj;
17628 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17629 bool arg2 ;
17630 PyObject * obj0 = 0 ;
17631 PyObject * obj1 = 0 ;
17632 char *kwnames[] = {
17633 (char *) "self",(char *) "m_leftDown", NULL
17634 };
17635
17636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17638 if (SWIG_arg_fail(1)) SWIG_fail;
17639 {
17640 arg2 = (bool)(SWIG_As_bool(obj1));
17641 if (SWIG_arg_fail(2)) SWIG_fail;
17642 }
17643 if (arg1) (arg1)->m_leftDown = arg2;
17644
17645 Py_INCREF(Py_None); resultobj = Py_None;
17646 return resultobj;
17647 fail:
17648 return NULL;
17649 }
17650
17651
17652 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17653 PyObject *resultobj;
17654 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17655 bool result;
17656 PyObject * obj0 = 0 ;
17657 char *kwnames[] = {
17658 (char *) "self", NULL
17659 };
17660
17661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17663 if (SWIG_arg_fail(1)) SWIG_fail;
17664 result = (bool) ((arg1)->m_leftDown);
17665
17666 {
17667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17668 }
17669 return resultobj;
17670 fail:
17671 return NULL;
17672 }
17673
17674
17675 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17676 PyObject *resultobj;
17677 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17678 bool arg2 ;
17679 PyObject * obj0 = 0 ;
17680 PyObject * obj1 = 0 ;
17681 char *kwnames[] = {
17682 (char *) "self",(char *) "m_middleDown", NULL
17683 };
17684
17685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17687 if (SWIG_arg_fail(1)) SWIG_fail;
17688 {
17689 arg2 = (bool)(SWIG_As_bool(obj1));
17690 if (SWIG_arg_fail(2)) SWIG_fail;
17691 }
17692 if (arg1) (arg1)->m_middleDown = arg2;
17693
17694 Py_INCREF(Py_None); resultobj = Py_None;
17695 return resultobj;
17696 fail:
17697 return NULL;
17698 }
17699
17700
17701 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17702 PyObject *resultobj;
17703 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17704 bool result;
17705 PyObject * obj0 = 0 ;
17706 char *kwnames[] = {
17707 (char *) "self", NULL
17708 };
17709
17710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17712 if (SWIG_arg_fail(1)) SWIG_fail;
17713 result = (bool) ((arg1)->m_middleDown);
17714
17715 {
17716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17717 }
17718 return resultobj;
17719 fail:
17720 return NULL;
17721 }
17722
17723
17724 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17725 PyObject *resultobj;
17726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17727 bool arg2 ;
17728 PyObject * obj0 = 0 ;
17729 PyObject * obj1 = 0 ;
17730 char *kwnames[] = {
17731 (char *) "self",(char *) "m_rightDown", NULL
17732 };
17733
17734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17736 if (SWIG_arg_fail(1)) SWIG_fail;
17737 {
17738 arg2 = (bool)(SWIG_As_bool(obj1));
17739 if (SWIG_arg_fail(2)) SWIG_fail;
17740 }
17741 if (arg1) (arg1)->m_rightDown = arg2;
17742
17743 Py_INCREF(Py_None); resultobj = Py_None;
17744 return resultobj;
17745 fail:
17746 return NULL;
17747 }
17748
17749
17750 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17751 PyObject *resultobj;
17752 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17753 bool result;
17754 PyObject * obj0 = 0 ;
17755 char *kwnames[] = {
17756 (char *) "self", NULL
17757 };
17758
17759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17761 if (SWIG_arg_fail(1)) SWIG_fail;
17762 result = (bool) ((arg1)->m_rightDown);
17763
17764 {
17765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17766 }
17767 return resultobj;
17768 fail:
17769 return NULL;
17770 }
17771
17772
17773 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17774 PyObject *resultobj;
17775 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17776 bool arg2 ;
17777 PyObject * obj0 = 0 ;
17778 PyObject * obj1 = 0 ;
17779 char *kwnames[] = {
17780 (char *) "self",(char *) "m_controlDown", NULL
17781 };
17782
17783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17785 if (SWIG_arg_fail(1)) SWIG_fail;
17786 {
17787 arg2 = (bool)(SWIG_As_bool(obj1));
17788 if (SWIG_arg_fail(2)) SWIG_fail;
17789 }
17790 if (arg1) (arg1)->m_controlDown = arg2;
17791
17792 Py_INCREF(Py_None); resultobj = Py_None;
17793 return resultobj;
17794 fail:
17795 return NULL;
17796 }
17797
17798
17799 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17800 PyObject *resultobj;
17801 wxMouseEvent *arg1 = (wxMouseEvent *) 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:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17810 if (SWIG_arg_fail(1)) SWIG_fail;
17811 result = (bool) ((arg1)->m_controlDown);
17812
17813 {
17814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17815 }
17816 return resultobj;
17817 fail:
17818 return NULL;
17819 }
17820
17821
17822 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17823 PyObject *resultobj;
17824 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17825 bool arg2 ;
17826 PyObject * obj0 = 0 ;
17827 PyObject * obj1 = 0 ;
17828 char *kwnames[] = {
17829 (char *) "self",(char *) "m_shiftDown", NULL
17830 };
17831
17832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17834 if (SWIG_arg_fail(1)) SWIG_fail;
17835 {
17836 arg2 = (bool)(SWIG_As_bool(obj1));
17837 if (SWIG_arg_fail(2)) SWIG_fail;
17838 }
17839 if (arg1) (arg1)->m_shiftDown = arg2;
17840
17841 Py_INCREF(Py_None); resultobj = Py_None;
17842 return resultobj;
17843 fail:
17844 return NULL;
17845 }
17846
17847
17848 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17849 PyObject *resultobj;
17850 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17851 bool result;
17852 PyObject * obj0 = 0 ;
17853 char *kwnames[] = {
17854 (char *) "self", NULL
17855 };
17856
17857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17859 if (SWIG_arg_fail(1)) SWIG_fail;
17860 result = (bool) ((arg1)->m_shiftDown);
17861
17862 {
17863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17864 }
17865 return resultobj;
17866 fail:
17867 return NULL;
17868 }
17869
17870
17871 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17872 PyObject *resultobj;
17873 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17874 bool arg2 ;
17875 PyObject * obj0 = 0 ;
17876 PyObject * obj1 = 0 ;
17877 char *kwnames[] = {
17878 (char *) "self",(char *) "m_altDown", NULL
17879 };
17880
17881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17883 if (SWIG_arg_fail(1)) SWIG_fail;
17884 {
17885 arg2 = (bool)(SWIG_As_bool(obj1));
17886 if (SWIG_arg_fail(2)) SWIG_fail;
17887 }
17888 if (arg1) (arg1)->m_altDown = arg2;
17889
17890 Py_INCREF(Py_None); resultobj = Py_None;
17891 return resultobj;
17892 fail:
17893 return NULL;
17894 }
17895
17896
17897 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17898 PyObject *resultobj;
17899 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17900 bool result;
17901 PyObject * obj0 = 0 ;
17902 char *kwnames[] = {
17903 (char *) "self", NULL
17904 };
17905
17906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17908 if (SWIG_arg_fail(1)) SWIG_fail;
17909 result = (bool) ((arg1)->m_altDown);
17910
17911 {
17912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17913 }
17914 return resultobj;
17915 fail:
17916 return NULL;
17917 }
17918
17919
17920 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17921 PyObject *resultobj;
17922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17923 bool arg2 ;
17924 PyObject * obj0 = 0 ;
17925 PyObject * obj1 = 0 ;
17926 char *kwnames[] = {
17927 (char *) "self",(char *) "m_metaDown", NULL
17928 };
17929
17930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17932 if (SWIG_arg_fail(1)) SWIG_fail;
17933 {
17934 arg2 = (bool)(SWIG_As_bool(obj1));
17935 if (SWIG_arg_fail(2)) SWIG_fail;
17936 }
17937 if (arg1) (arg1)->m_metaDown = arg2;
17938
17939 Py_INCREF(Py_None); resultobj = Py_None;
17940 return resultobj;
17941 fail:
17942 return NULL;
17943 }
17944
17945
17946 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17947 PyObject *resultobj;
17948 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17949 bool result;
17950 PyObject * obj0 = 0 ;
17951 char *kwnames[] = {
17952 (char *) "self", NULL
17953 };
17954
17955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17957 if (SWIG_arg_fail(1)) SWIG_fail;
17958 result = (bool) ((arg1)->m_metaDown);
17959
17960 {
17961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17962 }
17963 return resultobj;
17964 fail:
17965 return NULL;
17966 }
17967
17968
17969 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17970 PyObject *resultobj;
17971 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17972 int arg2 ;
17973 PyObject * obj0 = 0 ;
17974 PyObject * obj1 = 0 ;
17975 char *kwnames[] = {
17976 (char *) "self",(char *) "m_wheelRotation", NULL
17977 };
17978
17979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17981 if (SWIG_arg_fail(1)) SWIG_fail;
17982 {
17983 arg2 = (int)(SWIG_As_int(obj1));
17984 if (SWIG_arg_fail(2)) SWIG_fail;
17985 }
17986 if (arg1) (arg1)->m_wheelRotation = arg2;
17987
17988 Py_INCREF(Py_None); resultobj = Py_None;
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17996 PyObject *resultobj;
17997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17998 int result;
17999 PyObject * obj0 = 0 ;
18000 char *kwnames[] = {
18001 (char *) "self", NULL
18002 };
18003
18004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18006 if (SWIG_arg_fail(1)) SWIG_fail;
18007 result = (int) ((arg1)->m_wheelRotation);
18008
18009 {
18010 resultobj = SWIG_From_int((int)(result));
18011 }
18012 return resultobj;
18013 fail:
18014 return NULL;
18015 }
18016
18017
18018 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18019 PyObject *resultobj;
18020 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18021 int arg2 ;
18022 PyObject * obj0 = 0 ;
18023 PyObject * obj1 = 0 ;
18024 char *kwnames[] = {
18025 (char *) "self",(char *) "m_wheelDelta", NULL
18026 };
18027
18028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18030 if (SWIG_arg_fail(1)) SWIG_fail;
18031 {
18032 arg2 = (int)(SWIG_As_int(obj1));
18033 if (SWIG_arg_fail(2)) SWIG_fail;
18034 }
18035 if (arg1) (arg1)->m_wheelDelta = arg2;
18036
18037 Py_INCREF(Py_None); resultobj = Py_None;
18038 return resultobj;
18039 fail:
18040 return NULL;
18041 }
18042
18043
18044 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18045 PyObject *resultobj;
18046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18047 int result;
18048 PyObject * obj0 = 0 ;
18049 char *kwnames[] = {
18050 (char *) "self", NULL
18051 };
18052
18053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18055 if (SWIG_arg_fail(1)) SWIG_fail;
18056 result = (int) ((arg1)->m_wheelDelta);
18057
18058 {
18059 resultobj = SWIG_From_int((int)(result));
18060 }
18061 return resultobj;
18062 fail:
18063 return NULL;
18064 }
18065
18066
18067 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18068 PyObject *resultobj;
18069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18070 int arg2 ;
18071 PyObject * obj0 = 0 ;
18072 PyObject * obj1 = 0 ;
18073 char *kwnames[] = {
18074 (char *) "self",(char *) "m_linesPerAction", NULL
18075 };
18076
18077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18079 if (SWIG_arg_fail(1)) SWIG_fail;
18080 {
18081 arg2 = (int)(SWIG_As_int(obj1));
18082 if (SWIG_arg_fail(2)) SWIG_fail;
18083 }
18084 if (arg1) (arg1)->m_linesPerAction = arg2;
18085
18086 Py_INCREF(Py_None); resultobj = Py_None;
18087 return resultobj;
18088 fail:
18089 return NULL;
18090 }
18091
18092
18093 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18094 PyObject *resultobj;
18095 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18096 int result;
18097 PyObject * obj0 = 0 ;
18098 char *kwnames[] = {
18099 (char *) "self", NULL
18100 };
18101
18102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18104 if (SWIG_arg_fail(1)) SWIG_fail;
18105 result = (int) ((arg1)->m_linesPerAction);
18106
18107 {
18108 resultobj = SWIG_From_int((int)(result));
18109 }
18110 return resultobj;
18111 fail:
18112 return NULL;
18113 }
18114
18115
18116 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18117 PyObject *obj;
18118 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18119 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18120 Py_INCREF(obj);
18121 return Py_BuildValue((char *)"");
18122 }
18123 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18124 PyObject *resultobj;
18125 int arg1 = (int) 0 ;
18126 int arg2 = (int) 0 ;
18127 wxSetCursorEvent *result;
18128 PyObject * obj0 = 0 ;
18129 PyObject * obj1 = 0 ;
18130 char *kwnames[] = {
18131 (char *) "x",(char *) "y", NULL
18132 };
18133
18134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18135 if (obj0) {
18136 {
18137 arg1 = (int)(SWIG_As_int(obj0));
18138 if (SWIG_arg_fail(1)) SWIG_fail;
18139 }
18140 }
18141 if (obj1) {
18142 {
18143 arg2 = (int)(SWIG_As_int(obj1));
18144 if (SWIG_arg_fail(2)) SWIG_fail;
18145 }
18146 }
18147 {
18148 PyThreadState* __tstate = wxPyBeginAllowThreads();
18149 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18150
18151 wxPyEndAllowThreads(__tstate);
18152 if (PyErr_Occurred()) SWIG_fail;
18153 }
18154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18155 return resultobj;
18156 fail:
18157 return NULL;
18158 }
18159
18160
18161 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18162 PyObject *resultobj;
18163 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18164 int result;
18165 PyObject * obj0 = 0 ;
18166 char *kwnames[] = {
18167 (char *) "self", NULL
18168 };
18169
18170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18172 if (SWIG_arg_fail(1)) SWIG_fail;
18173 {
18174 PyThreadState* __tstate = wxPyBeginAllowThreads();
18175 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18176
18177 wxPyEndAllowThreads(__tstate);
18178 if (PyErr_Occurred()) SWIG_fail;
18179 }
18180 {
18181 resultobj = SWIG_From_int((int)(result));
18182 }
18183 return resultobj;
18184 fail:
18185 return NULL;
18186 }
18187
18188
18189 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18190 PyObject *resultobj;
18191 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18192 int result;
18193 PyObject * obj0 = 0 ;
18194 char *kwnames[] = {
18195 (char *) "self", NULL
18196 };
18197
18198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18200 if (SWIG_arg_fail(1)) SWIG_fail;
18201 {
18202 PyThreadState* __tstate = wxPyBeginAllowThreads();
18203 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18204
18205 wxPyEndAllowThreads(__tstate);
18206 if (PyErr_Occurred()) SWIG_fail;
18207 }
18208 {
18209 resultobj = SWIG_From_int((int)(result));
18210 }
18211 return resultobj;
18212 fail:
18213 return NULL;
18214 }
18215
18216
18217 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18218 PyObject *resultobj;
18219 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18220 wxCursor *arg2 = 0 ;
18221 PyObject * obj0 = 0 ;
18222 PyObject * obj1 = 0 ;
18223 char *kwnames[] = {
18224 (char *) "self",(char *) "cursor", NULL
18225 };
18226
18227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18229 if (SWIG_arg_fail(1)) SWIG_fail;
18230 {
18231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18232 if (SWIG_arg_fail(2)) SWIG_fail;
18233 if (arg2 == NULL) {
18234 SWIG_null_ref("wxCursor");
18235 }
18236 if (SWIG_arg_fail(2)) SWIG_fail;
18237 }
18238 {
18239 PyThreadState* __tstate = wxPyBeginAllowThreads();
18240 (arg1)->SetCursor((wxCursor const &)*arg2);
18241
18242 wxPyEndAllowThreads(__tstate);
18243 if (PyErr_Occurred()) SWIG_fail;
18244 }
18245 Py_INCREF(Py_None); resultobj = Py_None;
18246 return resultobj;
18247 fail:
18248 return NULL;
18249 }
18250
18251
18252 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18253 PyObject *resultobj;
18254 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18255 wxCursor *result;
18256 PyObject * obj0 = 0 ;
18257 char *kwnames[] = {
18258 (char *) "self", NULL
18259 };
18260
18261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18263 if (SWIG_arg_fail(1)) SWIG_fail;
18264 {
18265 PyThreadState* __tstate = wxPyBeginAllowThreads();
18266 {
18267 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18268 result = (wxCursor *) &_result_ref;
18269 }
18270
18271 wxPyEndAllowThreads(__tstate);
18272 if (PyErr_Occurred()) SWIG_fail;
18273 }
18274 {
18275 wxCursor* resultptr = new wxCursor(*result);
18276 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18277 }
18278 return resultobj;
18279 fail:
18280 return NULL;
18281 }
18282
18283
18284 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18285 PyObject *resultobj;
18286 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 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:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18295 if (SWIG_arg_fail(1)) SWIG_fail;
18296 {
18297 PyThreadState* __tstate = wxPyBeginAllowThreads();
18298 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18299
18300 wxPyEndAllowThreads(__tstate);
18301 if (PyErr_Occurred()) SWIG_fail;
18302 }
18303 {
18304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18305 }
18306 return resultobj;
18307 fail:
18308 return NULL;
18309 }
18310
18311
18312 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18313 PyObject *obj;
18314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18315 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18316 Py_INCREF(obj);
18317 return Py_BuildValue((char *)"");
18318 }
18319 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18320 PyObject *resultobj;
18321 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18322 wxKeyEvent *result;
18323 PyObject * obj0 = 0 ;
18324 char *kwnames[] = {
18325 (char *) "keyType", NULL
18326 };
18327
18328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18329 if (obj0) {
18330 {
18331 arg1 = (wxEventType)(SWIG_As_int(obj0));
18332 if (SWIG_arg_fail(1)) SWIG_fail;
18333 }
18334 }
18335 {
18336 PyThreadState* __tstate = wxPyBeginAllowThreads();
18337 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18338
18339 wxPyEndAllowThreads(__tstate);
18340 if (PyErr_Occurred()) SWIG_fail;
18341 }
18342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18343 return resultobj;
18344 fail:
18345 return NULL;
18346 }
18347
18348
18349 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18350 PyObject *resultobj;
18351 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18352 bool result;
18353 PyObject * obj0 = 0 ;
18354 char *kwnames[] = {
18355 (char *) "self", NULL
18356 };
18357
18358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18360 if (SWIG_arg_fail(1)) SWIG_fail;
18361 {
18362 PyThreadState* __tstate = wxPyBeginAllowThreads();
18363 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18364
18365 wxPyEndAllowThreads(__tstate);
18366 if (PyErr_Occurred()) SWIG_fail;
18367 }
18368 {
18369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18370 }
18371 return resultobj;
18372 fail:
18373 return NULL;
18374 }
18375
18376
18377 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18378 PyObject *resultobj;
18379 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18380 bool result;
18381 PyObject * obj0 = 0 ;
18382 char *kwnames[] = {
18383 (char *) "self", NULL
18384 };
18385
18386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18388 if (SWIG_arg_fail(1)) SWIG_fail;
18389 {
18390 PyThreadState* __tstate = wxPyBeginAllowThreads();
18391 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18392
18393 wxPyEndAllowThreads(__tstate);
18394 if (PyErr_Occurred()) SWIG_fail;
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_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18406 PyObject *resultobj;
18407 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18408 bool result;
18409 PyObject * obj0 = 0 ;
18410 char *kwnames[] = {
18411 (char *) "self", NULL
18412 };
18413
18414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18416 if (SWIG_arg_fail(1)) SWIG_fail;
18417 {
18418 PyThreadState* __tstate = wxPyBeginAllowThreads();
18419 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18420
18421 wxPyEndAllowThreads(__tstate);
18422 if (PyErr_Occurred()) SWIG_fail;
18423 }
18424 {
18425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18426 }
18427 return resultobj;
18428 fail:
18429 return NULL;
18430 }
18431
18432
18433 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18434 PyObject *resultobj;
18435 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18436 bool result;
18437 PyObject * obj0 = 0 ;
18438 char *kwnames[] = {
18439 (char *) "self", NULL
18440 };
18441
18442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18444 if (SWIG_arg_fail(1)) SWIG_fail;
18445 {
18446 PyThreadState* __tstate = wxPyBeginAllowThreads();
18447 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18448
18449 wxPyEndAllowThreads(__tstate);
18450 if (PyErr_Occurred()) SWIG_fail;
18451 }
18452 {
18453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18454 }
18455 return resultobj;
18456 fail:
18457 return NULL;
18458 }
18459
18460
18461 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18462 PyObject *resultobj;
18463 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18464 bool result;
18465 PyObject * obj0 = 0 ;
18466 char *kwnames[] = {
18467 (char *) "self", NULL
18468 };
18469
18470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18472 if (SWIG_arg_fail(1)) SWIG_fail;
18473 {
18474 PyThreadState* __tstate = wxPyBeginAllowThreads();
18475 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18476
18477 wxPyEndAllowThreads(__tstate);
18478 if (PyErr_Occurred()) SWIG_fail;
18479 }
18480 {
18481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18482 }
18483 return resultobj;
18484 fail:
18485 return NULL;
18486 }
18487
18488
18489 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18490 PyObject *resultobj;
18491 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18492 bool result;
18493 PyObject * obj0 = 0 ;
18494 char *kwnames[] = {
18495 (char *) "self", NULL
18496 };
18497
18498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18500 if (SWIG_arg_fail(1)) SWIG_fail;
18501 {
18502 PyThreadState* __tstate = wxPyBeginAllowThreads();
18503 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18504
18505 wxPyEndAllowThreads(__tstate);
18506 if (PyErr_Occurred()) SWIG_fail;
18507 }
18508 {
18509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18510 }
18511 return resultobj;
18512 fail:
18513 return NULL;
18514 }
18515
18516
18517 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18518 PyObject *resultobj;
18519 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18520 int result;
18521 PyObject * obj0 = 0 ;
18522 char *kwnames[] = {
18523 (char *) "self", NULL
18524 };
18525
18526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18528 if (SWIG_arg_fail(1)) SWIG_fail;
18529 {
18530 PyThreadState* __tstate = wxPyBeginAllowThreads();
18531 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18532
18533 wxPyEndAllowThreads(__tstate);
18534 if (PyErr_Occurred()) SWIG_fail;
18535 }
18536 {
18537 resultobj = SWIG_From_int((int)(result));
18538 }
18539 return resultobj;
18540 fail:
18541 return NULL;
18542 }
18543
18544
18545 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18546 PyObject *resultobj;
18547 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18548 int result;
18549 PyObject * obj0 = 0 ;
18550 char *kwnames[] = {
18551 (char *) "self", NULL
18552 };
18553
18554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18556 if (SWIG_arg_fail(1)) SWIG_fail;
18557 {
18558 PyThreadState* __tstate = wxPyBeginAllowThreads();
18559 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18560
18561 wxPyEndAllowThreads(__tstate);
18562 if (PyErr_Occurred()) SWIG_fail;
18563 }
18564 {
18565 resultobj = SWIG_From_int((int)(result));
18566 }
18567 return resultobj;
18568 fail:
18569 return NULL;
18570 }
18571
18572
18573 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18574 PyObject *resultobj;
18575 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18576 unsigned int result;
18577 PyObject * obj0 = 0 ;
18578 char *kwnames[] = {
18579 (char *) "self", NULL
18580 };
18581
18582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18584 if (SWIG_arg_fail(1)) SWIG_fail;
18585 {
18586 PyThreadState* __tstate = wxPyBeginAllowThreads();
18587 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18588
18589 wxPyEndAllowThreads(__tstate);
18590 if (PyErr_Occurred()) SWIG_fail;
18591 }
18592 {
18593 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18594 }
18595 return resultobj;
18596 fail:
18597 return NULL;
18598 }
18599
18600
18601 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18602 PyObject *resultobj;
18603 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18604 unsigned int result;
18605 PyObject * obj0 = 0 ;
18606 char *kwnames[] = {
18607 (char *) "self", NULL
18608 };
18609
18610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18612 if (SWIG_arg_fail(1)) SWIG_fail;
18613 {
18614 PyThreadState* __tstate = wxPyBeginAllowThreads();
18615 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18616
18617 wxPyEndAllowThreads(__tstate);
18618 if (PyErr_Occurred()) SWIG_fail;
18619 }
18620 {
18621 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18622 }
18623 return resultobj;
18624 fail:
18625 return NULL;
18626 }
18627
18628
18629 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18630 PyObject *resultobj;
18631 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18632 wxPoint result;
18633 PyObject * obj0 = 0 ;
18634 char *kwnames[] = {
18635 (char *) "self", NULL
18636 };
18637
18638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18640 if (SWIG_arg_fail(1)) SWIG_fail;
18641 {
18642 PyThreadState* __tstate = wxPyBeginAllowThreads();
18643 result = (arg1)->GetPosition();
18644
18645 wxPyEndAllowThreads(__tstate);
18646 if (PyErr_Occurred()) SWIG_fail;
18647 }
18648 {
18649 wxPoint * resultptr;
18650 resultptr = new wxPoint((wxPoint &)(result));
18651 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18652 }
18653 return resultobj;
18654 fail:
18655 return NULL;
18656 }
18657
18658
18659 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18660 PyObject *resultobj;
18661 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18662 long *arg2 = (long *) 0 ;
18663 long *arg3 = (long *) 0 ;
18664 long temp2 ;
18665 int res2 = 0 ;
18666 long temp3 ;
18667 int res3 = 0 ;
18668 PyObject * obj0 = 0 ;
18669 char *kwnames[] = {
18670 (char *) "self", NULL
18671 };
18672
18673 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18674 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18677 if (SWIG_arg_fail(1)) SWIG_fail;
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 (arg1)->GetPosition(arg2,arg3);
18681
18682 wxPyEndAllowThreads(__tstate);
18683 if (PyErr_Occurred()) SWIG_fail;
18684 }
18685 Py_INCREF(Py_None); resultobj = Py_None;
18686 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18687 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18688 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18689 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18690 return resultobj;
18691 fail:
18692 return NULL;
18693 }
18694
18695
18696 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18697 PyObject *resultobj;
18698 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18699 int result;
18700 PyObject * obj0 = 0 ;
18701 char *kwnames[] = {
18702 (char *) "self", NULL
18703 };
18704
18705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18707 if (SWIG_arg_fail(1)) SWIG_fail;
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 result = (int)((wxKeyEvent const *)arg1)->GetX();
18711
18712 wxPyEndAllowThreads(__tstate);
18713 if (PyErr_Occurred()) SWIG_fail;
18714 }
18715 {
18716 resultobj = SWIG_From_int((int)(result));
18717 }
18718 return resultobj;
18719 fail:
18720 return NULL;
18721 }
18722
18723
18724 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18725 PyObject *resultobj;
18726 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18727 int result;
18728 PyObject * obj0 = 0 ;
18729 char *kwnames[] = {
18730 (char *) "self", NULL
18731 };
18732
18733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18735 if (SWIG_arg_fail(1)) SWIG_fail;
18736 {
18737 PyThreadState* __tstate = wxPyBeginAllowThreads();
18738 result = (int)((wxKeyEvent const *)arg1)->GetY();
18739
18740 wxPyEndAllowThreads(__tstate);
18741 if (PyErr_Occurred()) SWIG_fail;
18742 }
18743 {
18744 resultobj = SWIG_From_int((int)(result));
18745 }
18746 return resultobj;
18747 fail:
18748 return NULL;
18749 }
18750
18751
18752 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18753 PyObject *resultobj;
18754 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18755 int arg2 ;
18756 PyObject * obj0 = 0 ;
18757 PyObject * obj1 = 0 ;
18758 char *kwnames[] = {
18759 (char *) "self",(char *) "m_x", NULL
18760 };
18761
18762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18764 if (SWIG_arg_fail(1)) SWIG_fail;
18765 {
18766 arg2 = (int)(SWIG_As_int(obj1));
18767 if (SWIG_arg_fail(2)) SWIG_fail;
18768 }
18769 if (arg1) (arg1)->m_x = arg2;
18770
18771 Py_INCREF(Py_None); resultobj = Py_None;
18772 return resultobj;
18773 fail:
18774 return NULL;
18775 }
18776
18777
18778 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18779 PyObject *resultobj;
18780 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18781 int result;
18782 PyObject * obj0 = 0 ;
18783 char *kwnames[] = {
18784 (char *) "self", NULL
18785 };
18786
18787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18789 if (SWIG_arg_fail(1)) SWIG_fail;
18790 result = (int) ((arg1)->m_x);
18791
18792 {
18793 resultobj = SWIG_From_int((int)(result));
18794 }
18795 return resultobj;
18796 fail:
18797 return NULL;
18798 }
18799
18800
18801 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18802 PyObject *resultobj;
18803 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18804 int arg2 ;
18805 PyObject * obj0 = 0 ;
18806 PyObject * obj1 = 0 ;
18807 char *kwnames[] = {
18808 (char *) "self",(char *) "m_y", NULL
18809 };
18810
18811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18813 if (SWIG_arg_fail(1)) SWIG_fail;
18814 {
18815 arg2 = (int)(SWIG_As_int(obj1));
18816 if (SWIG_arg_fail(2)) SWIG_fail;
18817 }
18818 if (arg1) (arg1)->m_y = arg2;
18819
18820 Py_INCREF(Py_None); resultobj = Py_None;
18821 return resultobj;
18822 fail:
18823 return NULL;
18824 }
18825
18826
18827 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18828 PyObject *resultobj;
18829 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18830 int result;
18831 PyObject * obj0 = 0 ;
18832 char *kwnames[] = {
18833 (char *) "self", NULL
18834 };
18835
18836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18838 if (SWIG_arg_fail(1)) SWIG_fail;
18839 result = (int) ((arg1)->m_y);
18840
18841 {
18842 resultobj = SWIG_From_int((int)(result));
18843 }
18844 return resultobj;
18845 fail:
18846 return NULL;
18847 }
18848
18849
18850 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18851 PyObject *resultobj;
18852 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18853 long arg2 ;
18854 PyObject * obj0 = 0 ;
18855 PyObject * obj1 = 0 ;
18856 char *kwnames[] = {
18857 (char *) "self",(char *) "m_keyCode", NULL
18858 };
18859
18860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18862 if (SWIG_arg_fail(1)) SWIG_fail;
18863 {
18864 arg2 = (long)(SWIG_As_long(obj1));
18865 if (SWIG_arg_fail(2)) SWIG_fail;
18866 }
18867 if (arg1) (arg1)->m_keyCode = arg2;
18868
18869 Py_INCREF(Py_None); resultobj = Py_None;
18870 return resultobj;
18871 fail:
18872 return NULL;
18873 }
18874
18875
18876 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18877 PyObject *resultobj;
18878 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18879 long result;
18880 PyObject * obj0 = 0 ;
18881 char *kwnames[] = {
18882 (char *) "self", NULL
18883 };
18884
18885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18887 if (SWIG_arg_fail(1)) SWIG_fail;
18888 result = (long) ((arg1)->m_keyCode);
18889
18890 {
18891 resultobj = SWIG_From_long((long)(result));
18892 }
18893 return resultobj;
18894 fail:
18895 return NULL;
18896 }
18897
18898
18899 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18900 PyObject *resultobj;
18901 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18902 bool arg2 ;
18903 PyObject * obj0 = 0 ;
18904 PyObject * obj1 = 0 ;
18905 char *kwnames[] = {
18906 (char *) "self",(char *) "m_controlDown", NULL
18907 };
18908
18909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18911 if (SWIG_arg_fail(1)) SWIG_fail;
18912 {
18913 arg2 = (bool)(SWIG_As_bool(obj1));
18914 if (SWIG_arg_fail(2)) SWIG_fail;
18915 }
18916 if (arg1) (arg1)->m_controlDown = arg2;
18917
18918 Py_INCREF(Py_None); resultobj = Py_None;
18919 return resultobj;
18920 fail:
18921 return NULL;
18922 }
18923
18924
18925 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18926 PyObject *resultobj;
18927 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18928 bool result;
18929 PyObject * obj0 = 0 ;
18930 char *kwnames[] = {
18931 (char *) "self", NULL
18932 };
18933
18934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18936 if (SWIG_arg_fail(1)) SWIG_fail;
18937 result = (bool) ((arg1)->m_controlDown);
18938
18939 {
18940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18941 }
18942 return resultobj;
18943 fail:
18944 return NULL;
18945 }
18946
18947
18948 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18949 PyObject *resultobj;
18950 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18951 bool arg2 ;
18952 PyObject * obj0 = 0 ;
18953 PyObject * obj1 = 0 ;
18954 char *kwnames[] = {
18955 (char *) "self",(char *) "m_shiftDown", NULL
18956 };
18957
18958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18960 if (SWIG_arg_fail(1)) SWIG_fail;
18961 {
18962 arg2 = (bool)(SWIG_As_bool(obj1));
18963 if (SWIG_arg_fail(2)) SWIG_fail;
18964 }
18965 if (arg1) (arg1)->m_shiftDown = arg2;
18966
18967 Py_INCREF(Py_None); resultobj = Py_None;
18968 return resultobj;
18969 fail:
18970 return NULL;
18971 }
18972
18973
18974 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18975 PyObject *resultobj;
18976 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18977 bool result;
18978 PyObject * obj0 = 0 ;
18979 char *kwnames[] = {
18980 (char *) "self", NULL
18981 };
18982
18983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18985 if (SWIG_arg_fail(1)) SWIG_fail;
18986 result = (bool) ((arg1)->m_shiftDown);
18987
18988 {
18989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18990 }
18991 return resultobj;
18992 fail:
18993 return NULL;
18994 }
18995
18996
18997 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18998 PyObject *resultobj;
18999 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19000 bool arg2 ;
19001 PyObject * obj0 = 0 ;
19002 PyObject * obj1 = 0 ;
19003 char *kwnames[] = {
19004 (char *) "self",(char *) "m_altDown", NULL
19005 };
19006
19007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19009 if (SWIG_arg_fail(1)) SWIG_fail;
19010 {
19011 arg2 = (bool)(SWIG_As_bool(obj1));
19012 if (SWIG_arg_fail(2)) SWIG_fail;
19013 }
19014 if (arg1) (arg1)->m_altDown = arg2;
19015
19016 Py_INCREF(Py_None); resultobj = Py_None;
19017 return resultobj;
19018 fail:
19019 return NULL;
19020 }
19021
19022
19023 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19024 PyObject *resultobj;
19025 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19026 bool result;
19027 PyObject * obj0 = 0 ;
19028 char *kwnames[] = {
19029 (char *) "self", NULL
19030 };
19031
19032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19034 if (SWIG_arg_fail(1)) SWIG_fail;
19035 result = (bool) ((arg1)->m_altDown);
19036
19037 {
19038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19039 }
19040 return resultobj;
19041 fail:
19042 return NULL;
19043 }
19044
19045
19046 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19047 PyObject *resultobj;
19048 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19049 bool arg2 ;
19050 PyObject * obj0 = 0 ;
19051 PyObject * obj1 = 0 ;
19052 char *kwnames[] = {
19053 (char *) "self",(char *) "m_metaDown", NULL
19054 };
19055
19056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19058 if (SWIG_arg_fail(1)) SWIG_fail;
19059 {
19060 arg2 = (bool)(SWIG_As_bool(obj1));
19061 if (SWIG_arg_fail(2)) SWIG_fail;
19062 }
19063 if (arg1) (arg1)->m_metaDown = arg2;
19064
19065 Py_INCREF(Py_None); resultobj = Py_None;
19066 return resultobj;
19067 fail:
19068 return NULL;
19069 }
19070
19071
19072 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19073 PyObject *resultobj;
19074 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19075 bool result;
19076 PyObject * obj0 = 0 ;
19077 char *kwnames[] = {
19078 (char *) "self", NULL
19079 };
19080
19081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19083 if (SWIG_arg_fail(1)) SWIG_fail;
19084 result = (bool) ((arg1)->m_metaDown);
19085
19086 {
19087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19088 }
19089 return resultobj;
19090 fail:
19091 return NULL;
19092 }
19093
19094
19095 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19096 PyObject *resultobj;
19097 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19098 bool arg2 ;
19099 PyObject * obj0 = 0 ;
19100 PyObject * obj1 = 0 ;
19101 char *kwnames[] = {
19102 (char *) "self",(char *) "m_scanCode", NULL
19103 };
19104
19105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19107 if (SWIG_arg_fail(1)) SWIG_fail;
19108 {
19109 arg2 = (bool)(SWIG_As_bool(obj1));
19110 if (SWIG_arg_fail(2)) SWIG_fail;
19111 }
19112 if (arg1) (arg1)->m_scanCode = arg2;
19113
19114 Py_INCREF(Py_None); resultobj = Py_None;
19115 return resultobj;
19116 fail:
19117 return NULL;
19118 }
19119
19120
19121 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19122 PyObject *resultobj;
19123 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19124 bool result;
19125 PyObject * obj0 = 0 ;
19126 char *kwnames[] = {
19127 (char *) "self", NULL
19128 };
19129
19130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19132 if (SWIG_arg_fail(1)) SWIG_fail;
19133 result = (bool) ((arg1)->m_scanCode);
19134
19135 {
19136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19137 }
19138 return resultobj;
19139 fail:
19140 return NULL;
19141 }
19142
19143
19144 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19145 PyObject *resultobj;
19146 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19147 unsigned int arg2 ;
19148 PyObject * obj0 = 0 ;
19149 PyObject * obj1 = 0 ;
19150 char *kwnames[] = {
19151 (char *) "self",(char *) "m_rawCode", NULL
19152 };
19153
19154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19156 if (SWIG_arg_fail(1)) SWIG_fail;
19157 {
19158 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19159 if (SWIG_arg_fail(2)) SWIG_fail;
19160 }
19161 if (arg1) (arg1)->m_rawCode = arg2;
19162
19163 Py_INCREF(Py_None); resultobj = Py_None;
19164 return resultobj;
19165 fail:
19166 return NULL;
19167 }
19168
19169
19170 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19171 PyObject *resultobj;
19172 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19173 unsigned int result;
19174 PyObject * obj0 = 0 ;
19175 char *kwnames[] = {
19176 (char *) "self", NULL
19177 };
19178
19179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19181 if (SWIG_arg_fail(1)) SWIG_fail;
19182 result = (unsigned int) ((arg1)->m_rawCode);
19183
19184 {
19185 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19186 }
19187 return resultobj;
19188 fail:
19189 return NULL;
19190 }
19191
19192
19193 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19194 PyObject *resultobj;
19195 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19196 unsigned int arg2 ;
19197 PyObject * obj0 = 0 ;
19198 PyObject * obj1 = 0 ;
19199 char *kwnames[] = {
19200 (char *) "self",(char *) "m_rawFlags", NULL
19201 };
19202
19203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19205 if (SWIG_arg_fail(1)) SWIG_fail;
19206 {
19207 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19208 if (SWIG_arg_fail(2)) SWIG_fail;
19209 }
19210 if (arg1) (arg1)->m_rawFlags = arg2;
19211
19212 Py_INCREF(Py_None); resultobj = Py_None;
19213 return resultobj;
19214 fail:
19215 return NULL;
19216 }
19217
19218
19219 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19220 PyObject *resultobj;
19221 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19222 unsigned int result;
19223 PyObject * obj0 = 0 ;
19224 char *kwnames[] = {
19225 (char *) "self", NULL
19226 };
19227
19228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19230 if (SWIG_arg_fail(1)) SWIG_fail;
19231 result = (unsigned int) ((arg1)->m_rawFlags);
19232
19233 {
19234 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19235 }
19236 return resultobj;
19237 fail:
19238 return NULL;
19239 }
19240
19241
19242 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19243 PyObject *obj;
19244 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19245 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19246 Py_INCREF(obj);
19247 return Py_BuildValue((char *)"");
19248 }
19249 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19250 PyObject *resultobj;
19251 wxSize const &arg1_defvalue = wxDefaultSize ;
19252 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19253 int arg2 = (int) 0 ;
19254 wxSizeEvent *result;
19255 wxSize temp1 ;
19256 PyObject * obj0 = 0 ;
19257 PyObject * obj1 = 0 ;
19258 char *kwnames[] = {
19259 (char *) "sz",(char *) "winid", NULL
19260 };
19261
19262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19263 if (obj0) {
19264 {
19265 arg1 = &temp1;
19266 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19267 }
19268 }
19269 if (obj1) {
19270 {
19271 arg2 = (int)(SWIG_As_int(obj1));
19272 if (SWIG_arg_fail(2)) SWIG_fail;
19273 }
19274 }
19275 {
19276 PyThreadState* __tstate = wxPyBeginAllowThreads();
19277 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19278
19279 wxPyEndAllowThreads(__tstate);
19280 if (PyErr_Occurred()) SWIG_fail;
19281 }
19282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19283 return resultobj;
19284 fail:
19285 return NULL;
19286 }
19287
19288
19289 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19290 PyObject *resultobj;
19291 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19292 wxSize result;
19293 PyObject * obj0 = 0 ;
19294 char *kwnames[] = {
19295 (char *) "self", NULL
19296 };
19297
19298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19300 if (SWIG_arg_fail(1)) SWIG_fail;
19301 {
19302 PyThreadState* __tstate = wxPyBeginAllowThreads();
19303 result = ((wxSizeEvent const *)arg1)->GetSize();
19304
19305 wxPyEndAllowThreads(__tstate);
19306 if (PyErr_Occurred()) SWIG_fail;
19307 }
19308 {
19309 wxSize * resultptr;
19310 resultptr = new wxSize((wxSize &)(result));
19311 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19312 }
19313 return resultobj;
19314 fail:
19315 return NULL;
19316 }
19317
19318
19319 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19320 PyObject *resultobj;
19321 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19322 wxRect result;
19323 PyObject * obj0 = 0 ;
19324 char *kwnames[] = {
19325 (char *) "self", NULL
19326 };
19327
19328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19330 if (SWIG_arg_fail(1)) SWIG_fail;
19331 {
19332 PyThreadState* __tstate = wxPyBeginAllowThreads();
19333 result = ((wxSizeEvent const *)arg1)->GetRect();
19334
19335 wxPyEndAllowThreads(__tstate);
19336 if (PyErr_Occurred()) SWIG_fail;
19337 }
19338 {
19339 wxRect * resultptr;
19340 resultptr = new wxRect((wxRect &)(result));
19341 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19342 }
19343 return resultobj;
19344 fail:
19345 return NULL;
19346 }
19347
19348
19349 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19350 PyObject *resultobj;
19351 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19352 wxRect arg2 ;
19353 PyObject * obj0 = 0 ;
19354 PyObject * obj1 = 0 ;
19355 char *kwnames[] = {
19356 (char *) "self",(char *) "rect", NULL
19357 };
19358
19359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19361 if (SWIG_arg_fail(1)) SWIG_fail;
19362 {
19363 wxRect * argp;
19364 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19365 if (SWIG_arg_fail(2)) SWIG_fail;
19366 if (argp == NULL) {
19367 SWIG_null_ref("wxRect");
19368 }
19369 if (SWIG_arg_fail(2)) SWIG_fail;
19370 arg2 = *argp;
19371 }
19372 {
19373 PyThreadState* __tstate = wxPyBeginAllowThreads();
19374 (arg1)->SetRect(arg2);
19375
19376 wxPyEndAllowThreads(__tstate);
19377 if (PyErr_Occurred()) SWIG_fail;
19378 }
19379 Py_INCREF(Py_None); resultobj = Py_None;
19380 return resultobj;
19381 fail:
19382 return NULL;
19383 }
19384
19385
19386 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19387 PyObject *resultobj;
19388 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19389 wxSize arg2 ;
19390 PyObject * obj0 = 0 ;
19391 PyObject * obj1 = 0 ;
19392 char *kwnames[] = {
19393 (char *) "self",(char *) "size", NULL
19394 };
19395
19396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19398 if (SWIG_arg_fail(1)) SWIG_fail;
19399 {
19400 wxSize * argp;
19401 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19402 if (SWIG_arg_fail(2)) SWIG_fail;
19403 if (argp == NULL) {
19404 SWIG_null_ref("wxSize");
19405 }
19406 if (SWIG_arg_fail(2)) SWIG_fail;
19407 arg2 = *argp;
19408 }
19409 {
19410 PyThreadState* __tstate = wxPyBeginAllowThreads();
19411 wxSizeEvent_SetSize(arg1,arg2);
19412
19413 wxPyEndAllowThreads(__tstate);
19414 if (PyErr_Occurred()) SWIG_fail;
19415 }
19416 Py_INCREF(Py_None); resultobj = Py_None;
19417 return resultobj;
19418 fail:
19419 return NULL;
19420 }
19421
19422
19423 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19424 PyObject *resultobj;
19425 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19426 wxSize *arg2 = (wxSize *) 0 ;
19427 PyObject * obj0 = 0 ;
19428 PyObject * obj1 = 0 ;
19429 char *kwnames[] = {
19430 (char *) "self",(char *) "m_size", NULL
19431 };
19432
19433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19435 if (SWIG_arg_fail(1)) SWIG_fail;
19436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19437 if (SWIG_arg_fail(2)) SWIG_fail;
19438 if (arg1) (arg1)->m_size = *arg2;
19439
19440 Py_INCREF(Py_None); resultobj = Py_None;
19441 return resultobj;
19442 fail:
19443 return NULL;
19444 }
19445
19446
19447 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19448 PyObject *resultobj;
19449 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19450 wxSize *result;
19451 PyObject * obj0 = 0 ;
19452 char *kwnames[] = {
19453 (char *) "self", NULL
19454 };
19455
19456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19458 if (SWIG_arg_fail(1)) SWIG_fail;
19459 result = (wxSize *)& ((arg1)->m_size);
19460
19461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19462 return resultobj;
19463 fail:
19464 return NULL;
19465 }
19466
19467
19468 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19469 PyObject *resultobj;
19470 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19471 wxRect *arg2 = (wxRect *) 0 ;
19472 PyObject * obj0 = 0 ;
19473 PyObject * obj1 = 0 ;
19474 char *kwnames[] = {
19475 (char *) "self",(char *) "m_rect", NULL
19476 };
19477
19478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19480 if (SWIG_arg_fail(1)) SWIG_fail;
19481 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19482 if (SWIG_arg_fail(2)) SWIG_fail;
19483 if (arg1) (arg1)->m_rect = *arg2;
19484
19485 Py_INCREF(Py_None); resultobj = Py_None;
19486 return resultobj;
19487 fail:
19488 return NULL;
19489 }
19490
19491
19492 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19493 PyObject *resultobj;
19494 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19495 wxRect *result;
19496 PyObject * obj0 = 0 ;
19497 char *kwnames[] = {
19498 (char *) "self", NULL
19499 };
19500
19501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19503 if (SWIG_arg_fail(1)) SWIG_fail;
19504 result = (wxRect *)& ((arg1)->m_rect);
19505
19506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19507 return resultobj;
19508 fail:
19509 return NULL;
19510 }
19511
19512
19513 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19514 PyObject *obj;
19515 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19516 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19517 Py_INCREF(obj);
19518 return Py_BuildValue((char *)"");
19519 }
19520 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19521 PyObject *resultobj;
19522 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19523 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19524 int arg2 = (int) 0 ;
19525 wxMoveEvent *result;
19526 wxPoint temp1 ;
19527 PyObject * obj0 = 0 ;
19528 PyObject * obj1 = 0 ;
19529 char *kwnames[] = {
19530 (char *) "pos",(char *) "winid", NULL
19531 };
19532
19533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19534 if (obj0) {
19535 {
19536 arg1 = &temp1;
19537 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19538 }
19539 }
19540 if (obj1) {
19541 {
19542 arg2 = (int)(SWIG_As_int(obj1));
19543 if (SWIG_arg_fail(2)) SWIG_fail;
19544 }
19545 }
19546 {
19547 PyThreadState* __tstate = wxPyBeginAllowThreads();
19548 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19549
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19561 PyObject *resultobj;
19562 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19563 wxPoint result;
19564 PyObject * obj0 = 0 ;
19565 char *kwnames[] = {
19566 (char *) "self", NULL
19567 };
19568
19569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19571 if (SWIG_arg_fail(1)) SWIG_fail;
19572 {
19573 PyThreadState* __tstate = wxPyBeginAllowThreads();
19574 result = ((wxMoveEvent const *)arg1)->GetPosition();
19575
19576 wxPyEndAllowThreads(__tstate);
19577 if (PyErr_Occurred()) SWIG_fail;
19578 }
19579 {
19580 wxPoint * resultptr;
19581 resultptr = new wxPoint((wxPoint &)(result));
19582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19583 }
19584 return resultobj;
19585 fail:
19586 return NULL;
19587 }
19588
19589
19590 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19591 PyObject *resultobj;
19592 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19593 wxRect result;
19594 PyObject * obj0 = 0 ;
19595 char *kwnames[] = {
19596 (char *) "self", NULL
19597 };
19598
19599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19601 if (SWIG_arg_fail(1)) SWIG_fail;
19602 {
19603 PyThreadState* __tstate = wxPyBeginAllowThreads();
19604 result = ((wxMoveEvent const *)arg1)->GetRect();
19605
19606 wxPyEndAllowThreads(__tstate);
19607 if (PyErr_Occurred()) SWIG_fail;
19608 }
19609 {
19610 wxRect * resultptr;
19611 resultptr = new wxRect((wxRect &)(result));
19612 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19613 }
19614 return resultobj;
19615 fail:
19616 return NULL;
19617 }
19618
19619
19620 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19621 PyObject *resultobj;
19622 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19623 wxRect *arg2 = 0 ;
19624 wxRect temp2 ;
19625 PyObject * obj0 = 0 ;
19626 PyObject * obj1 = 0 ;
19627 char *kwnames[] = {
19628 (char *) "self",(char *) "rect", NULL
19629 };
19630
19631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19633 if (SWIG_arg_fail(1)) SWIG_fail;
19634 {
19635 arg2 = &temp2;
19636 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19637 }
19638 {
19639 PyThreadState* __tstate = wxPyBeginAllowThreads();
19640 (arg1)->SetRect((wxRect const &)*arg2);
19641
19642 wxPyEndAllowThreads(__tstate);
19643 if (PyErr_Occurred()) SWIG_fail;
19644 }
19645 Py_INCREF(Py_None); resultobj = Py_None;
19646 return resultobj;
19647 fail:
19648 return NULL;
19649 }
19650
19651
19652 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19653 PyObject *resultobj;
19654 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19655 wxPoint *arg2 = 0 ;
19656 wxPoint temp2 ;
19657 PyObject * obj0 = 0 ;
19658 PyObject * obj1 = 0 ;
19659 char *kwnames[] = {
19660 (char *) "self",(char *) "pos", NULL
19661 };
19662
19663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19665 if (SWIG_arg_fail(1)) SWIG_fail;
19666 {
19667 arg2 = &temp2;
19668 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19669 }
19670 {
19671 PyThreadState* __tstate = wxPyBeginAllowThreads();
19672 (arg1)->SetPosition((wxPoint const &)*arg2);
19673
19674 wxPyEndAllowThreads(__tstate);
19675 if (PyErr_Occurred()) SWIG_fail;
19676 }
19677 Py_INCREF(Py_None); resultobj = Py_None;
19678 return resultobj;
19679 fail:
19680 return NULL;
19681 }
19682
19683
19684 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19685 PyObject *obj;
19686 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19687 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19688 Py_INCREF(obj);
19689 return Py_BuildValue((char *)"");
19690 }
19691 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19692 PyObject *resultobj;
19693 int arg1 = (int) 0 ;
19694 wxPaintEvent *result;
19695 PyObject * obj0 = 0 ;
19696 char *kwnames[] = {
19697 (char *) "Id", NULL
19698 };
19699
19700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19701 if (obj0) {
19702 {
19703 arg1 = (int)(SWIG_As_int(obj0));
19704 if (SWIG_arg_fail(1)) SWIG_fail;
19705 }
19706 }
19707 {
19708 PyThreadState* __tstate = wxPyBeginAllowThreads();
19709 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19710
19711 wxPyEndAllowThreads(__tstate);
19712 if (PyErr_Occurred()) SWIG_fail;
19713 }
19714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19715 return resultobj;
19716 fail:
19717 return NULL;
19718 }
19719
19720
19721 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19722 PyObject *obj;
19723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19724 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19725 Py_INCREF(obj);
19726 return Py_BuildValue((char *)"");
19727 }
19728 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19729 PyObject *resultobj;
19730 int arg1 = (int) 0 ;
19731 wxNcPaintEvent *result;
19732 PyObject * obj0 = 0 ;
19733 char *kwnames[] = {
19734 (char *) "winid", NULL
19735 };
19736
19737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19738 if (obj0) {
19739 {
19740 arg1 = (int)(SWIG_As_int(obj0));
19741 if (SWIG_arg_fail(1)) SWIG_fail;
19742 }
19743 }
19744 {
19745 PyThreadState* __tstate = wxPyBeginAllowThreads();
19746 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19747
19748 wxPyEndAllowThreads(__tstate);
19749 if (PyErr_Occurred()) SWIG_fail;
19750 }
19751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19752 return resultobj;
19753 fail:
19754 return NULL;
19755 }
19756
19757
19758 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19759 PyObject *obj;
19760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19761 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19762 Py_INCREF(obj);
19763 return Py_BuildValue((char *)"");
19764 }
19765 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19766 PyObject *resultobj;
19767 int arg1 = (int) 0 ;
19768 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19769 wxEraseEvent *result;
19770 PyObject * obj0 = 0 ;
19771 PyObject * obj1 = 0 ;
19772 char *kwnames[] = {
19773 (char *) "Id",(char *) "dc", NULL
19774 };
19775
19776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19777 if (obj0) {
19778 {
19779 arg1 = (int)(SWIG_As_int(obj0));
19780 if (SWIG_arg_fail(1)) SWIG_fail;
19781 }
19782 }
19783 if (obj1) {
19784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19785 if (SWIG_arg_fail(2)) SWIG_fail;
19786 }
19787 {
19788 PyThreadState* __tstate = wxPyBeginAllowThreads();
19789 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19790
19791 wxPyEndAllowThreads(__tstate);
19792 if (PyErr_Occurred()) SWIG_fail;
19793 }
19794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19795 return resultobj;
19796 fail:
19797 return NULL;
19798 }
19799
19800
19801 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19802 PyObject *resultobj;
19803 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19804 wxDC *result;
19805 PyObject * obj0 = 0 ;
19806 char *kwnames[] = {
19807 (char *) "self", NULL
19808 };
19809
19810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19812 if (SWIG_arg_fail(1)) SWIG_fail;
19813 {
19814 PyThreadState* __tstate = wxPyBeginAllowThreads();
19815 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19816
19817 wxPyEndAllowThreads(__tstate);
19818 if (PyErr_Occurred()) SWIG_fail;
19819 }
19820 {
19821 resultobj = wxPyMake_wxObject(result, 0);
19822 }
19823 return resultobj;
19824 fail:
19825 return NULL;
19826 }
19827
19828
19829 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19830 PyObject *obj;
19831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19832 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19833 Py_INCREF(obj);
19834 return Py_BuildValue((char *)"");
19835 }
19836 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19837 PyObject *resultobj;
19838 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19839 int arg2 = (int) 0 ;
19840 wxFocusEvent *result;
19841 PyObject * obj0 = 0 ;
19842 PyObject * obj1 = 0 ;
19843 char *kwnames[] = {
19844 (char *) "type",(char *) "winid", NULL
19845 };
19846
19847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19848 if (obj0) {
19849 {
19850 arg1 = (wxEventType)(SWIG_As_int(obj0));
19851 if (SWIG_arg_fail(1)) SWIG_fail;
19852 }
19853 }
19854 if (obj1) {
19855 {
19856 arg2 = (int)(SWIG_As_int(obj1));
19857 if (SWIG_arg_fail(2)) SWIG_fail;
19858 }
19859 }
19860 {
19861 PyThreadState* __tstate = wxPyBeginAllowThreads();
19862 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19863
19864 wxPyEndAllowThreads(__tstate);
19865 if (PyErr_Occurred()) SWIG_fail;
19866 }
19867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19868 return resultobj;
19869 fail:
19870 return NULL;
19871 }
19872
19873
19874 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19875 PyObject *resultobj;
19876 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19877 wxWindow *result;
19878 PyObject * obj0 = 0 ;
19879 char *kwnames[] = {
19880 (char *) "self", NULL
19881 };
19882
19883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19885 if (SWIG_arg_fail(1)) SWIG_fail;
19886 {
19887 PyThreadState* __tstate = wxPyBeginAllowThreads();
19888 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19889
19890 wxPyEndAllowThreads(__tstate);
19891 if (PyErr_Occurred()) SWIG_fail;
19892 }
19893 {
19894 resultobj = wxPyMake_wxObject(result, 0);
19895 }
19896 return resultobj;
19897 fail:
19898 return NULL;
19899 }
19900
19901
19902 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19903 PyObject *resultobj;
19904 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19905 wxWindow *arg2 = (wxWindow *) 0 ;
19906 PyObject * obj0 = 0 ;
19907 PyObject * obj1 = 0 ;
19908 char *kwnames[] = {
19909 (char *) "self",(char *) "win", NULL
19910 };
19911
19912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19914 if (SWIG_arg_fail(1)) SWIG_fail;
19915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19916 if (SWIG_arg_fail(2)) SWIG_fail;
19917 {
19918 PyThreadState* __tstate = wxPyBeginAllowThreads();
19919 (arg1)->SetWindow(arg2);
19920
19921 wxPyEndAllowThreads(__tstate);
19922 if (PyErr_Occurred()) SWIG_fail;
19923 }
19924 Py_INCREF(Py_None); resultobj = Py_None;
19925 return resultobj;
19926 fail:
19927 return NULL;
19928 }
19929
19930
19931 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19932 PyObject *obj;
19933 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19934 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19935 Py_INCREF(obj);
19936 return Py_BuildValue((char *)"");
19937 }
19938 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19939 PyObject *resultobj;
19940 wxWindow *arg1 = (wxWindow *) NULL ;
19941 wxChildFocusEvent *result;
19942 PyObject * obj0 = 0 ;
19943 char *kwnames[] = {
19944 (char *) "win", NULL
19945 };
19946
19947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19948 if (obj0) {
19949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19950 if (SWIG_arg_fail(1)) SWIG_fail;
19951 }
19952 {
19953 PyThreadState* __tstate = wxPyBeginAllowThreads();
19954 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19955
19956 wxPyEndAllowThreads(__tstate);
19957 if (PyErr_Occurred()) SWIG_fail;
19958 }
19959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19960 return resultobj;
19961 fail:
19962 return NULL;
19963 }
19964
19965
19966 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19967 PyObject *resultobj;
19968 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19969 wxWindow *result;
19970 PyObject * obj0 = 0 ;
19971 char *kwnames[] = {
19972 (char *) "self", NULL
19973 };
19974
19975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19977 if (SWIG_arg_fail(1)) SWIG_fail;
19978 {
19979 PyThreadState* __tstate = wxPyBeginAllowThreads();
19980 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19981
19982 wxPyEndAllowThreads(__tstate);
19983 if (PyErr_Occurred()) SWIG_fail;
19984 }
19985 {
19986 resultobj = wxPyMake_wxObject(result, 0);
19987 }
19988 return resultobj;
19989 fail:
19990 return NULL;
19991 }
19992
19993
19994 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19995 PyObject *obj;
19996 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19997 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19998 Py_INCREF(obj);
19999 return Py_BuildValue((char *)"");
20000 }
20001 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20002 PyObject *resultobj;
20003 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20004 bool arg2 = (bool) true ;
20005 int arg3 = (int) 0 ;
20006 wxActivateEvent *result;
20007 PyObject * obj0 = 0 ;
20008 PyObject * obj1 = 0 ;
20009 PyObject * obj2 = 0 ;
20010 char *kwnames[] = {
20011 (char *) "type",(char *) "active",(char *) "Id", NULL
20012 };
20013
20014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20015 if (obj0) {
20016 {
20017 arg1 = (wxEventType)(SWIG_As_int(obj0));
20018 if (SWIG_arg_fail(1)) SWIG_fail;
20019 }
20020 }
20021 if (obj1) {
20022 {
20023 arg2 = (bool)(SWIG_As_bool(obj1));
20024 if (SWIG_arg_fail(2)) SWIG_fail;
20025 }
20026 }
20027 if (obj2) {
20028 {
20029 arg3 = (int)(SWIG_As_int(obj2));
20030 if (SWIG_arg_fail(3)) SWIG_fail;
20031 }
20032 }
20033 {
20034 PyThreadState* __tstate = wxPyBeginAllowThreads();
20035 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20036
20037 wxPyEndAllowThreads(__tstate);
20038 if (PyErr_Occurred()) SWIG_fail;
20039 }
20040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20041 return resultobj;
20042 fail:
20043 return NULL;
20044 }
20045
20046
20047 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20048 PyObject *resultobj;
20049 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20050 bool result;
20051 PyObject * obj0 = 0 ;
20052 char *kwnames[] = {
20053 (char *) "self", NULL
20054 };
20055
20056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20058 if (SWIG_arg_fail(1)) SWIG_fail;
20059 {
20060 PyThreadState* __tstate = wxPyBeginAllowThreads();
20061 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20062
20063 wxPyEndAllowThreads(__tstate);
20064 if (PyErr_Occurred()) SWIG_fail;
20065 }
20066 {
20067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20068 }
20069 return resultobj;
20070 fail:
20071 return NULL;
20072 }
20073
20074
20075 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20076 PyObject *obj;
20077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20078 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20079 Py_INCREF(obj);
20080 return Py_BuildValue((char *)"");
20081 }
20082 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20083 PyObject *resultobj;
20084 int arg1 = (int) 0 ;
20085 wxInitDialogEvent *result;
20086 PyObject * obj0 = 0 ;
20087 char *kwnames[] = {
20088 (char *) "Id", NULL
20089 };
20090
20091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20092 if (obj0) {
20093 {
20094 arg1 = (int)(SWIG_As_int(obj0));
20095 if (SWIG_arg_fail(1)) SWIG_fail;
20096 }
20097 }
20098 {
20099 PyThreadState* __tstate = wxPyBeginAllowThreads();
20100 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20101
20102 wxPyEndAllowThreads(__tstate);
20103 if (PyErr_Occurred()) SWIG_fail;
20104 }
20105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20106 return resultobj;
20107 fail:
20108 return NULL;
20109 }
20110
20111
20112 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20113 PyObject *obj;
20114 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20115 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20116 Py_INCREF(obj);
20117 return Py_BuildValue((char *)"");
20118 }
20119 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20120 PyObject *resultobj;
20121 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20122 int arg2 = (int) 0 ;
20123 wxMenu *arg3 = (wxMenu *) NULL ;
20124 wxMenuEvent *result;
20125 PyObject * obj0 = 0 ;
20126 PyObject * obj1 = 0 ;
20127 PyObject * obj2 = 0 ;
20128 char *kwnames[] = {
20129 (char *) "type",(char *) "winid",(char *) "menu", NULL
20130 };
20131
20132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20133 if (obj0) {
20134 {
20135 arg1 = (wxEventType)(SWIG_As_int(obj0));
20136 if (SWIG_arg_fail(1)) SWIG_fail;
20137 }
20138 }
20139 if (obj1) {
20140 {
20141 arg2 = (int)(SWIG_As_int(obj1));
20142 if (SWIG_arg_fail(2)) SWIG_fail;
20143 }
20144 }
20145 if (obj2) {
20146 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20147 if (SWIG_arg_fail(3)) SWIG_fail;
20148 }
20149 {
20150 PyThreadState* __tstate = wxPyBeginAllowThreads();
20151 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20152
20153 wxPyEndAllowThreads(__tstate);
20154 if (PyErr_Occurred()) SWIG_fail;
20155 }
20156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20157 return resultobj;
20158 fail:
20159 return NULL;
20160 }
20161
20162
20163 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20164 PyObject *resultobj;
20165 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20166 int result;
20167 PyObject * obj0 = 0 ;
20168 char *kwnames[] = {
20169 (char *) "self", NULL
20170 };
20171
20172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20174 if (SWIG_arg_fail(1)) SWIG_fail;
20175 {
20176 PyThreadState* __tstate = wxPyBeginAllowThreads();
20177 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20178
20179 wxPyEndAllowThreads(__tstate);
20180 if (PyErr_Occurred()) SWIG_fail;
20181 }
20182 {
20183 resultobj = SWIG_From_int((int)(result));
20184 }
20185 return resultobj;
20186 fail:
20187 return NULL;
20188 }
20189
20190
20191 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20192 PyObject *resultobj;
20193 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20194 bool result;
20195 PyObject * obj0 = 0 ;
20196 char *kwnames[] = {
20197 (char *) "self", NULL
20198 };
20199
20200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20202 if (SWIG_arg_fail(1)) SWIG_fail;
20203 {
20204 PyThreadState* __tstate = wxPyBeginAllowThreads();
20205 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20206
20207 wxPyEndAllowThreads(__tstate);
20208 if (PyErr_Occurred()) SWIG_fail;
20209 }
20210 {
20211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20212 }
20213 return resultobj;
20214 fail:
20215 return NULL;
20216 }
20217
20218
20219 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20220 PyObject *resultobj;
20221 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20222 wxMenu *result;
20223 PyObject * obj0 = 0 ;
20224 char *kwnames[] = {
20225 (char *) "self", NULL
20226 };
20227
20228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20230 if (SWIG_arg_fail(1)) SWIG_fail;
20231 {
20232 PyThreadState* __tstate = wxPyBeginAllowThreads();
20233 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20234
20235 wxPyEndAllowThreads(__tstate);
20236 if (PyErr_Occurred()) SWIG_fail;
20237 }
20238 {
20239 resultobj = wxPyMake_wxObject(result, 0);
20240 }
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20248 PyObject *obj;
20249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20250 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20251 Py_INCREF(obj);
20252 return Py_BuildValue((char *)"");
20253 }
20254 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20255 PyObject *resultobj;
20256 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20257 int arg2 = (int) 0 ;
20258 wxCloseEvent *result;
20259 PyObject * obj0 = 0 ;
20260 PyObject * obj1 = 0 ;
20261 char *kwnames[] = {
20262 (char *) "type",(char *) "winid", NULL
20263 };
20264
20265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20266 if (obj0) {
20267 {
20268 arg1 = (wxEventType)(SWIG_As_int(obj0));
20269 if (SWIG_arg_fail(1)) SWIG_fail;
20270 }
20271 }
20272 if (obj1) {
20273 {
20274 arg2 = (int)(SWIG_As_int(obj1));
20275 if (SWIG_arg_fail(2)) SWIG_fail;
20276 }
20277 }
20278 {
20279 PyThreadState* __tstate = wxPyBeginAllowThreads();
20280 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20281
20282 wxPyEndAllowThreads(__tstate);
20283 if (PyErr_Occurred()) SWIG_fail;
20284 }
20285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20286 return resultobj;
20287 fail:
20288 return NULL;
20289 }
20290
20291
20292 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20293 PyObject *resultobj;
20294 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20295 bool arg2 ;
20296 PyObject * obj0 = 0 ;
20297 PyObject * obj1 = 0 ;
20298 char *kwnames[] = {
20299 (char *) "self",(char *) "logOff", NULL
20300 };
20301
20302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20304 if (SWIG_arg_fail(1)) SWIG_fail;
20305 {
20306 arg2 = (bool)(SWIG_As_bool(obj1));
20307 if (SWIG_arg_fail(2)) SWIG_fail;
20308 }
20309 {
20310 PyThreadState* __tstate = wxPyBeginAllowThreads();
20311 (arg1)->SetLoggingOff(arg2);
20312
20313 wxPyEndAllowThreads(__tstate);
20314 if (PyErr_Occurred()) SWIG_fail;
20315 }
20316 Py_INCREF(Py_None); resultobj = Py_None;
20317 return resultobj;
20318 fail:
20319 return NULL;
20320 }
20321
20322
20323 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20324 PyObject *resultobj;
20325 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20326 bool result;
20327 PyObject * obj0 = 0 ;
20328 char *kwnames[] = {
20329 (char *) "self", NULL
20330 };
20331
20332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20334 if (SWIG_arg_fail(1)) SWIG_fail;
20335 {
20336 PyThreadState* __tstate = wxPyBeginAllowThreads();
20337 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20338
20339 wxPyEndAllowThreads(__tstate);
20340 if (PyErr_Occurred()) SWIG_fail;
20341 }
20342 {
20343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20344 }
20345 return resultobj;
20346 fail:
20347 return NULL;
20348 }
20349
20350
20351 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20352 PyObject *resultobj;
20353 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20354 bool arg2 = (bool) true ;
20355 PyObject * obj0 = 0 ;
20356 PyObject * obj1 = 0 ;
20357 char *kwnames[] = {
20358 (char *) "self",(char *) "veto", NULL
20359 };
20360
20361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20363 if (SWIG_arg_fail(1)) SWIG_fail;
20364 if (obj1) {
20365 {
20366 arg2 = (bool)(SWIG_As_bool(obj1));
20367 if (SWIG_arg_fail(2)) SWIG_fail;
20368 }
20369 }
20370 {
20371 PyThreadState* __tstate = wxPyBeginAllowThreads();
20372 (arg1)->Veto(arg2);
20373
20374 wxPyEndAllowThreads(__tstate);
20375 if (PyErr_Occurred()) SWIG_fail;
20376 }
20377 Py_INCREF(Py_None); resultobj = Py_None;
20378 return resultobj;
20379 fail:
20380 return NULL;
20381 }
20382
20383
20384 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20385 PyObject *resultobj;
20386 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20387 bool arg2 ;
20388 PyObject * obj0 = 0 ;
20389 PyObject * obj1 = 0 ;
20390 char *kwnames[] = {
20391 (char *) "self",(char *) "canVeto", NULL
20392 };
20393
20394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20396 if (SWIG_arg_fail(1)) SWIG_fail;
20397 {
20398 arg2 = (bool)(SWIG_As_bool(obj1));
20399 if (SWIG_arg_fail(2)) SWIG_fail;
20400 }
20401 {
20402 PyThreadState* __tstate = wxPyBeginAllowThreads();
20403 (arg1)->SetCanVeto(arg2);
20404
20405 wxPyEndAllowThreads(__tstate);
20406 if (PyErr_Occurred()) SWIG_fail;
20407 }
20408 Py_INCREF(Py_None); resultobj = Py_None;
20409 return resultobj;
20410 fail:
20411 return NULL;
20412 }
20413
20414
20415 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20416 PyObject *resultobj;
20417 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20418 bool result;
20419 PyObject * obj0 = 0 ;
20420 char *kwnames[] = {
20421 (char *) "self", NULL
20422 };
20423
20424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20426 if (SWIG_arg_fail(1)) SWIG_fail;
20427 {
20428 PyThreadState* __tstate = wxPyBeginAllowThreads();
20429 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20430
20431 wxPyEndAllowThreads(__tstate);
20432 if (PyErr_Occurred()) SWIG_fail;
20433 }
20434 {
20435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20436 }
20437 return resultobj;
20438 fail:
20439 return NULL;
20440 }
20441
20442
20443 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20444 PyObject *resultobj;
20445 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20446 bool result;
20447 PyObject * obj0 = 0 ;
20448 char *kwnames[] = {
20449 (char *) "self", NULL
20450 };
20451
20452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20454 if (SWIG_arg_fail(1)) SWIG_fail;
20455 {
20456 PyThreadState* __tstate = wxPyBeginAllowThreads();
20457 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20458
20459 wxPyEndAllowThreads(__tstate);
20460 if (PyErr_Occurred()) SWIG_fail;
20461 }
20462 {
20463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20464 }
20465 return resultobj;
20466 fail:
20467 return NULL;
20468 }
20469
20470
20471 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20472 PyObject *obj;
20473 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20474 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20475 Py_INCREF(obj);
20476 return Py_BuildValue((char *)"");
20477 }
20478 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20479 PyObject *resultobj;
20480 int arg1 = (int) 0 ;
20481 bool arg2 = (bool) false ;
20482 wxShowEvent *result;
20483 PyObject * obj0 = 0 ;
20484 PyObject * obj1 = 0 ;
20485 char *kwnames[] = {
20486 (char *) "winid",(char *) "show", NULL
20487 };
20488
20489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20490 if (obj0) {
20491 {
20492 arg1 = (int)(SWIG_As_int(obj0));
20493 if (SWIG_arg_fail(1)) SWIG_fail;
20494 }
20495 }
20496 if (obj1) {
20497 {
20498 arg2 = (bool)(SWIG_As_bool(obj1));
20499 if (SWIG_arg_fail(2)) SWIG_fail;
20500 }
20501 }
20502 {
20503 PyThreadState* __tstate = wxPyBeginAllowThreads();
20504 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20505
20506 wxPyEndAllowThreads(__tstate);
20507 if (PyErr_Occurred()) SWIG_fail;
20508 }
20509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20510 return resultobj;
20511 fail:
20512 return NULL;
20513 }
20514
20515
20516 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20517 PyObject *resultobj;
20518 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20519 bool arg2 ;
20520 PyObject * obj0 = 0 ;
20521 PyObject * obj1 = 0 ;
20522 char *kwnames[] = {
20523 (char *) "self",(char *) "show", NULL
20524 };
20525
20526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20528 if (SWIG_arg_fail(1)) SWIG_fail;
20529 {
20530 arg2 = (bool)(SWIG_As_bool(obj1));
20531 if (SWIG_arg_fail(2)) SWIG_fail;
20532 }
20533 {
20534 PyThreadState* __tstate = wxPyBeginAllowThreads();
20535 (arg1)->SetShow(arg2);
20536
20537 wxPyEndAllowThreads(__tstate);
20538 if (PyErr_Occurred()) SWIG_fail;
20539 }
20540 Py_INCREF(Py_None); resultobj = Py_None;
20541 return resultobj;
20542 fail:
20543 return NULL;
20544 }
20545
20546
20547 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20548 PyObject *resultobj;
20549 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20550 bool result;
20551 PyObject * obj0 = 0 ;
20552 char *kwnames[] = {
20553 (char *) "self", NULL
20554 };
20555
20556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20558 if (SWIG_arg_fail(1)) SWIG_fail;
20559 {
20560 PyThreadState* __tstate = wxPyBeginAllowThreads();
20561 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20562
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 {
20567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20568 }
20569 return resultobj;
20570 fail:
20571 return NULL;
20572 }
20573
20574
20575 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20576 PyObject *obj;
20577 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20578 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20579 Py_INCREF(obj);
20580 return Py_BuildValue((char *)"");
20581 }
20582 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20583 PyObject *resultobj;
20584 int arg1 = (int) 0 ;
20585 bool arg2 = (bool) true ;
20586 wxIconizeEvent *result;
20587 PyObject * obj0 = 0 ;
20588 PyObject * obj1 = 0 ;
20589 char *kwnames[] = {
20590 (char *) "id",(char *) "iconized", NULL
20591 };
20592
20593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20594 if (obj0) {
20595 {
20596 arg1 = (int)(SWIG_As_int(obj0));
20597 if (SWIG_arg_fail(1)) SWIG_fail;
20598 }
20599 }
20600 if (obj1) {
20601 {
20602 arg2 = (bool)(SWIG_As_bool(obj1));
20603 if (SWIG_arg_fail(2)) SWIG_fail;
20604 }
20605 }
20606 {
20607 PyThreadState* __tstate = wxPyBeginAllowThreads();
20608 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20609
20610 wxPyEndAllowThreads(__tstate);
20611 if (PyErr_Occurred()) SWIG_fail;
20612 }
20613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20614 return resultobj;
20615 fail:
20616 return NULL;
20617 }
20618
20619
20620 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20621 PyObject *resultobj;
20622 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20623 bool result;
20624 PyObject * obj0 = 0 ;
20625 char *kwnames[] = {
20626 (char *) "self", NULL
20627 };
20628
20629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20631 if (SWIG_arg_fail(1)) SWIG_fail;
20632 {
20633 PyThreadState* __tstate = wxPyBeginAllowThreads();
20634 result = (bool)(arg1)->Iconized();
20635
20636 wxPyEndAllowThreads(__tstate);
20637 if (PyErr_Occurred()) SWIG_fail;
20638 }
20639 {
20640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20641 }
20642 return resultobj;
20643 fail:
20644 return NULL;
20645 }
20646
20647
20648 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20649 PyObject *obj;
20650 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20651 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20652 Py_INCREF(obj);
20653 return Py_BuildValue((char *)"");
20654 }
20655 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20656 PyObject *resultobj;
20657 int arg1 = (int) 0 ;
20658 wxMaximizeEvent *result;
20659 PyObject * obj0 = 0 ;
20660 char *kwnames[] = {
20661 (char *) "id", NULL
20662 };
20663
20664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20665 if (obj0) {
20666 {
20667 arg1 = (int)(SWIG_As_int(obj0));
20668 if (SWIG_arg_fail(1)) SWIG_fail;
20669 }
20670 }
20671 {
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20674
20675 wxPyEndAllowThreads(__tstate);
20676 if (PyErr_Occurred()) SWIG_fail;
20677 }
20678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20679 return resultobj;
20680 fail:
20681 return NULL;
20682 }
20683
20684
20685 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20686 PyObject *obj;
20687 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20688 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20689 Py_INCREF(obj);
20690 return Py_BuildValue((char *)"");
20691 }
20692 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20693 PyObject *resultobj;
20694 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20695 wxPoint result;
20696 PyObject * obj0 = 0 ;
20697 char *kwnames[] = {
20698 (char *) "self", NULL
20699 };
20700
20701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20703 if (SWIG_arg_fail(1)) SWIG_fail;
20704 {
20705 PyThreadState* __tstate = wxPyBeginAllowThreads();
20706 result = (arg1)->GetPosition();
20707
20708 wxPyEndAllowThreads(__tstate);
20709 if (PyErr_Occurred()) SWIG_fail;
20710 }
20711 {
20712 wxPoint * resultptr;
20713 resultptr = new wxPoint((wxPoint &)(result));
20714 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20715 }
20716 return resultobj;
20717 fail:
20718 return NULL;
20719 }
20720
20721
20722 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20723 PyObject *resultobj;
20724 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20725 int result;
20726 PyObject * obj0 = 0 ;
20727 char *kwnames[] = {
20728 (char *) "self", NULL
20729 };
20730
20731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20733 if (SWIG_arg_fail(1)) SWIG_fail;
20734 {
20735 PyThreadState* __tstate = wxPyBeginAllowThreads();
20736 result = (int)(arg1)->GetNumberOfFiles();
20737
20738 wxPyEndAllowThreads(__tstate);
20739 if (PyErr_Occurred()) SWIG_fail;
20740 }
20741 {
20742 resultobj = SWIG_From_int((int)(result));
20743 }
20744 return resultobj;
20745 fail:
20746 return NULL;
20747 }
20748
20749
20750 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20751 PyObject *resultobj;
20752 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20753 PyObject *result;
20754 PyObject * obj0 = 0 ;
20755 char *kwnames[] = {
20756 (char *) "self", NULL
20757 };
20758
20759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20761 if (SWIG_arg_fail(1)) SWIG_fail;
20762 {
20763 PyThreadState* __tstate = wxPyBeginAllowThreads();
20764 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20765
20766 wxPyEndAllowThreads(__tstate);
20767 if (PyErr_Occurred()) SWIG_fail;
20768 }
20769 resultobj = result;
20770 return resultobj;
20771 fail:
20772 return NULL;
20773 }
20774
20775
20776 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20777 PyObject *obj;
20778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20779 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20780 Py_INCREF(obj);
20781 return Py_BuildValue((char *)"");
20782 }
20783 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20784 PyObject *resultobj;
20785 int arg1 = (int) 0 ;
20786 wxUpdateUIEvent *result;
20787 PyObject * obj0 = 0 ;
20788 char *kwnames[] = {
20789 (char *) "commandId", NULL
20790 };
20791
20792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",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 = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20802
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20814 PyObject *resultobj;
20815 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20816 bool result;
20817 PyObject * obj0 = 0 ;
20818 char *kwnames[] = {
20819 (char *) "self", NULL
20820 };
20821
20822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20824 if (SWIG_arg_fail(1)) SWIG_fail;
20825 {
20826 PyThreadState* __tstate = wxPyBeginAllowThreads();
20827 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20828
20829 wxPyEndAllowThreads(__tstate);
20830 if (PyErr_Occurred()) SWIG_fail;
20831 }
20832 {
20833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20834 }
20835 return resultobj;
20836 fail:
20837 return NULL;
20838 }
20839
20840
20841 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20842 PyObject *resultobj;
20843 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20844 bool result;
20845 PyObject * obj0 = 0 ;
20846 char *kwnames[] = {
20847 (char *) "self", NULL
20848 };
20849
20850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20852 if (SWIG_arg_fail(1)) SWIG_fail;
20853 {
20854 PyThreadState* __tstate = wxPyBeginAllowThreads();
20855 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20856
20857 wxPyEndAllowThreads(__tstate);
20858 if (PyErr_Occurred()) SWIG_fail;
20859 }
20860 {
20861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20862 }
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20870 PyObject *resultobj;
20871 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20872 wxString result;
20873 PyObject * obj0 = 0 ;
20874 char *kwnames[] = {
20875 (char *) "self", NULL
20876 };
20877
20878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20880 if (SWIG_arg_fail(1)) SWIG_fail;
20881 {
20882 PyThreadState* __tstate = wxPyBeginAllowThreads();
20883 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20884
20885 wxPyEndAllowThreads(__tstate);
20886 if (PyErr_Occurred()) SWIG_fail;
20887 }
20888 {
20889 #if wxUSE_UNICODE
20890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20891 #else
20892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20893 #endif
20894 }
20895 return resultobj;
20896 fail:
20897 return NULL;
20898 }
20899
20900
20901 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20902 PyObject *resultobj;
20903 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20904 bool result;
20905 PyObject * obj0 = 0 ;
20906 char *kwnames[] = {
20907 (char *) "self", NULL
20908 };
20909
20910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20912 if (SWIG_arg_fail(1)) SWIG_fail;
20913 {
20914 PyThreadState* __tstate = wxPyBeginAllowThreads();
20915 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20916
20917 wxPyEndAllowThreads(__tstate);
20918 if (PyErr_Occurred()) SWIG_fail;
20919 }
20920 {
20921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20922 }
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20930 PyObject *resultobj;
20931 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20932 bool result;
20933 PyObject * obj0 = 0 ;
20934 char *kwnames[] = {
20935 (char *) "self", NULL
20936 };
20937
20938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20940 if (SWIG_arg_fail(1)) SWIG_fail;
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20944
20945 wxPyEndAllowThreads(__tstate);
20946 if (PyErr_Occurred()) SWIG_fail;
20947 }
20948 {
20949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20950 }
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20958 PyObject *resultobj;
20959 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20960 bool result;
20961 PyObject * obj0 = 0 ;
20962 char *kwnames[] = {
20963 (char *) "self", NULL
20964 };
20965
20966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20968 if (SWIG_arg_fail(1)) SWIG_fail;
20969 {
20970 PyThreadState* __tstate = wxPyBeginAllowThreads();
20971 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20972
20973 wxPyEndAllowThreads(__tstate);
20974 if (PyErr_Occurred()) SWIG_fail;
20975 }
20976 {
20977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20978 }
20979 return resultobj;
20980 fail:
20981 return NULL;
20982 }
20983
20984
20985 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20986 PyObject *resultobj;
20987 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20988 bool arg2 ;
20989 PyObject * obj0 = 0 ;
20990 PyObject * obj1 = 0 ;
20991 char *kwnames[] = {
20992 (char *) "self",(char *) "check", NULL
20993 };
20994
20995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20997 if (SWIG_arg_fail(1)) SWIG_fail;
20998 {
20999 arg2 = (bool)(SWIG_As_bool(obj1));
21000 if (SWIG_arg_fail(2)) SWIG_fail;
21001 }
21002 {
21003 PyThreadState* __tstate = wxPyBeginAllowThreads();
21004 (arg1)->Check(arg2);
21005
21006 wxPyEndAllowThreads(__tstate);
21007 if (PyErr_Occurred()) SWIG_fail;
21008 }
21009 Py_INCREF(Py_None); resultobj = Py_None;
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21017 PyObject *resultobj;
21018 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21019 bool arg2 ;
21020 PyObject * obj0 = 0 ;
21021 PyObject * obj1 = 0 ;
21022 char *kwnames[] = {
21023 (char *) "self",(char *) "enable", NULL
21024 };
21025
21026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21028 if (SWIG_arg_fail(1)) SWIG_fail;
21029 {
21030 arg2 = (bool)(SWIG_As_bool(obj1));
21031 if (SWIG_arg_fail(2)) SWIG_fail;
21032 }
21033 {
21034 PyThreadState* __tstate = wxPyBeginAllowThreads();
21035 (arg1)->Enable(arg2);
21036
21037 wxPyEndAllowThreads(__tstate);
21038 if (PyErr_Occurred()) SWIG_fail;
21039 }
21040 Py_INCREF(Py_None); resultobj = Py_None;
21041 return resultobj;
21042 fail:
21043 return NULL;
21044 }
21045
21046
21047 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21048 PyObject *resultobj;
21049 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21050 wxString *arg2 = 0 ;
21051 bool temp2 = false ;
21052 PyObject * obj0 = 0 ;
21053 PyObject * obj1 = 0 ;
21054 char *kwnames[] = {
21055 (char *) "self",(char *) "text", NULL
21056 };
21057
21058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21060 if (SWIG_arg_fail(1)) SWIG_fail;
21061 {
21062 arg2 = wxString_in_helper(obj1);
21063 if (arg2 == NULL) SWIG_fail;
21064 temp2 = true;
21065 }
21066 {
21067 PyThreadState* __tstate = wxPyBeginAllowThreads();
21068 (arg1)->SetText((wxString const &)*arg2);
21069
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 Py_INCREF(Py_None); resultobj = Py_None;
21074 {
21075 if (temp2)
21076 delete arg2;
21077 }
21078 return resultobj;
21079 fail:
21080 {
21081 if (temp2)
21082 delete arg2;
21083 }
21084 return NULL;
21085 }
21086
21087
21088 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21089 PyObject *resultobj;
21090 long arg1 ;
21091 PyObject * obj0 = 0 ;
21092 char *kwnames[] = {
21093 (char *) "updateInterval", NULL
21094 };
21095
21096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21097 {
21098 arg1 = (long)(SWIG_As_long(obj0));
21099 if (SWIG_arg_fail(1)) SWIG_fail;
21100 }
21101 {
21102 PyThreadState* __tstate = wxPyBeginAllowThreads();
21103 wxUpdateUIEvent::SetUpdateInterval(arg1);
21104
21105 wxPyEndAllowThreads(__tstate);
21106 if (PyErr_Occurred()) SWIG_fail;
21107 }
21108 Py_INCREF(Py_None); resultobj = Py_None;
21109 return resultobj;
21110 fail:
21111 return NULL;
21112 }
21113
21114
21115 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21116 PyObject *resultobj;
21117 long result;
21118 char *kwnames[] = {
21119 NULL
21120 };
21121
21122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21126
21127 wxPyEndAllowThreads(__tstate);
21128 if (PyErr_Occurred()) SWIG_fail;
21129 }
21130 {
21131 resultobj = SWIG_From_long((long)(result));
21132 }
21133 return resultobj;
21134 fail:
21135 return NULL;
21136 }
21137
21138
21139 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21140 PyObject *resultobj;
21141 wxWindow *arg1 = (wxWindow *) 0 ;
21142 bool result;
21143 PyObject * obj0 = 0 ;
21144 char *kwnames[] = {
21145 (char *) "win", NULL
21146 };
21147
21148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21150 if (SWIG_arg_fail(1)) SWIG_fail;
21151 {
21152 PyThreadState* __tstate = wxPyBeginAllowThreads();
21153 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21154
21155 wxPyEndAllowThreads(__tstate);
21156 if (PyErr_Occurred()) SWIG_fail;
21157 }
21158 {
21159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21160 }
21161 return resultobj;
21162 fail:
21163 return NULL;
21164 }
21165
21166
21167 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21168 PyObject *resultobj;
21169 char *kwnames[] = {
21170 NULL
21171 };
21172
21173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21174 {
21175 PyThreadState* __tstate = wxPyBeginAllowThreads();
21176 wxUpdateUIEvent::ResetUpdateTime();
21177
21178 wxPyEndAllowThreads(__tstate);
21179 if (PyErr_Occurred()) SWIG_fail;
21180 }
21181 Py_INCREF(Py_None); resultobj = Py_None;
21182 return resultobj;
21183 fail:
21184 return NULL;
21185 }
21186
21187
21188 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21189 PyObject *resultobj;
21190 wxUpdateUIMode arg1 ;
21191 PyObject * obj0 = 0 ;
21192 char *kwnames[] = {
21193 (char *) "mode", NULL
21194 };
21195
21196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21197 {
21198 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21199 if (SWIG_arg_fail(1)) SWIG_fail;
21200 }
21201 {
21202 PyThreadState* __tstate = wxPyBeginAllowThreads();
21203 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21204
21205 wxPyEndAllowThreads(__tstate);
21206 if (PyErr_Occurred()) SWIG_fail;
21207 }
21208 Py_INCREF(Py_None); resultobj = Py_None;
21209 return resultobj;
21210 fail:
21211 return NULL;
21212 }
21213
21214
21215 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21216 PyObject *resultobj;
21217 wxUpdateUIMode result;
21218 char *kwnames[] = {
21219 NULL
21220 };
21221
21222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21223 {
21224 PyThreadState* __tstate = wxPyBeginAllowThreads();
21225 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21226
21227 wxPyEndAllowThreads(__tstate);
21228 if (PyErr_Occurred()) SWIG_fail;
21229 }
21230 resultobj = SWIG_From_int((result));
21231 return resultobj;
21232 fail:
21233 return NULL;
21234 }
21235
21236
21237 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21238 PyObject *obj;
21239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21240 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21241 Py_INCREF(obj);
21242 return Py_BuildValue((char *)"");
21243 }
21244 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21245 PyObject *resultobj;
21246 wxSysColourChangedEvent *result;
21247 char *kwnames[] = {
21248 NULL
21249 };
21250
21251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21252 {
21253 PyThreadState* __tstate = wxPyBeginAllowThreads();
21254 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21255
21256 wxPyEndAllowThreads(__tstate);
21257 if (PyErr_Occurred()) SWIG_fail;
21258 }
21259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21260 return resultobj;
21261 fail:
21262 return NULL;
21263 }
21264
21265
21266 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21267 PyObject *obj;
21268 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21269 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21270 Py_INCREF(obj);
21271 return Py_BuildValue((char *)"");
21272 }
21273 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21274 PyObject *resultobj;
21275 int arg1 = (int) 0 ;
21276 wxWindow *arg2 = (wxWindow *) NULL ;
21277 wxMouseCaptureChangedEvent *result;
21278 PyObject * obj0 = 0 ;
21279 PyObject * obj1 = 0 ;
21280 char *kwnames[] = {
21281 (char *) "winid",(char *) "gainedCapture", NULL
21282 };
21283
21284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21285 if (obj0) {
21286 {
21287 arg1 = (int)(SWIG_As_int(obj0));
21288 if (SWIG_arg_fail(1)) SWIG_fail;
21289 }
21290 }
21291 if (obj1) {
21292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21293 if (SWIG_arg_fail(2)) SWIG_fail;
21294 }
21295 {
21296 PyThreadState* __tstate = wxPyBeginAllowThreads();
21297 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21298
21299 wxPyEndAllowThreads(__tstate);
21300 if (PyErr_Occurred()) SWIG_fail;
21301 }
21302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21303 return resultobj;
21304 fail:
21305 return NULL;
21306 }
21307
21308
21309 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21310 PyObject *resultobj;
21311 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21312 wxWindow *result;
21313 PyObject * obj0 = 0 ;
21314 char *kwnames[] = {
21315 (char *) "self", NULL
21316 };
21317
21318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21320 if (SWIG_arg_fail(1)) SWIG_fail;
21321 {
21322 PyThreadState* __tstate = wxPyBeginAllowThreads();
21323 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21324
21325 wxPyEndAllowThreads(__tstate);
21326 if (PyErr_Occurred()) SWIG_fail;
21327 }
21328 {
21329 resultobj = wxPyMake_wxObject(result, 0);
21330 }
21331 return resultobj;
21332 fail:
21333 return NULL;
21334 }
21335
21336
21337 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21338 PyObject *obj;
21339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21340 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21341 Py_INCREF(obj);
21342 return Py_BuildValue((char *)"");
21343 }
21344 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21345 PyObject *resultobj;
21346 wxDisplayChangedEvent *result;
21347 char *kwnames[] = {
21348 NULL
21349 };
21350
21351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21352 {
21353 PyThreadState* __tstate = wxPyBeginAllowThreads();
21354 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21355
21356 wxPyEndAllowThreads(__tstate);
21357 if (PyErr_Occurred()) SWIG_fail;
21358 }
21359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21360 return resultobj;
21361 fail:
21362 return NULL;
21363 }
21364
21365
21366 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21367 PyObject *obj;
21368 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21369 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21370 Py_INCREF(obj);
21371 return Py_BuildValue((char *)"");
21372 }
21373 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21374 PyObject *resultobj;
21375 int arg1 = (int) 0 ;
21376 wxPaletteChangedEvent *result;
21377 PyObject * obj0 = 0 ;
21378 char *kwnames[] = {
21379 (char *) "id", NULL
21380 };
21381
21382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21383 if (obj0) {
21384 {
21385 arg1 = (int)(SWIG_As_int(obj0));
21386 if (SWIG_arg_fail(1)) SWIG_fail;
21387 }
21388 }
21389 {
21390 PyThreadState* __tstate = wxPyBeginAllowThreads();
21391 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21392
21393 wxPyEndAllowThreads(__tstate);
21394 if (PyErr_Occurred()) SWIG_fail;
21395 }
21396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21397 return resultobj;
21398 fail:
21399 return NULL;
21400 }
21401
21402
21403 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21404 PyObject *resultobj;
21405 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21406 wxWindow *arg2 = (wxWindow *) 0 ;
21407 PyObject * obj0 = 0 ;
21408 PyObject * obj1 = 0 ;
21409 char *kwnames[] = {
21410 (char *) "self",(char *) "win", NULL
21411 };
21412
21413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21415 if (SWIG_arg_fail(1)) SWIG_fail;
21416 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21417 if (SWIG_arg_fail(2)) SWIG_fail;
21418 {
21419 PyThreadState* __tstate = wxPyBeginAllowThreads();
21420 (arg1)->SetChangedWindow(arg2);
21421
21422 wxPyEndAllowThreads(__tstate);
21423 if (PyErr_Occurred()) SWIG_fail;
21424 }
21425 Py_INCREF(Py_None); resultobj = Py_None;
21426 return resultobj;
21427 fail:
21428 return NULL;
21429 }
21430
21431
21432 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21433 PyObject *resultobj;
21434 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21435 wxWindow *result;
21436 PyObject * obj0 = 0 ;
21437 char *kwnames[] = {
21438 (char *) "self", NULL
21439 };
21440
21441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21443 if (SWIG_arg_fail(1)) SWIG_fail;
21444 {
21445 PyThreadState* __tstate = wxPyBeginAllowThreads();
21446 result = (wxWindow *)(arg1)->GetChangedWindow();
21447
21448 wxPyEndAllowThreads(__tstate);
21449 if (PyErr_Occurred()) SWIG_fail;
21450 }
21451 {
21452 resultobj = wxPyMake_wxObject(result, 0);
21453 }
21454 return resultobj;
21455 fail:
21456 return NULL;
21457 }
21458
21459
21460 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21461 PyObject *obj;
21462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21463 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21464 Py_INCREF(obj);
21465 return Py_BuildValue((char *)"");
21466 }
21467 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21468 PyObject *resultobj;
21469 int arg1 = (int) 0 ;
21470 wxQueryNewPaletteEvent *result;
21471 PyObject * obj0 = 0 ;
21472 char *kwnames[] = {
21473 (char *) "winid", NULL
21474 };
21475
21476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21477 if (obj0) {
21478 {
21479 arg1 = (int)(SWIG_As_int(obj0));
21480 if (SWIG_arg_fail(1)) SWIG_fail;
21481 }
21482 }
21483 {
21484 PyThreadState* __tstate = wxPyBeginAllowThreads();
21485 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21486
21487 wxPyEndAllowThreads(__tstate);
21488 if (PyErr_Occurred()) SWIG_fail;
21489 }
21490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21491 return resultobj;
21492 fail:
21493 return NULL;
21494 }
21495
21496
21497 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21498 PyObject *resultobj;
21499 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21500 bool arg2 ;
21501 PyObject * obj0 = 0 ;
21502 PyObject * obj1 = 0 ;
21503 char *kwnames[] = {
21504 (char *) "self",(char *) "realized", NULL
21505 };
21506
21507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21509 if (SWIG_arg_fail(1)) SWIG_fail;
21510 {
21511 arg2 = (bool)(SWIG_As_bool(obj1));
21512 if (SWIG_arg_fail(2)) SWIG_fail;
21513 }
21514 {
21515 PyThreadState* __tstate = wxPyBeginAllowThreads();
21516 (arg1)->SetPaletteRealized(arg2);
21517
21518 wxPyEndAllowThreads(__tstate);
21519 if (PyErr_Occurred()) SWIG_fail;
21520 }
21521 Py_INCREF(Py_None); resultobj = Py_None;
21522 return resultobj;
21523 fail:
21524 return NULL;
21525 }
21526
21527
21528 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21529 PyObject *resultobj;
21530 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21531 bool result;
21532 PyObject * obj0 = 0 ;
21533 char *kwnames[] = {
21534 (char *) "self", NULL
21535 };
21536
21537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21539 if (SWIG_arg_fail(1)) SWIG_fail;
21540 {
21541 PyThreadState* __tstate = wxPyBeginAllowThreads();
21542 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21543
21544 wxPyEndAllowThreads(__tstate);
21545 if (PyErr_Occurred()) SWIG_fail;
21546 }
21547 {
21548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21549 }
21550 return resultobj;
21551 fail:
21552 return NULL;
21553 }
21554
21555
21556 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21557 PyObject *obj;
21558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21559 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21560 Py_INCREF(obj);
21561 return Py_BuildValue((char *)"");
21562 }
21563 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21564 PyObject *resultobj;
21565 wxNavigationKeyEvent *result;
21566 char *kwnames[] = {
21567 NULL
21568 };
21569
21570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21571 {
21572 PyThreadState* __tstate = wxPyBeginAllowThreads();
21573 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21574
21575 wxPyEndAllowThreads(__tstate);
21576 if (PyErr_Occurred()) SWIG_fail;
21577 }
21578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21579 return resultobj;
21580 fail:
21581 return NULL;
21582 }
21583
21584
21585 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21586 PyObject *resultobj;
21587 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21588 bool result;
21589 PyObject * obj0 = 0 ;
21590 char *kwnames[] = {
21591 (char *) "self", NULL
21592 };
21593
21594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21596 if (SWIG_arg_fail(1)) SWIG_fail;
21597 {
21598 PyThreadState* __tstate = wxPyBeginAllowThreads();
21599 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21600
21601 wxPyEndAllowThreads(__tstate);
21602 if (PyErr_Occurred()) SWIG_fail;
21603 }
21604 {
21605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21606 }
21607 return resultobj;
21608 fail:
21609 return NULL;
21610 }
21611
21612
21613 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21614 PyObject *resultobj;
21615 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21616 bool arg2 ;
21617 PyObject * obj0 = 0 ;
21618 PyObject * obj1 = 0 ;
21619 char *kwnames[] = {
21620 (char *) "self",(char *) "forward", NULL
21621 };
21622
21623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21625 if (SWIG_arg_fail(1)) SWIG_fail;
21626 {
21627 arg2 = (bool)(SWIG_As_bool(obj1));
21628 if (SWIG_arg_fail(2)) SWIG_fail;
21629 }
21630 {
21631 PyThreadState* __tstate = wxPyBeginAllowThreads();
21632 (arg1)->SetDirection(arg2);
21633
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 Py_INCREF(Py_None); resultobj = Py_None;
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21645 PyObject *resultobj;
21646 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21647 bool result;
21648 PyObject * obj0 = 0 ;
21649 char *kwnames[] = {
21650 (char *) "self", NULL
21651 };
21652
21653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21655 if (SWIG_arg_fail(1)) SWIG_fail;
21656 {
21657 PyThreadState* __tstate = wxPyBeginAllowThreads();
21658 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21659
21660 wxPyEndAllowThreads(__tstate);
21661 if (PyErr_Occurred()) SWIG_fail;
21662 }
21663 {
21664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21665 }
21666 return resultobj;
21667 fail:
21668 return NULL;
21669 }
21670
21671
21672 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21673 PyObject *resultobj;
21674 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21675 bool arg2 ;
21676 PyObject * obj0 = 0 ;
21677 PyObject * obj1 = 0 ;
21678 char *kwnames[] = {
21679 (char *) "self",(char *) "ischange", NULL
21680 };
21681
21682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21684 if (SWIG_arg_fail(1)) SWIG_fail;
21685 {
21686 arg2 = (bool)(SWIG_As_bool(obj1));
21687 if (SWIG_arg_fail(2)) SWIG_fail;
21688 }
21689 {
21690 PyThreadState* __tstate = wxPyBeginAllowThreads();
21691 (arg1)->SetWindowChange(arg2);
21692
21693 wxPyEndAllowThreads(__tstate);
21694 if (PyErr_Occurred()) SWIG_fail;
21695 }
21696 Py_INCREF(Py_None); resultobj = Py_None;
21697 return resultobj;
21698 fail:
21699 return NULL;
21700 }
21701
21702
21703 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21704 PyObject *resultobj;
21705 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21706 bool result;
21707 PyObject * obj0 = 0 ;
21708 char *kwnames[] = {
21709 (char *) "self", NULL
21710 };
21711
21712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21714 if (SWIG_arg_fail(1)) SWIG_fail;
21715 {
21716 PyThreadState* __tstate = wxPyBeginAllowThreads();
21717 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21718
21719 wxPyEndAllowThreads(__tstate);
21720 if (PyErr_Occurred()) SWIG_fail;
21721 }
21722 {
21723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21724 }
21725 return resultobj;
21726 fail:
21727 return NULL;
21728 }
21729
21730
21731 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21732 PyObject *resultobj;
21733 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21734 bool arg2 ;
21735 PyObject * obj0 = 0 ;
21736 PyObject * obj1 = 0 ;
21737 char *kwnames[] = {
21738 (char *) "self",(char *) "bIs", NULL
21739 };
21740
21741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21743 if (SWIG_arg_fail(1)) SWIG_fail;
21744 {
21745 arg2 = (bool)(SWIG_As_bool(obj1));
21746 if (SWIG_arg_fail(2)) SWIG_fail;
21747 }
21748 {
21749 PyThreadState* __tstate = wxPyBeginAllowThreads();
21750 (arg1)->SetFromTab(arg2);
21751
21752 wxPyEndAllowThreads(__tstate);
21753 if (PyErr_Occurred()) SWIG_fail;
21754 }
21755 Py_INCREF(Py_None); resultobj = Py_None;
21756 return resultobj;
21757 fail:
21758 return NULL;
21759 }
21760
21761
21762 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21763 PyObject *resultobj;
21764 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21765 long arg2 ;
21766 PyObject * obj0 = 0 ;
21767 PyObject * obj1 = 0 ;
21768 char *kwnames[] = {
21769 (char *) "self",(char *) "flags", NULL
21770 };
21771
21772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21774 if (SWIG_arg_fail(1)) SWIG_fail;
21775 {
21776 arg2 = (long)(SWIG_As_long(obj1));
21777 if (SWIG_arg_fail(2)) SWIG_fail;
21778 }
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 (arg1)->SetFlags(arg2);
21782
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 Py_INCREF(Py_None); resultobj = Py_None;
21787 return resultobj;
21788 fail:
21789 return NULL;
21790 }
21791
21792
21793 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21794 PyObject *resultobj;
21795 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21796 wxWindow *result;
21797 PyObject * obj0 = 0 ;
21798 char *kwnames[] = {
21799 (char *) "self", NULL
21800 };
21801
21802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21804 if (SWIG_arg_fail(1)) SWIG_fail;
21805 {
21806 PyThreadState* __tstate = wxPyBeginAllowThreads();
21807 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21808
21809 wxPyEndAllowThreads(__tstate);
21810 if (PyErr_Occurred()) SWIG_fail;
21811 }
21812 {
21813 resultobj = wxPyMake_wxObject(result, 0);
21814 }
21815 return resultobj;
21816 fail:
21817 return NULL;
21818 }
21819
21820
21821 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21822 PyObject *resultobj;
21823 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21824 wxWindow *arg2 = (wxWindow *) 0 ;
21825 PyObject * obj0 = 0 ;
21826 PyObject * obj1 = 0 ;
21827 char *kwnames[] = {
21828 (char *) "self",(char *) "win", NULL
21829 };
21830
21831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21833 if (SWIG_arg_fail(1)) SWIG_fail;
21834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21835 if (SWIG_arg_fail(2)) SWIG_fail;
21836 {
21837 PyThreadState* __tstate = wxPyBeginAllowThreads();
21838 (arg1)->SetCurrentFocus(arg2);
21839
21840 wxPyEndAllowThreads(__tstate);
21841 if (PyErr_Occurred()) SWIG_fail;
21842 }
21843 Py_INCREF(Py_None); resultobj = Py_None;
21844 return resultobj;
21845 fail:
21846 return NULL;
21847 }
21848
21849
21850 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21851 PyObject *obj;
21852 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21853 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21854 Py_INCREF(obj);
21855 return Py_BuildValue((char *)"");
21856 }
21857 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21858 PyObject *resultobj;
21859 wxWindow *arg1 = (wxWindow *) NULL ;
21860 wxWindowCreateEvent *result;
21861 PyObject * obj0 = 0 ;
21862 char *kwnames[] = {
21863 (char *) "win", NULL
21864 };
21865
21866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21867 if (obj0) {
21868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21869 if (SWIG_arg_fail(1)) SWIG_fail;
21870 }
21871 {
21872 PyThreadState* __tstate = wxPyBeginAllowThreads();
21873 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21874
21875 wxPyEndAllowThreads(__tstate);
21876 if (PyErr_Occurred()) SWIG_fail;
21877 }
21878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21879 return resultobj;
21880 fail:
21881 return NULL;
21882 }
21883
21884
21885 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21886 PyObject *resultobj;
21887 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21888 wxWindow *result;
21889 PyObject * obj0 = 0 ;
21890 char *kwnames[] = {
21891 (char *) "self", NULL
21892 };
21893
21894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21896 if (SWIG_arg_fail(1)) SWIG_fail;
21897 {
21898 PyThreadState* __tstate = wxPyBeginAllowThreads();
21899 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21900
21901 wxPyEndAllowThreads(__tstate);
21902 if (PyErr_Occurred()) SWIG_fail;
21903 }
21904 {
21905 resultobj = wxPyMake_wxObject(result, 0);
21906 }
21907 return resultobj;
21908 fail:
21909 return NULL;
21910 }
21911
21912
21913 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21914 PyObject *obj;
21915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21916 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21917 Py_INCREF(obj);
21918 return Py_BuildValue((char *)"");
21919 }
21920 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21921 PyObject *resultobj;
21922 wxWindow *arg1 = (wxWindow *) NULL ;
21923 wxWindowDestroyEvent *result;
21924 PyObject * obj0 = 0 ;
21925 char *kwnames[] = {
21926 (char *) "win", NULL
21927 };
21928
21929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21930 if (obj0) {
21931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21932 if (SWIG_arg_fail(1)) SWIG_fail;
21933 }
21934 {
21935 PyThreadState* __tstate = wxPyBeginAllowThreads();
21936 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21937
21938 wxPyEndAllowThreads(__tstate);
21939 if (PyErr_Occurred()) SWIG_fail;
21940 }
21941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21942 return resultobj;
21943 fail:
21944 return NULL;
21945 }
21946
21947
21948 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21949 PyObject *resultobj;
21950 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21951 wxWindow *result;
21952 PyObject * obj0 = 0 ;
21953 char *kwnames[] = {
21954 (char *) "self", NULL
21955 };
21956
21957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21959 if (SWIG_arg_fail(1)) SWIG_fail;
21960 {
21961 PyThreadState* __tstate = wxPyBeginAllowThreads();
21962 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21963
21964 wxPyEndAllowThreads(__tstate);
21965 if (PyErr_Occurred()) SWIG_fail;
21966 }
21967 {
21968 resultobj = wxPyMake_wxObject(result, 0);
21969 }
21970 return resultobj;
21971 fail:
21972 return NULL;
21973 }
21974
21975
21976 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21977 PyObject *obj;
21978 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21979 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21980 Py_INCREF(obj);
21981 return Py_BuildValue((char *)"");
21982 }
21983 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21984 PyObject *resultobj;
21985 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21986 int arg2 = (int) 0 ;
21987 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21988 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21989 wxContextMenuEvent *result;
21990 wxPoint temp3 ;
21991 PyObject * obj0 = 0 ;
21992 PyObject * obj1 = 0 ;
21993 PyObject * obj2 = 0 ;
21994 char *kwnames[] = {
21995 (char *) "type",(char *) "winid",(char *) "pt", NULL
21996 };
21997
21998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21999 if (obj0) {
22000 {
22001 arg1 = (wxEventType)(SWIG_As_int(obj0));
22002 if (SWIG_arg_fail(1)) SWIG_fail;
22003 }
22004 }
22005 if (obj1) {
22006 {
22007 arg2 = (int)(SWIG_As_int(obj1));
22008 if (SWIG_arg_fail(2)) SWIG_fail;
22009 }
22010 }
22011 if (obj2) {
22012 {
22013 arg3 = &temp3;
22014 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22015 }
22016 }
22017 {
22018 PyThreadState* __tstate = wxPyBeginAllowThreads();
22019 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22020
22021 wxPyEndAllowThreads(__tstate);
22022 if (PyErr_Occurred()) SWIG_fail;
22023 }
22024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22025 return resultobj;
22026 fail:
22027 return NULL;
22028 }
22029
22030
22031 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22032 PyObject *resultobj;
22033 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22034 wxPoint *result;
22035 PyObject * obj0 = 0 ;
22036 char *kwnames[] = {
22037 (char *) "self", NULL
22038 };
22039
22040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22042 if (SWIG_arg_fail(1)) SWIG_fail;
22043 {
22044 PyThreadState* __tstate = wxPyBeginAllowThreads();
22045 {
22046 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22047 result = (wxPoint *) &_result_ref;
22048 }
22049
22050 wxPyEndAllowThreads(__tstate);
22051 if (PyErr_Occurred()) SWIG_fail;
22052 }
22053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22054 return resultobj;
22055 fail:
22056 return NULL;
22057 }
22058
22059
22060 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22061 PyObject *resultobj;
22062 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22063 wxPoint *arg2 = 0 ;
22064 wxPoint temp2 ;
22065 PyObject * obj0 = 0 ;
22066 PyObject * obj1 = 0 ;
22067 char *kwnames[] = {
22068 (char *) "self",(char *) "pos", NULL
22069 };
22070
22071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22073 if (SWIG_arg_fail(1)) SWIG_fail;
22074 {
22075 arg2 = &temp2;
22076 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22077 }
22078 {
22079 PyThreadState* __tstate = wxPyBeginAllowThreads();
22080 (arg1)->SetPosition((wxPoint const &)*arg2);
22081
22082 wxPyEndAllowThreads(__tstate);
22083 if (PyErr_Occurred()) SWIG_fail;
22084 }
22085 Py_INCREF(Py_None); resultobj = Py_None;
22086 return resultobj;
22087 fail:
22088 return NULL;
22089 }
22090
22091
22092 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22093 PyObject *obj;
22094 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22095 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22096 Py_INCREF(obj);
22097 return Py_BuildValue((char *)"");
22098 }
22099 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22100 PyObject *resultobj;
22101 wxIdleEvent *result;
22102 char *kwnames[] = {
22103 NULL
22104 };
22105
22106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22107 {
22108 PyThreadState* __tstate = wxPyBeginAllowThreads();
22109 result = (wxIdleEvent *)new wxIdleEvent();
22110
22111 wxPyEndAllowThreads(__tstate);
22112 if (PyErr_Occurred()) SWIG_fail;
22113 }
22114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22115 return resultobj;
22116 fail:
22117 return NULL;
22118 }
22119
22120
22121 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22122 PyObject *resultobj;
22123 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22124 bool arg2 = (bool) true ;
22125 PyObject * obj0 = 0 ;
22126 PyObject * obj1 = 0 ;
22127 char *kwnames[] = {
22128 (char *) "self",(char *) "needMore", NULL
22129 };
22130
22131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22133 if (SWIG_arg_fail(1)) SWIG_fail;
22134 if (obj1) {
22135 {
22136 arg2 = (bool)(SWIG_As_bool(obj1));
22137 if (SWIG_arg_fail(2)) SWIG_fail;
22138 }
22139 }
22140 {
22141 PyThreadState* __tstate = wxPyBeginAllowThreads();
22142 (arg1)->RequestMore(arg2);
22143
22144 wxPyEndAllowThreads(__tstate);
22145 if (PyErr_Occurred()) SWIG_fail;
22146 }
22147 Py_INCREF(Py_None); resultobj = Py_None;
22148 return resultobj;
22149 fail:
22150 return NULL;
22151 }
22152
22153
22154 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22155 PyObject *resultobj;
22156 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22157 bool result;
22158 PyObject * obj0 = 0 ;
22159 char *kwnames[] = {
22160 (char *) "self", NULL
22161 };
22162
22163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22165 if (SWIG_arg_fail(1)) SWIG_fail;
22166 {
22167 PyThreadState* __tstate = wxPyBeginAllowThreads();
22168 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22169
22170 wxPyEndAllowThreads(__tstate);
22171 if (PyErr_Occurred()) SWIG_fail;
22172 }
22173 {
22174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22175 }
22176 return resultobj;
22177 fail:
22178 return NULL;
22179 }
22180
22181
22182 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22183 PyObject *resultobj;
22184 wxIdleMode arg1 ;
22185 PyObject * obj0 = 0 ;
22186 char *kwnames[] = {
22187 (char *) "mode", NULL
22188 };
22189
22190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22191 {
22192 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22193 if (SWIG_arg_fail(1)) SWIG_fail;
22194 }
22195 {
22196 PyThreadState* __tstate = wxPyBeginAllowThreads();
22197 wxIdleEvent::SetMode((wxIdleMode )arg1);
22198
22199 wxPyEndAllowThreads(__tstate);
22200 if (PyErr_Occurred()) SWIG_fail;
22201 }
22202 Py_INCREF(Py_None); resultobj = Py_None;
22203 return resultobj;
22204 fail:
22205 return NULL;
22206 }
22207
22208
22209 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22210 PyObject *resultobj;
22211 wxIdleMode result;
22212 char *kwnames[] = {
22213 NULL
22214 };
22215
22216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22217 {
22218 PyThreadState* __tstate = wxPyBeginAllowThreads();
22219 result = (wxIdleMode)wxIdleEvent::GetMode();
22220
22221 wxPyEndAllowThreads(__tstate);
22222 if (PyErr_Occurred()) SWIG_fail;
22223 }
22224 resultobj = SWIG_From_int((result));
22225 return resultobj;
22226 fail:
22227 return NULL;
22228 }
22229
22230
22231 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22232 PyObject *resultobj;
22233 wxWindow *arg1 = (wxWindow *) 0 ;
22234 bool result;
22235 PyObject * obj0 = 0 ;
22236 char *kwnames[] = {
22237 (char *) "win", NULL
22238 };
22239
22240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22242 if (SWIG_arg_fail(1)) SWIG_fail;
22243 {
22244 PyThreadState* __tstate = wxPyBeginAllowThreads();
22245 result = (bool)wxIdleEvent::CanSend(arg1);
22246
22247 wxPyEndAllowThreads(__tstate);
22248 if (PyErr_Occurred()) SWIG_fail;
22249 }
22250 {
22251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22252 }
22253 return resultobj;
22254 fail:
22255 return NULL;
22256 }
22257
22258
22259 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22260 PyObject *obj;
22261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22262 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22263 Py_INCREF(obj);
22264 return Py_BuildValue((char *)"");
22265 }
22266 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22267 PyObject *resultobj;
22268 int arg1 = (int) 0 ;
22269 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22270 wxPyEvent *result;
22271 PyObject * obj0 = 0 ;
22272 PyObject * obj1 = 0 ;
22273 char *kwnames[] = {
22274 (char *) "winid",(char *) "commandType", NULL
22275 };
22276
22277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22278 if (obj0) {
22279 {
22280 arg1 = (int)(SWIG_As_int(obj0));
22281 if (SWIG_arg_fail(1)) SWIG_fail;
22282 }
22283 }
22284 if (obj1) {
22285 {
22286 arg2 = (wxEventType)(SWIG_As_int(obj1));
22287 if (SWIG_arg_fail(2)) SWIG_fail;
22288 }
22289 }
22290 {
22291 PyThreadState* __tstate = wxPyBeginAllowThreads();
22292 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22293
22294 wxPyEndAllowThreads(__tstate);
22295 if (PyErr_Occurred()) SWIG_fail;
22296 }
22297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22298 return resultobj;
22299 fail:
22300 return NULL;
22301 }
22302
22303
22304 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22305 PyObject *resultobj;
22306 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22307 PyObject * obj0 = 0 ;
22308 char *kwnames[] = {
22309 (char *) "self", NULL
22310 };
22311
22312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22314 if (SWIG_arg_fail(1)) SWIG_fail;
22315 {
22316 PyThreadState* __tstate = wxPyBeginAllowThreads();
22317 delete arg1;
22318
22319 wxPyEndAllowThreads(__tstate);
22320 if (PyErr_Occurred()) SWIG_fail;
22321 }
22322 Py_INCREF(Py_None); resultobj = Py_None;
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22330 PyObject *resultobj;
22331 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22332 PyObject *arg2 = (PyObject *) 0 ;
22333 PyObject * obj0 = 0 ;
22334 PyObject * obj1 = 0 ;
22335 char *kwnames[] = {
22336 (char *) "self",(char *) "self", NULL
22337 };
22338
22339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22341 if (SWIG_arg_fail(1)) SWIG_fail;
22342 arg2 = obj1;
22343 {
22344 PyThreadState* __tstate = wxPyBeginAllowThreads();
22345 (arg1)->SetSelf(arg2);
22346
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 Py_INCREF(Py_None); resultobj = Py_None;
22351 return resultobj;
22352 fail:
22353 return NULL;
22354 }
22355
22356
22357 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22358 PyObject *resultobj;
22359 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22360 PyObject *result;
22361 PyObject * obj0 = 0 ;
22362 char *kwnames[] = {
22363 (char *) "self", NULL
22364 };
22365
22366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22368 if (SWIG_arg_fail(1)) SWIG_fail;
22369 {
22370 PyThreadState* __tstate = wxPyBeginAllowThreads();
22371 result = (PyObject *)(arg1)->GetSelf();
22372
22373 wxPyEndAllowThreads(__tstate);
22374 if (PyErr_Occurred()) SWIG_fail;
22375 }
22376 resultobj = result;
22377 return resultobj;
22378 fail:
22379 return NULL;
22380 }
22381
22382
22383 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22384 PyObject *obj;
22385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22386 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22387 Py_INCREF(obj);
22388 return Py_BuildValue((char *)"");
22389 }
22390 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22391 PyObject *resultobj;
22392 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22393 int arg2 = (int) 0 ;
22394 wxPyCommandEvent *result;
22395 PyObject * obj0 = 0 ;
22396 PyObject * obj1 = 0 ;
22397 char *kwnames[] = {
22398 (char *) "commandType",(char *) "id", NULL
22399 };
22400
22401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22402 if (obj0) {
22403 {
22404 arg1 = (wxEventType)(SWIG_As_int(obj0));
22405 if (SWIG_arg_fail(1)) SWIG_fail;
22406 }
22407 }
22408 if (obj1) {
22409 {
22410 arg2 = (int)(SWIG_As_int(obj1));
22411 if (SWIG_arg_fail(2)) SWIG_fail;
22412 }
22413 }
22414 {
22415 PyThreadState* __tstate = wxPyBeginAllowThreads();
22416 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22417
22418 wxPyEndAllowThreads(__tstate);
22419 if (PyErr_Occurred()) SWIG_fail;
22420 }
22421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22422 return resultobj;
22423 fail:
22424 return NULL;
22425 }
22426
22427
22428 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22429 PyObject *resultobj;
22430 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22431 PyObject * obj0 = 0 ;
22432 char *kwnames[] = {
22433 (char *) "self", NULL
22434 };
22435
22436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22438 if (SWIG_arg_fail(1)) SWIG_fail;
22439 {
22440 PyThreadState* __tstate = wxPyBeginAllowThreads();
22441 delete arg1;
22442
22443 wxPyEndAllowThreads(__tstate);
22444 if (PyErr_Occurred()) SWIG_fail;
22445 }
22446 Py_INCREF(Py_None); resultobj = Py_None;
22447 return resultobj;
22448 fail:
22449 return NULL;
22450 }
22451
22452
22453 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22454 PyObject *resultobj;
22455 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22456 PyObject *arg2 = (PyObject *) 0 ;
22457 PyObject * obj0 = 0 ;
22458 PyObject * obj1 = 0 ;
22459 char *kwnames[] = {
22460 (char *) "self",(char *) "self", NULL
22461 };
22462
22463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22465 if (SWIG_arg_fail(1)) SWIG_fail;
22466 arg2 = obj1;
22467 {
22468 PyThreadState* __tstate = wxPyBeginAllowThreads();
22469 (arg1)->SetSelf(arg2);
22470
22471 wxPyEndAllowThreads(__tstate);
22472 if (PyErr_Occurred()) SWIG_fail;
22473 }
22474 Py_INCREF(Py_None); resultobj = Py_None;
22475 return resultobj;
22476 fail:
22477 return NULL;
22478 }
22479
22480
22481 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22482 PyObject *resultobj;
22483 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22484 PyObject *result;
22485 PyObject * obj0 = 0 ;
22486 char *kwnames[] = {
22487 (char *) "self", NULL
22488 };
22489
22490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22492 if (SWIG_arg_fail(1)) SWIG_fail;
22493 {
22494 PyThreadState* __tstate = wxPyBeginAllowThreads();
22495 result = (PyObject *)(arg1)->GetSelf();
22496
22497 wxPyEndAllowThreads(__tstate);
22498 if (PyErr_Occurred()) SWIG_fail;
22499 }
22500 resultobj = result;
22501 return resultobj;
22502 fail:
22503 return NULL;
22504 }
22505
22506
22507 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22508 PyObject *obj;
22509 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22510 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22511 Py_INCREF(obj);
22512 return Py_BuildValue((char *)"");
22513 }
22514 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22515 PyObject *resultobj;
22516 wxWindow *arg1 = (wxWindow *) 0 ;
22517 wxDateTime *arg2 = 0 ;
22518 wxEventType arg3 ;
22519 wxDateEvent *result;
22520 PyObject * obj0 = 0 ;
22521 PyObject * obj1 = 0 ;
22522 PyObject * obj2 = 0 ;
22523 char *kwnames[] = {
22524 (char *) "win",(char *) "dt",(char *) "type", NULL
22525 };
22526
22527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22529 if (SWIG_arg_fail(1)) SWIG_fail;
22530 {
22531 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22532 if (SWIG_arg_fail(2)) SWIG_fail;
22533 if (arg2 == NULL) {
22534 SWIG_null_ref("wxDateTime");
22535 }
22536 if (SWIG_arg_fail(2)) SWIG_fail;
22537 }
22538 {
22539 arg3 = (wxEventType)(SWIG_As_int(obj2));
22540 if (SWIG_arg_fail(3)) SWIG_fail;
22541 }
22542 {
22543 PyThreadState* __tstate = wxPyBeginAllowThreads();
22544 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22545
22546 wxPyEndAllowThreads(__tstate);
22547 if (PyErr_Occurred()) SWIG_fail;
22548 }
22549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22550 return resultobj;
22551 fail:
22552 return NULL;
22553 }
22554
22555
22556 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22557 PyObject *resultobj;
22558 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22559 wxDateTime *result;
22560 PyObject * obj0 = 0 ;
22561 char *kwnames[] = {
22562 (char *) "self", NULL
22563 };
22564
22565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22567 if (SWIG_arg_fail(1)) SWIG_fail;
22568 {
22569 PyThreadState* __tstate = wxPyBeginAllowThreads();
22570 {
22571 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22572 result = (wxDateTime *) &_result_ref;
22573 }
22574
22575 wxPyEndAllowThreads(__tstate);
22576 if (PyErr_Occurred()) SWIG_fail;
22577 }
22578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22579 return resultobj;
22580 fail:
22581 return NULL;
22582 }
22583
22584
22585 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22586 PyObject *resultobj;
22587 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22588 wxDateTime *arg2 = 0 ;
22589 PyObject * obj0 = 0 ;
22590 PyObject * obj1 = 0 ;
22591 char *kwnames[] = {
22592 (char *) "self",(char *) "date", NULL
22593 };
22594
22595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22597 if (SWIG_arg_fail(1)) SWIG_fail;
22598 {
22599 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22600 if (SWIG_arg_fail(2)) SWIG_fail;
22601 if (arg2 == NULL) {
22602 SWIG_null_ref("wxDateTime");
22603 }
22604 if (SWIG_arg_fail(2)) SWIG_fail;
22605 }
22606 {
22607 PyThreadState* __tstate = wxPyBeginAllowThreads();
22608 (arg1)->SetDate((wxDateTime const &)*arg2);
22609
22610 wxPyEndAllowThreads(__tstate);
22611 if (PyErr_Occurred()) SWIG_fail;
22612 }
22613 Py_INCREF(Py_None); resultobj = Py_None;
22614 return resultobj;
22615 fail:
22616 return NULL;
22617 }
22618
22619
22620 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22621 PyObject *obj;
22622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22623 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22624 Py_INCREF(obj);
22625 return Py_BuildValue((char *)"");
22626 }
22627 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22628 PyObject *resultobj;
22629 wxPyApp *result;
22630 char *kwnames[] = {
22631 NULL
22632 };
22633
22634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22635 {
22636 PyThreadState* __tstate = wxPyBeginAllowThreads();
22637 result = (wxPyApp *)new_wxPyApp();
22638
22639 wxPyEndAllowThreads(__tstate);
22640 if (PyErr_Occurred()) SWIG_fail;
22641 }
22642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22650 PyObject *resultobj;
22651 wxPyApp *arg1 = (wxPyApp *) 0 ;
22652 PyObject * obj0 = 0 ;
22653 char *kwnames[] = {
22654 (char *) "self", NULL
22655 };
22656
22657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22659 if (SWIG_arg_fail(1)) SWIG_fail;
22660 {
22661 PyThreadState* __tstate = wxPyBeginAllowThreads();
22662 delete arg1;
22663
22664 wxPyEndAllowThreads(__tstate);
22665 if (PyErr_Occurred()) SWIG_fail;
22666 }
22667 Py_INCREF(Py_None); resultobj = Py_None;
22668 return resultobj;
22669 fail:
22670 return NULL;
22671 }
22672
22673
22674 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22675 PyObject *resultobj;
22676 wxPyApp *arg1 = (wxPyApp *) 0 ;
22677 PyObject *arg2 = (PyObject *) 0 ;
22678 PyObject *arg3 = (PyObject *) 0 ;
22679 bool arg4 ;
22680 PyObject * obj0 = 0 ;
22681 PyObject * obj1 = 0 ;
22682 PyObject * obj2 = 0 ;
22683 PyObject * obj3 = 0 ;
22684 char *kwnames[] = {
22685 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
22686 };
22687
22688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22690 if (SWIG_arg_fail(1)) SWIG_fail;
22691 arg2 = obj1;
22692 arg3 = obj2;
22693 {
22694 arg4 = (bool)(SWIG_As_bool(obj3));
22695 if (SWIG_arg_fail(4)) SWIG_fail;
22696 }
22697 {
22698 PyThreadState* __tstate = wxPyBeginAllowThreads();
22699 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
22700
22701 wxPyEndAllowThreads(__tstate);
22702 if (PyErr_Occurred()) SWIG_fail;
22703 }
22704 Py_INCREF(Py_None); resultobj = Py_None;
22705 return resultobj;
22706 fail:
22707 return NULL;
22708 }
22709
22710
22711 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22712 PyObject *resultobj;
22713 wxPyApp *arg1 = (wxPyApp *) 0 ;
22714 wxString result;
22715 PyObject * obj0 = 0 ;
22716 char *kwnames[] = {
22717 (char *) "self", NULL
22718 };
22719
22720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22722 if (SWIG_arg_fail(1)) SWIG_fail;
22723 {
22724 PyThreadState* __tstate = wxPyBeginAllowThreads();
22725 result = ((wxPyApp const *)arg1)->GetAppName();
22726
22727 wxPyEndAllowThreads(__tstate);
22728 if (PyErr_Occurred()) SWIG_fail;
22729 }
22730 {
22731 #if wxUSE_UNICODE
22732 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22733 #else
22734 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22735 #endif
22736 }
22737 return resultobj;
22738 fail:
22739 return NULL;
22740 }
22741
22742
22743 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22744 PyObject *resultobj;
22745 wxPyApp *arg1 = (wxPyApp *) 0 ;
22746 wxString *arg2 = 0 ;
22747 bool temp2 = false ;
22748 PyObject * obj0 = 0 ;
22749 PyObject * obj1 = 0 ;
22750 char *kwnames[] = {
22751 (char *) "self",(char *) "name", NULL
22752 };
22753
22754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22756 if (SWIG_arg_fail(1)) SWIG_fail;
22757 {
22758 arg2 = wxString_in_helper(obj1);
22759 if (arg2 == NULL) SWIG_fail;
22760 temp2 = true;
22761 }
22762 {
22763 PyThreadState* __tstate = wxPyBeginAllowThreads();
22764 (arg1)->SetAppName((wxString const &)*arg2);
22765
22766 wxPyEndAllowThreads(__tstate);
22767 if (PyErr_Occurred()) SWIG_fail;
22768 }
22769 Py_INCREF(Py_None); resultobj = Py_None;
22770 {
22771 if (temp2)
22772 delete arg2;
22773 }
22774 return resultobj;
22775 fail:
22776 {
22777 if (temp2)
22778 delete arg2;
22779 }
22780 return NULL;
22781 }
22782
22783
22784 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22785 PyObject *resultobj;
22786 wxPyApp *arg1 = (wxPyApp *) 0 ;
22787 wxString result;
22788 PyObject * obj0 = 0 ;
22789 char *kwnames[] = {
22790 (char *) "self", NULL
22791 };
22792
22793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22795 if (SWIG_arg_fail(1)) SWIG_fail;
22796 {
22797 PyThreadState* __tstate = wxPyBeginAllowThreads();
22798 result = ((wxPyApp const *)arg1)->GetClassName();
22799
22800 wxPyEndAllowThreads(__tstate);
22801 if (PyErr_Occurred()) SWIG_fail;
22802 }
22803 {
22804 #if wxUSE_UNICODE
22805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22806 #else
22807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22808 #endif
22809 }
22810 return resultobj;
22811 fail:
22812 return NULL;
22813 }
22814
22815
22816 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22817 PyObject *resultobj;
22818 wxPyApp *arg1 = (wxPyApp *) 0 ;
22819 wxString *arg2 = 0 ;
22820 bool temp2 = false ;
22821 PyObject * obj0 = 0 ;
22822 PyObject * obj1 = 0 ;
22823 char *kwnames[] = {
22824 (char *) "self",(char *) "name", NULL
22825 };
22826
22827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22829 if (SWIG_arg_fail(1)) SWIG_fail;
22830 {
22831 arg2 = wxString_in_helper(obj1);
22832 if (arg2 == NULL) SWIG_fail;
22833 temp2 = true;
22834 }
22835 {
22836 PyThreadState* __tstate = wxPyBeginAllowThreads();
22837 (arg1)->SetClassName((wxString const &)*arg2);
22838
22839 wxPyEndAllowThreads(__tstate);
22840 if (PyErr_Occurred()) SWIG_fail;
22841 }
22842 Py_INCREF(Py_None); resultobj = Py_None;
22843 {
22844 if (temp2)
22845 delete arg2;
22846 }
22847 return resultobj;
22848 fail:
22849 {
22850 if (temp2)
22851 delete arg2;
22852 }
22853 return NULL;
22854 }
22855
22856
22857 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22858 PyObject *resultobj;
22859 wxPyApp *arg1 = (wxPyApp *) 0 ;
22860 wxString *result;
22861 PyObject * obj0 = 0 ;
22862 char *kwnames[] = {
22863 (char *) "self", NULL
22864 };
22865
22866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22868 if (SWIG_arg_fail(1)) SWIG_fail;
22869 {
22870 PyThreadState* __tstate = wxPyBeginAllowThreads();
22871 {
22872 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22873 result = (wxString *) &_result_ref;
22874 }
22875
22876 wxPyEndAllowThreads(__tstate);
22877 if (PyErr_Occurred()) SWIG_fail;
22878 }
22879 {
22880 #if wxUSE_UNICODE
22881 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22882 #else
22883 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22884 #endif
22885 }
22886 return resultobj;
22887 fail:
22888 return NULL;
22889 }
22890
22891
22892 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22893 PyObject *resultobj;
22894 wxPyApp *arg1 = (wxPyApp *) 0 ;
22895 wxString *arg2 = 0 ;
22896 bool temp2 = false ;
22897 PyObject * obj0 = 0 ;
22898 PyObject * obj1 = 0 ;
22899 char *kwnames[] = {
22900 (char *) "self",(char *) "name", NULL
22901 };
22902
22903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22905 if (SWIG_arg_fail(1)) SWIG_fail;
22906 {
22907 arg2 = wxString_in_helper(obj1);
22908 if (arg2 == NULL) SWIG_fail;
22909 temp2 = true;
22910 }
22911 {
22912 PyThreadState* __tstate = wxPyBeginAllowThreads();
22913 (arg1)->SetVendorName((wxString const &)*arg2);
22914
22915 wxPyEndAllowThreads(__tstate);
22916 if (PyErr_Occurred()) SWIG_fail;
22917 }
22918 Py_INCREF(Py_None); resultobj = Py_None;
22919 {
22920 if (temp2)
22921 delete arg2;
22922 }
22923 return resultobj;
22924 fail:
22925 {
22926 if (temp2)
22927 delete arg2;
22928 }
22929 return NULL;
22930 }
22931
22932
22933 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22934 PyObject *resultobj;
22935 wxPyApp *arg1 = (wxPyApp *) 0 ;
22936 wxAppTraits *result;
22937 PyObject * obj0 = 0 ;
22938 char *kwnames[] = {
22939 (char *) "self", NULL
22940 };
22941
22942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22944 if (SWIG_arg_fail(1)) SWIG_fail;
22945 {
22946 PyThreadState* __tstate = wxPyBeginAllowThreads();
22947 result = (wxAppTraits *)(arg1)->GetTraits();
22948
22949 wxPyEndAllowThreads(__tstate);
22950 if (PyErr_Occurred()) SWIG_fail;
22951 }
22952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22953 return resultobj;
22954 fail:
22955 return NULL;
22956 }
22957
22958
22959 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22960 PyObject *resultobj;
22961 wxPyApp *arg1 = (wxPyApp *) 0 ;
22962 PyObject * obj0 = 0 ;
22963 char *kwnames[] = {
22964 (char *) "self", NULL
22965 };
22966
22967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22969 if (SWIG_arg_fail(1)) SWIG_fail;
22970 {
22971 PyThreadState* __tstate = wxPyBeginAllowThreads();
22972 (arg1)->ProcessPendingEvents();
22973
22974 wxPyEndAllowThreads(__tstate);
22975 if (PyErr_Occurred()) SWIG_fail;
22976 }
22977 Py_INCREF(Py_None); resultobj = Py_None;
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22985 PyObject *resultobj;
22986 wxPyApp *arg1 = (wxPyApp *) 0 ;
22987 bool arg2 = (bool) false ;
22988 bool result;
22989 PyObject * obj0 = 0 ;
22990 PyObject * obj1 = 0 ;
22991 char *kwnames[] = {
22992 (char *) "self",(char *) "onlyIfNeeded", NULL
22993 };
22994
22995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22997 if (SWIG_arg_fail(1)) SWIG_fail;
22998 if (obj1) {
22999 {
23000 arg2 = (bool)(SWIG_As_bool(obj1));
23001 if (SWIG_arg_fail(2)) SWIG_fail;
23002 }
23003 }
23004 {
23005 PyThreadState* __tstate = wxPyBeginAllowThreads();
23006 result = (bool)(arg1)->Yield(arg2);
23007
23008 wxPyEndAllowThreads(__tstate);
23009 if (PyErr_Occurred()) SWIG_fail;
23010 }
23011 {
23012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23013 }
23014 return resultobj;
23015 fail:
23016 return NULL;
23017 }
23018
23019
23020 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23021 PyObject *resultobj;
23022 wxPyApp *arg1 = (wxPyApp *) 0 ;
23023 PyObject * obj0 = 0 ;
23024 char *kwnames[] = {
23025 (char *) "self", NULL
23026 };
23027
23028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23030 if (SWIG_arg_fail(1)) SWIG_fail;
23031 {
23032 PyThreadState* __tstate = wxPyBeginAllowThreads();
23033 (arg1)->WakeUpIdle();
23034
23035 wxPyEndAllowThreads(__tstate);
23036 if (PyErr_Occurred()) SWIG_fail;
23037 }
23038 Py_INCREF(Py_None); resultobj = Py_None;
23039 return resultobj;
23040 fail:
23041 return NULL;
23042 }
23043
23044
23045 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23046 PyObject *resultobj;
23047 bool result;
23048 char *kwnames[] = {
23049 NULL
23050 };
23051
23052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23053 {
23054 PyThreadState* __tstate = wxPyBeginAllowThreads();
23055 result = (bool)wxPyApp::IsMainLoopRunning();
23056
23057 wxPyEndAllowThreads(__tstate);
23058 if (PyErr_Occurred()) SWIG_fail;
23059 }
23060 {
23061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23062 }
23063 return resultobj;
23064 fail:
23065 return NULL;
23066 }
23067
23068
23069 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23070 PyObject *resultobj;
23071 wxPyApp *arg1 = (wxPyApp *) 0 ;
23072 int result;
23073 PyObject * obj0 = 0 ;
23074 char *kwnames[] = {
23075 (char *) "self", NULL
23076 };
23077
23078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23080 if (SWIG_arg_fail(1)) SWIG_fail;
23081 {
23082 PyThreadState* __tstate = wxPyBeginAllowThreads();
23083 result = (int)(arg1)->MainLoop();
23084
23085 wxPyEndAllowThreads(__tstate);
23086 if (PyErr_Occurred()) SWIG_fail;
23087 }
23088 {
23089 resultobj = SWIG_From_int((int)(result));
23090 }
23091 return resultobj;
23092 fail:
23093 return NULL;
23094 }
23095
23096
23097 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23098 PyObject *resultobj;
23099 wxPyApp *arg1 = (wxPyApp *) 0 ;
23100 PyObject * obj0 = 0 ;
23101 char *kwnames[] = {
23102 (char *) "self", NULL
23103 };
23104
23105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23107 if (SWIG_arg_fail(1)) SWIG_fail;
23108 {
23109 PyThreadState* __tstate = wxPyBeginAllowThreads();
23110 (arg1)->Exit();
23111
23112 wxPyEndAllowThreads(__tstate);
23113 if (PyErr_Occurred()) SWIG_fail;
23114 }
23115 Py_INCREF(Py_None); resultobj = Py_None;
23116 return resultobj;
23117 fail:
23118 return NULL;
23119 }
23120
23121
23122 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23123 PyObject *resultobj;
23124 wxPyApp *arg1 = (wxPyApp *) 0 ;
23125 PyObject * obj0 = 0 ;
23126 char *kwnames[] = {
23127 (char *) "self", NULL
23128 };
23129
23130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23132 if (SWIG_arg_fail(1)) SWIG_fail;
23133 {
23134 PyThreadState* __tstate = wxPyBeginAllowThreads();
23135 (arg1)->ExitMainLoop();
23136
23137 wxPyEndAllowThreads(__tstate);
23138 if (PyErr_Occurred()) SWIG_fail;
23139 }
23140 Py_INCREF(Py_None); resultobj = Py_None;
23141 return resultobj;
23142 fail:
23143 return NULL;
23144 }
23145
23146
23147 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23148 PyObject *resultobj;
23149 wxPyApp *arg1 = (wxPyApp *) 0 ;
23150 bool result;
23151 PyObject * obj0 = 0 ;
23152 char *kwnames[] = {
23153 (char *) "self", NULL
23154 };
23155
23156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23158 if (SWIG_arg_fail(1)) SWIG_fail;
23159 {
23160 PyThreadState* __tstate = wxPyBeginAllowThreads();
23161 result = (bool)(arg1)->Pending();
23162
23163 wxPyEndAllowThreads(__tstate);
23164 if (PyErr_Occurred()) SWIG_fail;
23165 }
23166 {
23167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23168 }
23169 return resultobj;
23170 fail:
23171 return NULL;
23172 }
23173
23174
23175 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23176 PyObject *resultobj;
23177 wxPyApp *arg1 = (wxPyApp *) 0 ;
23178 bool result;
23179 PyObject * obj0 = 0 ;
23180 char *kwnames[] = {
23181 (char *) "self", NULL
23182 };
23183
23184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23186 if (SWIG_arg_fail(1)) SWIG_fail;
23187 {
23188 PyThreadState* __tstate = wxPyBeginAllowThreads();
23189 result = (bool)(arg1)->Dispatch();
23190
23191 wxPyEndAllowThreads(__tstate);
23192 if (PyErr_Occurred()) SWIG_fail;
23193 }
23194 {
23195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23196 }
23197 return resultobj;
23198 fail:
23199 return NULL;
23200 }
23201
23202
23203 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23204 PyObject *resultobj;
23205 wxPyApp *arg1 = (wxPyApp *) 0 ;
23206 bool result;
23207 PyObject * obj0 = 0 ;
23208 char *kwnames[] = {
23209 (char *) "self", NULL
23210 };
23211
23212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23214 if (SWIG_arg_fail(1)) SWIG_fail;
23215 {
23216 PyThreadState* __tstate = wxPyBeginAllowThreads();
23217 result = (bool)(arg1)->ProcessIdle();
23218
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 {
23223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23224 }
23225 return resultobj;
23226 fail:
23227 return NULL;
23228 }
23229
23230
23231 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23232 PyObject *resultobj;
23233 wxPyApp *arg1 = (wxPyApp *) 0 ;
23234 wxWindow *arg2 = (wxWindow *) 0 ;
23235 wxIdleEvent *arg3 = 0 ;
23236 bool result;
23237 PyObject * obj0 = 0 ;
23238 PyObject * obj1 = 0 ;
23239 PyObject * obj2 = 0 ;
23240 char *kwnames[] = {
23241 (char *) "self",(char *) "win",(char *) "event", NULL
23242 };
23243
23244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23246 if (SWIG_arg_fail(1)) SWIG_fail;
23247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23248 if (SWIG_arg_fail(2)) SWIG_fail;
23249 {
23250 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23251 if (SWIG_arg_fail(3)) SWIG_fail;
23252 if (arg3 == NULL) {
23253 SWIG_null_ref("wxIdleEvent");
23254 }
23255 if (SWIG_arg_fail(3)) SWIG_fail;
23256 }
23257 {
23258 PyThreadState* __tstate = wxPyBeginAllowThreads();
23259 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23260
23261 wxPyEndAllowThreads(__tstate);
23262 if (PyErr_Occurred()) SWIG_fail;
23263 }
23264 {
23265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23266 }
23267 return resultobj;
23268 fail:
23269 return NULL;
23270 }
23271
23272
23273 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23274 PyObject *resultobj;
23275 wxPyApp *arg1 = (wxPyApp *) 0 ;
23276 bool result;
23277 PyObject * obj0 = 0 ;
23278 char *kwnames[] = {
23279 (char *) "self", NULL
23280 };
23281
23282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23284 if (SWIG_arg_fail(1)) SWIG_fail;
23285 {
23286 PyThreadState* __tstate = wxPyBeginAllowThreads();
23287 result = (bool)((wxPyApp const *)arg1)->IsActive();
23288
23289 wxPyEndAllowThreads(__tstate);
23290 if (PyErr_Occurred()) SWIG_fail;
23291 }
23292 {
23293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23294 }
23295 return resultobj;
23296 fail:
23297 return NULL;
23298 }
23299
23300
23301 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23302 PyObject *resultobj;
23303 wxPyApp *arg1 = (wxPyApp *) 0 ;
23304 wxWindow *arg2 = (wxWindow *) 0 ;
23305 PyObject * obj0 = 0 ;
23306 PyObject * obj1 = 0 ;
23307 char *kwnames[] = {
23308 (char *) "self",(char *) "win", NULL
23309 };
23310
23311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23313 if (SWIG_arg_fail(1)) SWIG_fail;
23314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23315 if (SWIG_arg_fail(2)) SWIG_fail;
23316 {
23317 PyThreadState* __tstate = wxPyBeginAllowThreads();
23318 (arg1)->SetTopWindow(arg2);
23319
23320 wxPyEndAllowThreads(__tstate);
23321 if (PyErr_Occurred()) SWIG_fail;
23322 }
23323 Py_INCREF(Py_None); resultobj = Py_None;
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23331 PyObject *resultobj;
23332 wxPyApp *arg1 = (wxPyApp *) 0 ;
23333 wxWindow *result;
23334 PyObject * obj0 = 0 ;
23335 char *kwnames[] = {
23336 (char *) "self", NULL
23337 };
23338
23339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23341 if (SWIG_arg_fail(1)) SWIG_fail;
23342 {
23343 PyThreadState* __tstate = wxPyBeginAllowThreads();
23344 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23345
23346 wxPyEndAllowThreads(__tstate);
23347 if (PyErr_Occurred()) SWIG_fail;
23348 }
23349 {
23350 resultobj = wxPyMake_wxObject(result, 0);
23351 }
23352 return resultobj;
23353 fail:
23354 return NULL;
23355 }
23356
23357
23358 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23359 PyObject *resultobj;
23360 wxPyApp *arg1 = (wxPyApp *) 0 ;
23361 bool arg2 ;
23362 PyObject * obj0 = 0 ;
23363 PyObject * obj1 = 0 ;
23364 char *kwnames[] = {
23365 (char *) "self",(char *) "flag", NULL
23366 };
23367
23368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23370 if (SWIG_arg_fail(1)) SWIG_fail;
23371 {
23372 arg2 = (bool)(SWIG_As_bool(obj1));
23373 if (SWIG_arg_fail(2)) SWIG_fail;
23374 }
23375 {
23376 PyThreadState* __tstate = wxPyBeginAllowThreads();
23377 (arg1)->SetExitOnFrameDelete(arg2);
23378
23379 wxPyEndAllowThreads(__tstate);
23380 if (PyErr_Occurred()) SWIG_fail;
23381 }
23382 Py_INCREF(Py_None); resultobj = Py_None;
23383 return resultobj;
23384 fail:
23385 return NULL;
23386 }
23387
23388
23389 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23390 PyObject *resultobj;
23391 wxPyApp *arg1 = (wxPyApp *) 0 ;
23392 bool result;
23393 PyObject * obj0 = 0 ;
23394 char *kwnames[] = {
23395 (char *) "self", NULL
23396 };
23397
23398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23400 if (SWIG_arg_fail(1)) SWIG_fail;
23401 {
23402 PyThreadState* __tstate = wxPyBeginAllowThreads();
23403 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23404
23405 wxPyEndAllowThreads(__tstate);
23406 if (PyErr_Occurred()) SWIG_fail;
23407 }
23408 {
23409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23410 }
23411 return resultobj;
23412 fail:
23413 return NULL;
23414 }
23415
23416
23417 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj;
23419 wxPyApp *arg1 = (wxPyApp *) 0 ;
23420 bool arg2 ;
23421 PyObject * obj0 = 0 ;
23422 PyObject * obj1 = 0 ;
23423 char *kwnames[] = {
23424 (char *) "self",(char *) "flag", NULL
23425 };
23426
23427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23429 if (SWIG_arg_fail(1)) SWIG_fail;
23430 {
23431 arg2 = (bool)(SWIG_As_bool(obj1));
23432 if (SWIG_arg_fail(2)) SWIG_fail;
23433 }
23434 {
23435 PyThreadState* __tstate = wxPyBeginAllowThreads();
23436 (arg1)->SetUseBestVisual(arg2);
23437
23438 wxPyEndAllowThreads(__tstate);
23439 if (PyErr_Occurred()) SWIG_fail;
23440 }
23441 Py_INCREF(Py_None); resultobj = Py_None;
23442 return resultobj;
23443 fail:
23444 return NULL;
23445 }
23446
23447
23448 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23449 PyObject *resultobj;
23450 wxPyApp *arg1 = (wxPyApp *) 0 ;
23451 bool result;
23452 PyObject * obj0 = 0 ;
23453 char *kwnames[] = {
23454 (char *) "self", NULL
23455 };
23456
23457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23459 if (SWIG_arg_fail(1)) SWIG_fail;
23460 {
23461 PyThreadState* __tstate = wxPyBeginAllowThreads();
23462 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23463
23464 wxPyEndAllowThreads(__tstate);
23465 if (PyErr_Occurred()) SWIG_fail;
23466 }
23467 {
23468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23469 }
23470 return resultobj;
23471 fail:
23472 return NULL;
23473 }
23474
23475
23476 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23477 PyObject *resultobj;
23478 wxPyApp *arg1 = (wxPyApp *) 0 ;
23479 int arg2 ;
23480 PyObject * obj0 = 0 ;
23481 PyObject * obj1 = 0 ;
23482 char *kwnames[] = {
23483 (char *) "self",(char *) "mode", NULL
23484 };
23485
23486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23488 if (SWIG_arg_fail(1)) SWIG_fail;
23489 {
23490 arg2 = (int)(SWIG_As_int(obj1));
23491 if (SWIG_arg_fail(2)) SWIG_fail;
23492 }
23493 {
23494 PyThreadState* __tstate = wxPyBeginAllowThreads();
23495 (arg1)->SetPrintMode(arg2);
23496
23497 wxPyEndAllowThreads(__tstate);
23498 if (PyErr_Occurred()) SWIG_fail;
23499 }
23500 Py_INCREF(Py_None); resultobj = Py_None;
23501 return resultobj;
23502 fail:
23503 return NULL;
23504 }
23505
23506
23507 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23508 PyObject *resultobj;
23509 wxPyApp *arg1 = (wxPyApp *) 0 ;
23510 int result;
23511 PyObject * obj0 = 0 ;
23512 char *kwnames[] = {
23513 (char *) "self", NULL
23514 };
23515
23516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23518 if (SWIG_arg_fail(1)) SWIG_fail;
23519 {
23520 PyThreadState* __tstate = wxPyBeginAllowThreads();
23521 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23522
23523 wxPyEndAllowThreads(__tstate);
23524 if (PyErr_Occurred()) SWIG_fail;
23525 }
23526 {
23527 resultobj = SWIG_From_int((int)(result));
23528 }
23529 return resultobj;
23530 fail:
23531 return NULL;
23532 }
23533
23534
23535 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23536 PyObject *resultobj;
23537 wxPyApp *arg1 = (wxPyApp *) 0 ;
23538 int arg2 ;
23539 PyObject * obj0 = 0 ;
23540 PyObject * obj1 = 0 ;
23541 char *kwnames[] = {
23542 (char *) "self",(char *) "mode", NULL
23543 };
23544
23545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23547 if (SWIG_arg_fail(1)) SWIG_fail;
23548 {
23549 arg2 = (int)(SWIG_As_int(obj1));
23550 if (SWIG_arg_fail(2)) SWIG_fail;
23551 }
23552 {
23553 PyThreadState* __tstate = wxPyBeginAllowThreads();
23554 (arg1)->SetAssertMode(arg2);
23555
23556 wxPyEndAllowThreads(__tstate);
23557 if (PyErr_Occurred()) SWIG_fail;
23558 }
23559 Py_INCREF(Py_None); resultobj = Py_None;
23560 return resultobj;
23561 fail:
23562 return NULL;
23563 }
23564
23565
23566 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23567 PyObject *resultobj;
23568 wxPyApp *arg1 = (wxPyApp *) 0 ;
23569 int result;
23570 PyObject * obj0 = 0 ;
23571 char *kwnames[] = {
23572 (char *) "self", NULL
23573 };
23574
23575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23577 if (SWIG_arg_fail(1)) SWIG_fail;
23578 {
23579 PyThreadState* __tstate = wxPyBeginAllowThreads();
23580 result = (int)(arg1)->GetAssertMode();
23581
23582 wxPyEndAllowThreads(__tstate);
23583 if (PyErr_Occurred()) SWIG_fail;
23584 }
23585 {
23586 resultobj = SWIG_From_int((int)(result));
23587 }
23588 return resultobj;
23589 fail:
23590 return NULL;
23591 }
23592
23593
23594 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23595 PyObject *resultobj;
23596 bool result;
23597 char *kwnames[] = {
23598 NULL
23599 };
23600
23601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23602 {
23603 PyThreadState* __tstate = wxPyBeginAllowThreads();
23604 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23605
23606 wxPyEndAllowThreads(__tstate);
23607 if (PyErr_Occurred()) SWIG_fail;
23608 }
23609 {
23610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23611 }
23612 return resultobj;
23613 fail:
23614 return NULL;
23615 }
23616
23617
23618 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23619 PyObject *resultobj;
23620 long result;
23621 char *kwnames[] = {
23622 NULL
23623 };
23624
23625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23626 {
23627 PyThreadState* __tstate = wxPyBeginAllowThreads();
23628 result = (long)wxPyApp::GetMacAboutMenuItemId();
23629
23630 wxPyEndAllowThreads(__tstate);
23631 if (PyErr_Occurred()) SWIG_fail;
23632 }
23633 {
23634 resultobj = SWIG_From_long((long)(result));
23635 }
23636 return resultobj;
23637 fail:
23638 return NULL;
23639 }
23640
23641
23642 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23643 PyObject *resultobj;
23644 long result;
23645 char *kwnames[] = {
23646 NULL
23647 };
23648
23649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23650 {
23651 PyThreadState* __tstate = wxPyBeginAllowThreads();
23652 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23653
23654 wxPyEndAllowThreads(__tstate);
23655 if (PyErr_Occurred()) SWIG_fail;
23656 }
23657 {
23658 resultobj = SWIG_From_long((long)(result));
23659 }
23660 return resultobj;
23661 fail:
23662 return NULL;
23663 }
23664
23665
23666 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23667 PyObject *resultobj;
23668 long result;
23669 char *kwnames[] = {
23670 NULL
23671 };
23672
23673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23674 {
23675 PyThreadState* __tstate = wxPyBeginAllowThreads();
23676 result = (long)wxPyApp::GetMacExitMenuItemId();
23677
23678 wxPyEndAllowThreads(__tstate);
23679 if (PyErr_Occurred()) SWIG_fail;
23680 }
23681 {
23682 resultobj = SWIG_From_long((long)(result));
23683 }
23684 return resultobj;
23685 fail:
23686 return NULL;
23687 }
23688
23689
23690 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23691 PyObject *resultobj;
23692 wxString result;
23693 char *kwnames[] = {
23694 NULL
23695 };
23696
23697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23698 {
23699 PyThreadState* __tstate = wxPyBeginAllowThreads();
23700 result = wxPyApp::GetMacHelpMenuTitleName();
23701
23702 wxPyEndAllowThreads(__tstate);
23703 if (PyErr_Occurred()) SWIG_fail;
23704 }
23705 {
23706 #if wxUSE_UNICODE
23707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23708 #else
23709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23710 #endif
23711 }
23712 return resultobj;
23713 fail:
23714 return NULL;
23715 }
23716
23717
23718 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23719 PyObject *resultobj;
23720 bool arg1 ;
23721 PyObject * obj0 = 0 ;
23722 char *kwnames[] = {
23723 (char *) "val", NULL
23724 };
23725
23726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23727 {
23728 arg1 = (bool)(SWIG_As_bool(obj0));
23729 if (SWIG_arg_fail(1)) SWIG_fail;
23730 }
23731 {
23732 PyThreadState* __tstate = wxPyBeginAllowThreads();
23733 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23734
23735 wxPyEndAllowThreads(__tstate);
23736 if (PyErr_Occurred()) SWIG_fail;
23737 }
23738 Py_INCREF(Py_None); resultobj = Py_None;
23739 return resultobj;
23740 fail:
23741 return NULL;
23742 }
23743
23744
23745 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23746 PyObject *resultobj;
23747 long arg1 ;
23748 PyObject * obj0 = 0 ;
23749 char *kwnames[] = {
23750 (char *) "val", NULL
23751 };
23752
23753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23754 {
23755 arg1 = (long)(SWIG_As_long(obj0));
23756 if (SWIG_arg_fail(1)) SWIG_fail;
23757 }
23758 {
23759 PyThreadState* __tstate = wxPyBeginAllowThreads();
23760 wxPyApp::SetMacAboutMenuItemId(arg1);
23761
23762 wxPyEndAllowThreads(__tstate);
23763 if (PyErr_Occurred()) SWIG_fail;
23764 }
23765 Py_INCREF(Py_None); resultobj = Py_None;
23766 return resultobj;
23767 fail:
23768 return NULL;
23769 }
23770
23771
23772 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23773 PyObject *resultobj;
23774 long arg1 ;
23775 PyObject * obj0 = 0 ;
23776 char *kwnames[] = {
23777 (char *) "val", NULL
23778 };
23779
23780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23781 {
23782 arg1 = (long)(SWIG_As_long(obj0));
23783 if (SWIG_arg_fail(1)) SWIG_fail;
23784 }
23785 {
23786 PyThreadState* __tstate = wxPyBeginAllowThreads();
23787 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23788
23789 wxPyEndAllowThreads(__tstate);
23790 if (PyErr_Occurred()) SWIG_fail;
23791 }
23792 Py_INCREF(Py_None); resultobj = Py_None;
23793 return resultobj;
23794 fail:
23795 return NULL;
23796 }
23797
23798
23799 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23800 PyObject *resultobj;
23801 long arg1 ;
23802 PyObject * obj0 = 0 ;
23803 char *kwnames[] = {
23804 (char *) "val", NULL
23805 };
23806
23807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23808 {
23809 arg1 = (long)(SWIG_As_long(obj0));
23810 if (SWIG_arg_fail(1)) SWIG_fail;
23811 }
23812 {
23813 PyThreadState* __tstate = wxPyBeginAllowThreads();
23814 wxPyApp::SetMacExitMenuItemId(arg1);
23815
23816 wxPyEndAllowThreads(__tstate);
23817 if (PyErr_Occurred()) SWIG_fail;
23818 }
23819 Py_INCREF(Py_None); resultobj = Py_None;
23820 return resultobj;
23821 fail:
23822 return NULL;
23823 }
23824
23825
23826 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23827 PyObject *resultobj;
23828 wxString *arg1 = 0 ;
23829 bool temp1 = false ;
23830 PyObject * obj0 = 0 ;
23831 char *kwnames[] = {
23832 (char *) "val", NULL
23833 };
23834
23835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23836 {
23837 arg1 = wxString_in_helper(obj0);
23838 if (arg1 == NULL) SWIG_fail;
23839 temp1 = true;
23840 }
23841 {
23842 PyThreadState* __tstate = wxPyBeginAllowThreads();
23843 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23844
23845 wxPyEndAllowThreads(__tstate);
23846 if (PyErr_Occurred()) SWIG_fail;
23847 }
23848 Py_INCREF(Py_None); resultobj = Py_None;
23849 {
23850 if (temp1)
23851 delete arg1;
23852 }
23853 return resultobj;
23854 fail:
23855 {
23856 if (temp1)
23857 delete arg1;
23858 }
23859 return NULL;
23860 }
23861
23862
23863 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23864 PyObject *resultobj;
23865 wxPyApp *arg1 = (wxPyApp *) 0 ;
23866 PyObject * obj0 = 0 ;
23867 char *kwnames[] = {
23868 (char *) "self", NULL
23869 };
23870
23871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23873 if (SWIG_arg_fail(1)) SWIG_fail;
23874 {
23875 PyThreadState* __tstate = wxPyBeginAllowThreads();
23876 (arg1)->_BootstrapApp();
23877
23878 wxPyEndAllowThreads(__tstate);
23879 if (PyErr_Occurred()) SWIG_fail;
23880 }
23881 Py_INCREF(Py_None); resultobj = Py_None;
23882 return resultobj;
23883 fail:
23884 return NULL;
23885 }
23886
23887
23888 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23889 PyObject *resultobj;
23890 int result;
23891 char *kwnames[] = {
23892 NULL
23893 };
23894
23895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23896 {
23897 PyThreadState* __tstate = wxPyBeginAllowThreads();
23898 result = (int)PyApp_GetComCtl32Version();
23899
23900 wxPyEndAllowThreads(__tstate);
23901 if (PyErr_Occurred()) SWIG_fail;
23902 }
23903 {
23904 resultobj = SWIG_From_int((int)(result));
23905 }
23906 return resultobj;
23907 fail:
23908 return NULL;
23909 }
23910
23911
23912 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23913 PyObject *obj;
23914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23915 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23916 Py_INCREF(obj);
23917 return Py_BuildValue((char *)"");
23918 }
23919 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23920 PyObject *resultobj;
23921 char *kwnames[] = {
23922 NULL
23923 };
23924
23925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23926 {
23927 PyThreadState* __tstate = wxPyBeginAllowThreads();
23928 wxExit();
23929
23930 wxPyEndAllowThreads(__tstate);
23931 if (PyErr_Occurred()) SWIG_fail;
23932 }
23933 Py_INCREF(Py_None); resultobj = Py_None;
23934 return resultobj;
23935 fail:
23936 return NULL;
23937 }
23938
23939
23940 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23941 PyObject *resultobj;
23942 bool result;
23943 char *kwnames[] = {
23944 NULL
23945 };
23946
23947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23948 {
23949 PyThreadState* __tstate = wxPyBeginAllowThreads();
23950 result = (bool)wxYield();
23951
23952 wxPyEndAllowThreads(__tstate);
23953 if (PyErr_Occurred()) SWIG_fail;
23954 }
23955 {
23956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23957 }
23958 return resultobj;
23959 fail:
23960 return NULL;
23961 }
23962
23963
23964 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23965 PyObject *resultobj;
23966 bool result;
23967 char *kwnames[] = {
23968 NULL
23969 };
23970
23971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23972 {
23973 PyThreadState* __tstate = wxPyBeginAllowThreads();
23974 result = (bool)wxYieldIfNeeded();
23975
23976 wxPyEndAllowThreads(__tstate);
23977 if (PyErr_Occurred()) SWIG_fail;
23978 }
23979 {
23980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23981 }
23982 return resultobj;
23983 fail:
23984 return NULL;
23985 }
23986
23987
23988 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23989 PyObject *resultobj;
23990 wxWindow *arg1 = (wxWindow *) NULL ;
23991 bool arg2 = (bool) false ;
23992 bool result;
23993 PyObject * obj0 = 0 ;
23994 PyObject * obj1 = 0 ;
23995 char *kwnames[] = {
23996 (char *) "win",(char *) "onlyIfNeeded", NULL
23997 };
23998
23999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24000 if (obj0) {
24001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24002 if (SWIG_arg_fail(1)) SWIG_fail;
24003 }
24004 if (obj1) {
24005 {
24006 arg2 = (bool)(SWIG_As_bool(obj1));
24007 if (SWIG_arg_fail(2)) SWIG_fail;
24008 }
24009 }
24010 {
24011 PyThreadState* __tstate = wxPyBeginAllowThreads();
24012 result = (bool)wxSafeYield(arg1,arg2);
24013
24014 wxPyEndAllowThreads(__tstate);
24015 if (PyErr_Occurred()) SWIG_fail;
24016 }
24017 {
24018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24019 }
24020 return resultobj;
24021 fail:
24022 return NULL;
24023 }
24024
24025
24026 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24027 PyObject *resultobj;
24028 char *kwnames[] = {
24029 NULL
24030 };
24031
24032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24033 {
24034 PyThreadState* __tstate = wxPyBeginAllowThreads();
24035 wxWakeUpIdle();
24036
24037 wxPyEndAllowThreads(__tstate);
24038 if (PyErr_Occurred()) SWIG_fail;
24039 }
24040 Py_INCREF(Py_None); resultobj = Py_None;
24041 return resultobj;
24042 fail:
24043 return NULL;
24044 }
24045
24046
24047 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24048 PyObject *resultobj;
24049 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24050 wxEvent *arg2 = 0 ;
24051 PyObject * obj0 = 0 ;
24052 PyObject * obj1 = 0 ;
24053 char *kwnames[] = {
24054 (char *) "dest",(char *) "event", NULL
24055 };
24056
24057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24059 if (SWIG_arg_fail(1)) SWIG_fail;
24060 {
24061 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24062 if (SWIG_arg_fail(2)) SWIG_fail;
24063 if (arg2 == NULL) {
24064 SWIG_null_ref("wxEvent");
24065 }
24066 if (SWIG_arg_fail(2)) SWIG_fail;
24067 }
24068 {
24069 PyThreadState* __tstate = wxPyBeginAllowThreads();
24070 wxPostEvent(arg1,*arg2);
24071
24072 wxPyEndAllowThreads(__tstate);
24073 if (PyErr_Occurred()) SWIG_fail;
24074 }
24075 Py_INCREF(Py_None); resultobj = Py_None;
24076 return resultobj;
24077 fail:
24078 return NULL;
24079 }
24080
24081
24082 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24083 PyObject *resultobj;
24084 char *kwnames[] = {
24085 NULL
24086 };
24087
24088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24089 {
24090 PyThreadState* __tstate = wxPyBeginAllowThreads();
24091 wxApp_CleanUp();
24092
24093 wxPyEndAllowThreads(__tstate);
24094 if (PyErr_Occurred()) SWIG_fail;
24095 }
24096 Py_INCREF(Py_None); resultobj = Py_None;
24097 return resultobj;
24098 fail:
24099 return NULL;
24100 }
24101
24102
24103 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24104 PyObject *resultobj;
24105 wxPyApp *result;
24106 char *kwnames[] = {
24107 NULL
24108 };
24109
24110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24111 {
24112 PyThreadState* __tstate = wxPyBeginAllowThreads();
24113 result = (wxPyApp *)wxPyGetApp();
24114
24115 wxPyEndAllowThreads(__tstate);
24116 if (PyErr_Occurred()) SWIG_fail;
24117 }
24118 {
24119 resultobj = wxPyMake_wxObject(result, 0);
24120 }
24121 return resultobj;
24122 fail:
24123 return NULL;
24124 }
24125
24126
24127 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24128 PyObject *resultobj;
24129 char *arg1 = (char *) 0 ;
24130 PyObject * obj0 = 0 ;
24131 char *kwnames[] = {
24132 (char *) "encoding", NULL
24133 };
24134
24135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24136 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24137 SWIG_arg_fail(1);SWIG_fail;
24138 }
24139 {
24140 PyThreadState* __tstate = wxPyBeginAllowThreads();
24141 wxSetDefaultPyEncoding((char const *)arg1);
24142
24143 wxPyEndAllowThreads(__tstate);
24144 if (PyErr_Occurred()) SWIG_fail;
24145 }
24146 Py_INCREF(Py_None); resultobj = Py_None;
24147 return resultobj;
24148 fail:
24149 return NULL;
24150 }
24151
24152
24153 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24154 PyObject *resultobj;
24155 char *result;
24156 char *kwnames[] = {
24157 NULL
24158 };
24159
24160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24161 {
24162 PyThreadState* __tstate = wxPyBeginAllowThreads();
24163 result = (char *)wxGetDefaultPyEncoding();
24164
24165 wxPyEndAllowThreads(__tstate);
24166 if (PyErr_Occurred()) SWIG_fail;
24167 }
24168 resultobj = SWIG_FromCharPtr(result);
24169 return resultobj;
24170 fail:
24171 return NULL;
24172 }
24173
24174
24175 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24176 PyObject *resultobj;
24177 wxEventLoop *result;
24178 char *kwnames[] = {
24179 NULL
24180 };
24181
24182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24183 {
24184 PyThreadState* __tstate = wxPyBeginAllowThreads();
24185 result = (wxEventLoop *)new wxEventLoop();
24186
24187 wxPyEndAllowThreads(__tstate);
24188 if (PyErr_Occurred()) SWIG_fail;
24189 }
24190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24191 return resultobj;
24192 fail:
24193 return NULL;
24194 }
24195
24196
24197 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24198 PyObject *resultobj;
24199 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24200 PyObject * obj0 = 0 ;
24201 char *kwnames[] = {
24202 (char *) "self", NULL
24203 };
24204
24205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24207 if (SWIG_arg_fail(1)) SWIG_fail;
24208 {
24209 PyThreadState* __tstate = wxPyBeginAllowThreads();
24210 delete arg1;
24211
24212 wxPyEndAllowThreads(__tstate);
24213 if (PyErr_Occurred()) SWIG_fail;
24214 }
24215 Py_INCREF(Py_None); resultobj = Py_None;
24216 return resultobj;
24217 fail:
24218 return NULL;
24219 }
24220
24221
24222 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24223 PyObject *resultobj;
24224 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24225 int result;
24226 PyObject * obj0 = 0 ;
24227 char *kwnames[] = {
24228 (char *) "self", NULL
24229 };
24230
24231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24233 if (SWIG_arg_fail(1)) SWIG_fail;
24234 {
24235 PyThreadState* __tstate = wxPyBeginAllowThreads();
24236 result = (int)(arg1)->Run();
24237
24238 wxPyEndAllowThreads(__tstate);
24239 if (PyErr_Occurred()) SWIG_fail;
24240 }
24241 {
24242 resultobj = SWIG_From_int((int)(result));
24243 }
24244 return resultobj;
24245 fail:
24246 return NULL;
24247 }
24248
24249
24250 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24251 PyObject *resultobj;
24252 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24253 int arg2 = (int) 0 ;
24254 PyObject * obj0 = 0 ;
24255 PyObject * obj1 = 0 ;
24256 char *kwnames[] = {
24257 (char *) "self",(char *) "rc", NULL
24258 };
24259
24260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24262 if (SWIG_arg_fail(1)) SWIG_fail;
24263 if (obj1) {
24264 {
24265 arg2 = (int)(SWIG_As_int(obj1));
24266 if (SWIG_arg_fail(2)) SWIG_fail;
24267 }
24268 }
24269 {
24270 PyThreadState* __tstate = wxPyBeginAllowThreads();
24271 (arg1)->Exit(arg2);
24272
24273 wxPyEndAllowThreads(__tstate);
24274 if (PyErr_Occurred()) SWIG_fail;
24275 }
24276 Py_INCREF(Py_None); resultobj = Py_None;
24277 return resultobj;
24278 fail:
24279 return NULL;
24280 }
24281
24282
24283 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24284 PyObject *resultobj;
24285 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24286 bool result;
24287 PyObject * obj0 = 0 ;
24288 char *kwnames[] = {
24289 (char *) "self", NULL
24290 };
24291
24292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24294 if (SWIG_arg_fail(1)) SWIG_fail;
24295 {
24296 PyThreadState* __tstate = wxPyBeginAllowThreads();
24297 result = (bool)((wxEventLoop const *)arg1)->Pending();
24298
24299 wxPyEndAllowThreads(__tstate);
24300 if (PyErr_Occurred()) SWIG_fail;
24301 }
24302 {
24303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24304 }
24305 return resultobj;
24306 fail:
24307 return NULL;
24308 }
24309
24310
24311 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24312 PyObject *resultobj;
24313 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24314 bool result;
24315 PyObject * obj0 = 0 ;
24316 char *kwnames[] = {
24317 (char *) "self", NULL
24318 };
24319
24320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24322 if (SWIG_arg_fail(1)) SWIG_fail;
24323 {
24324 PyThreadState* __tstate = wxPyBeginAllowThreads();
24325 result = (bool)(arg1)->Dispatch();
24326
24327 wxPyEndAllowThreads(__tstate);
24328 if (PyErr_Occurred()) SWIG_fail;
24329 }
24330 {
24331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24332 }
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24340 PyObject *resultobj;
24341 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24342 bool result;
24343 PyObject * obj0 = 0 ;
24344 char *kwnames[] = {
24345 (char *) "self", NULL
24346 };
24347
24348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24350 if (SWIG_arg_fail(1)) SWIG_fail;
24351 {
24352 PyThreadState* __tstate = wxPyBeginAllowThreads();
24353 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24354
24355 wxPyEndAllowThreads(__tstate);
24356 if (PyErr_Occurred()) SWIG_fail;
24357 }
24358 {
24359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24360 }
24361 return resultobj;
24362 fail:
24363 return NULL;
24364 }
24365
24366
24367 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24368 PyObject *resultobj;
24369 wxEventLoop *result;
24370 char *kwnames[] = {
24371 NULL
24372 };
24373
24374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24375 {
24376 PyThreadState* __tstate = wxPyBeginAllowThreads();
24377 result = (wxEventLoop *)wxEventLoop::GetActive();
24378
24379 wxPyEndAllowThreads(__tstate);
24380 if (PyErr_Occurred()) SWIG_fail;
24381 }
24382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24383 return resultobj;
24384 fail:
24385 return NULL;
24386 }
24387
24388
24389 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24390 PyObject *resultobj;
24391 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24392 PyObject * obj0 = 0 ;
24393 char *kwnames[] = {
24394 (char *) "loop", NULL
24395 };
24396
24397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24399 if (SWIG_arg_fail(1)) SWIG_fail;
24400 {
24401 PyThreadState* __tstate = wxPyBeginAllowThreads();
24402 wxEventLoop::SetActive(arg1);
24403
24404 wxPyEndAllowThreads(__tstate);
24405 if (PyErr_Occurred()) SWIG_fail;
24406 }
24407 Py_INCREF(Py_None); resultobj = Py_None;
24408 return resultobj;
24409 fail:
24410 return NULL;
24411 }
24412
24413
24414 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24415 PyObject *obj;
24416 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24417 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24418 Py_INCREF(obj);
24419 return Py_BuildValue((char *)"");
24420 }
24421 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24422 PyObject *resultobj;
24423 int arg1 = (int) 0 ;
24424 int arg2 = (int) 0 ;
24425 int arg3 = (int) 0 ;
24426 wxAcceleratorEntry *result;
24427 PyObject * obj0 = 0 ;
24428 PyObject * obj1 = 0 ;
24429 PyObject * obj2 = 0 ;
24430 char *kwnames[] = {
24431 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24432 };
24433
24434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24435 if (obj0) {
24436 {
24437 arg1 = (int)(SWIG_As_int(obj0));
24438 if (SWIG_arg_fail(1)) SWIG_fail;
24439 }
24440 }
24441 if (obj1) {
24442 {
24443 arg2 = (int)(SWIG_As_int(obj1));
24444 if (SWIG_arg_fail(2)) SWIG_fail;
24445 }
24446 }
24447 if (obj2) {
24448 {
24449 arg3 = (int)(SWIG_As_int(obj2));
24450 if (SWIG_arg_fail(3)) SWIG_fail;
24451 }
24452 }
24453 {
24454 PyThreadState* __tstate = wxPyBeginAllowThreads();
24455 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24456
24457 wxPyEndAllowThreads(__tstate);
24458 if (PyErr_Occurred()) SWIG_fail;
24459 }
24460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24461 return resultobj;
24462 fail:
24463 return NULL;
24464 }
24465
24466
24467 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24468 PyObject *resultobj;
24469 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24470 PyObject * obj0 = 0 ;
24471 char *kwnames[] = {
24472 (char *) "self", NULL
24473 };
24474
24475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24477 if (SWIG_arg_fail(1)) SWIG_fail;
24478 {
24479 PyThreadState* __tstate = wxPyBeginAllowThreads();
24480 delete arg1;
24481
24482 wxPyEndAllowThreads(__tstate);
24483 if (PyErr_Occurred()) SWIG_fail;
24484 }
24485 Py_INCREF(Py_None); resultobj = Py_None;
24486 return resultobj;
24487 fail:
24488 return NULL;
24489 }
24490
24491
24492 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24493 PyObject *resultobj;
24494 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24495 int arg2 ;
24496 int arg3 ;
24497 int arg4 ;
24498 PyObject * obj0 = 0 ;
24499 PyObject * obj1 = 0 ;
24500 PyObject * obj2 = 0 ;
24501 PyObject * obj3 = 0 ;
24502 char *kwnames[] = {
24503 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24504 };
24505
24506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24508 if (SWIG_arg_fail(1)) SWIG_fail;
24509 {
24510 arg2 = (int)(SWIG_As_int(obj1));
24511 if (SWIG_arg_fail(2)) SWIG_fail;
24512 }
24513 {
24514 arg3 = (int)(SWIG_As_int(obj2));
24515 if (SWIG_arg_fail(3)) SWIG_fail;
24516 }
24517 {
24518 arg4 = (int)(SWIG_As_int(obj3));
24519 if (SWIG_arg_fail(4)) SWIG_fail;
24520 }
24521 {
24522 PyThreadState* __tstate = wxPyBeginAllowThreads();
24523 (arg1)->Set(arg2,arg3,arg4);
24524
24525 wxPyEndAllowThreads(__tstate);
24526 if (PyErr_Occurred()) SWIG_fail;
24527 }
24528 Py_INCREF(Py_None); resultobj = Py_None;
24529 return resultobj;
24530 fail:
24531 return NULL;
24532 }
24533
24534
24535 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24536 PyObject *resultobj;
24537 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24538 int result;
24539 PyObject * obj0 = 0 ;
24540 char *kwnames[] = {
24541 (char *) "self", NULL
24542 };
24543
24544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24546 if (SWIG_arg_fail(1)) SWIG_fail;
24547 {
24548 PyThreadState* __tstate = wxPyBeginAllowThreads();
24549 result = (int)(arg1)->GetFlags();
24550
24551 wxPyEndAllowThreads(__tstate);
24552 if (PyErr_Occurred()) SWIG_fail;
24553 }
24554 {
24555 resultobj = SWIG_From_int((int)(result));
24556 }
24557 return resultobj;
24558 fail:
24559 return NULL;
24560 }
24561
24562
24563 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24564 PyObject *resultobj;
24565 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24566 int result;
24567 PyObject * obj0 = 0 ;
24568 char *kwnames[] = {
24569 (char *) "self", NULL
24570 };
24571
24572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24574 if (SWIG_arg_fail(1)) SWIG_fail;
24575 {
24576 PyThreadState* __tstate = wxPyBeginAllowThreads();
24577 result = (int)(arg1)->GetKeyCode();
24578
24579 wxPyEndAllowThreads(__tstate);
24580 if (PyErr_Occurred()) SWIG_fail;
24581 }
24582 {
24583 resultobj = SWIG_From_int((int)(result));
24584 }
24585 return resultobj;
24586 fail:
24587 return NULL;
24588 }
24589
24590
24591 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24592 PyObject *resultobj;
24593 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24594 int result;
24595 PyObject * obj0 = 0 ;
24596 char *kwnames[] = {
24597 (char *) "self", NULL
24598 };
24599
24600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24602 if (SWIG_arg_fail(1)) SWIG_fail;
24603 {
24604 PyThreadState* __tstate = wxPyBeginAllowThreads();
24605 result = (int)(arg1)->GetCommand();
24606
24607 wxPyEndAllowThreads(__tstate);
24608 if (PyErr_Occurred()) SWIG_fail;
24609 }
24610 {
24611 resultobj = SWIG_From_int((int)(result));
24612 }
24613 return resultobj;
24614 fail:
24615 return NULL;
24616 }
24617
24618
24619 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24620 PyObject *obj;
24621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24622 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24623 Py_INCREF(obj);
24624 return Py_BuildValue((char *)"");
24625 }
24626 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24627 PyObject *resultobj;
24628 int arg1 ;
24629 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24630 wxAcceleratorTable *result;
24631 PyObject * obj0 = 0 ;
24632 char *kwnames[] = {
24633 (char *) "n", NULL
24634 };
24635
24636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24637 {
24638 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24639 if (arg2) arg1 = PyList_Size(obj0);
24640 else arg1 = 0;
24641 }
24642 {
24643 PyThreadState* __tstate = wxPyBeginAllowThreads();
24644 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24645
24646 wxPyEndAllowThreads(__tstate);
24647 if (PyErr_Occurred()) SWIG_fail;
24648 }
24649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24650 {
24651 delete [] arg2;
24652 }
24653 return resultobj;
24654 fail:
24655 {
24656 delete [] arg2;
24657 }
24658 return NULL;
24659 }
24660
24661
24662 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24663 PyObject *resultobj;
24664 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24665 PyObject * obj0 = 0 ;
24666 char *kwnames[] = {
24667 (char *) "self", NULL
24668 };
24669
24670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24672 if (SWIG_arg_fail(1)) SWIG_fail;
24673 {
24674 PyThreadState* __tstate = wxPyBeginAllowThreads();
24675 delete arg1;
24676
24677 wxPyEndAllowThreads(__tstate);
24678 if (PyErr_Occurred()) SWIG_fail;
24679 }
24680 Py_INCREF(Py_None); resultobj = Py_None;
24681 return resultobj;
24682 fail:
24683 return NULL;
24684 }
24685
24686
24687 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24688 PyObject *resultobj;
24689 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24690 bool result;
24691 PyObject * obj0 = 0 ;
24692 char *kwnames[] = {
24693 (char *) "self", NULL
24694 };
24695
24696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24698 if (SWIG_arg_fail(1)) SWIG_fail;
24699 {
24700 PyThreadState* __tstate = wxPyBeginAllowThreads();
24701 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24702
24703 wxPyEndAllowThreads(__tstate);
24704 if (PyErr_Occurred()) SWIG_fail;
24705 }
24706 {
24707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24708 }
24709 return resultobj;
24710 fail:
24711 return NULL;
24712 }
24713
24714
24715 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24716 PyObject *obj;
24717 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24718 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24719 Py_INCREF(obj);
24720 return Py_BuildValue((char *)"");
24721 }
24722 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24723 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24724 return 1;
24725 }
24726
24727
24728 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24729 PyObject *pyobj;
24730
24731 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24732 return pyobj;
24733 }
24734
24735
24736 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24737 PyObject *resultobj;
24738 wxString *arg1 = 0 ;
24739 wxAcceleratorEntry *result;
24740 bool temp1 = false ;
24741 PyObject * obj0 = 0 ;
24742 char *kwnames[] = {
24743 (char *) "label", NULL
24744 };
24745
24746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24747 {
24748 arg1 = wxString_in_helper(obj0);
24749 if (arg1 == NULL) SWIG_fail;
24750 temp1 = true;
24751 }
24752 {
24753 PyThreadState* __tstate = wxPyBeginAllowThreads();
24754 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24755
24756 wxPyEndAllowThreads(__tstate);
24757 if (PyErr_Occurred()) SWIG_fail;
24758 }
24759 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24760 {
24761 if (temp1)
24762 delete arg1;
24763 }
24764 return resultobj;
24765 fail:
24766 {
24767 if (temp1)
24768 delete arg1;
24769 }
24770 return NULL;
24771 }
24772
24773
24774 static int _wrap_PanelNameStr_set(PyObject *) {
24775 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24776 return 1;
24777 }
24778
24779
24780 static PyObject *_wrap_PanelNameStr_get(void) {
24781 PyObject *pyobj;
24782
24783 {
24784 #if wxUSE_UNICODE
24785 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24786 #else
24787 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24788 #endif
24789 }
24790 return pyobj;
24791 }
24792
24793
24794 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24795 PyObject *resultobj;
24796 wxVisualAttributes *result;
24797 char *kwnames[] = {
24798 NULL
24799 };
24800
24801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24802 {
24803 PyThreadState* __tstate = wxPyBeginAllowThreads();
24804 result = (wxVisualAttributes *)new_wxVisualAttributes();
24805
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24810 return resultobj;
24811 fail:
24812 return NULL;
24813 }
24814
24815
24816 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24817 PyObject *resultobj;
24818 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24819 PyObject * obj0 = 0 ;
24820 char *kwnames[] = {
24821 (char *) "self", NULL
24822 };
24823
24824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24826 if (SWIG_arg_fail(1)) SWIG_fail;
24827 {
24828 PyThreadState* __tstate = wxPyBeginAllowThreads();
24829 delete_wxVisualAttributes(arg1);
24830
24831 wxPyEndAllowThreads(__tstate);
24832 if (PyErr_Occurred()) SWIG_fail;
24833 }
24834 Py_INCREF(Py_None); resultobj = Py_None;
24835 return resultobj;
24836 fail:
24837 return NULL;
24838 }
24839
24840
24841 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24842 PyObject *resultobj;
24843 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24844 wxFont *arg2 = (wxFont *) 0 ;
24845 PyObject * obj0 = 0 ;
24846 PyObject * obj1 = 0 ;
24847 char *kwnames[] = {
24848 (char *) "self",(char *) "font", NULL
24849 };
24850
24851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24853 if (SWIG_arg_fail(1)) SWIG_fail;
24854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24855 if (SWIG_arg_fail(2)) SWIG_fail;
24856 if (arg1) (arg1)->font = *arg2;
24857
24858 Py_INCREF(Py_None); resultobj = Py_None;
24859 return resultobj;
24860 fail:
24861 return NULL;
24862 }
24863
24864
24865 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24866 PyObject *resultobj;
24867 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24868 wxFont *result;
24869 PyObject * obj0 = 0 ;
24870 char *kwnames[] = {
24871 (char *) "self", NULL
24872 };
24873
24874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24876 if (SWIG_arg_fail(1)) SWIG_fail;
24877 result = (wxFont *)& ((arg1)->font);
24878
24879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24880 return resultobj;
24881 fail:
24882 return NULL;
24883 }
24884
24885
24886 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24887 PyObject *resultobj;
24888 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24889 wxColour *arg2 = (wxColour *) 0 ;
24890 PyObject * obj0 = 0 ;
24891 PyObject * obj1 = 0 ;
24892 char *kwnames[] = {
24893 (char *) "self",(char *) "colFg", NULL
24894 };
24895
24896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24898 if (SWIG_arg_fail(1)) SWIG_fail;
24899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24900 if (SWIG_arg_fail(2)) SWIG_fail;
24901 if (arg1) (arg1)->colFg = *arg2;
24902
24903 Py_INCREF(Py_None); resultobj = Py_None;
24904 return resultobj;
24905 fail:
24906 return NULL;
24907 }
24908
24909
24910 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24911 PyObject *resultobj;
24912 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24913 wxColour *result;
24914 PyObject * obj0 = 0 ;
24915 char *kwnames[] = {
24916 (char *) "self", NULL
24917 };
24918
24919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24921 if (SWIG_arg_fail(1)) SWIG_fail;
24922 result = (wxColour *)& ((arg1)->colFg);
24923
24924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24925 return resultobj;
24926 fail:
24927 return NULL;
24928 }
24929
24930
24931 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24932 PyObject *resultobj;
24933 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24934 wxColour *arg2 = (wxColour *) 0 ;
24935 PyObject * obj0 = 0 ;
24936 PyObject * obj1 = 0 ;
24937 char *kwnames[] = {
24938 (char *) "self",(char *) "colBg", NULL
24939 };
24940
24941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24943 if (SWIG_arg_fail(1)) SWIG_fail;
24944 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24945 if (SWIG_arg_fail(2)) SWIG_fail;
24946 if (arg1) (arg1)->colBg = *arg2;
24947
24948 Py_INCREF(Py_None); resultobj = Py_None;
24949 return resultobj;
24950 fail:
24951 return NULL;
24952 }
24953
24954
24955 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24956 PyObject *resultobj;
24957 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24958 wxColour *result;
24959 PyObject * obj0 = 0 ;
24960 char *kwnames[] = {
24961 (char *) "self", NULL
24962 };
24963
24964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24966 if (SWIG_arg_fail(1)) SWIG_fail;
24967 result = (wxColour *)& ((arg1)->colBg);
24968
24969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24970 return resultobj;
24971 fail:
24972 return NULL;
24973 }
24974
24975
24976 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24977 PyObject *obj;
24978 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24979 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24980 Py_INCREF(obj);
24981 return Py_BuildValue((char *)"");
24982 }
24983 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24984 PyObject *resultobj;
24985 wxWindow *arg1 = (wxWindow *) 0 ;
24986 int arg2 = (int) (int)-1 ;
24987 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24988 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24989 wxSize const &arg4_defvalue = wxDefaultSize ;
24990 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24991 long arg5 = (long) 0 ;
24992 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24993 wxString *arg6 = (wxString *) &arg6_defvalue ;
24994 wxWindow *result;
24995 wxPoint temp3 ;
24996 wxSize temp4 ;
24997 bool temp6 = false ;
24998 PyObject * obj0 = 0 ;
24999 PyObject * obj1 = 0 ;
25000 PyObject * obj2 = 0 ;
25001 PyObject * obj3 = 0 ;
25002 PyObject * obj4 = 0 ;
25003 PyObject * obj5 = 0 ;
25004 char *kwnames[] = {
25005 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25006 };
25007
25008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25010 if (SWIG_arg_fail(1)) SWIG_fail;
25011 if (obj1) {
25012 {
25013 arg2 = (int const)(SWIG_As_int(obj1));
25014 if (SWIG_arg_fail(2)) SWIG_fail;
25015 }
25016 }
25017 if (obj2) {
25018 {
25019 arg3 = &temp3;
25020 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25021 }
25022 }
25023 if (obj3) {
25024 {
25025 arg4 = &temp4;
25026 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25027 }
25028 }
25029 if (obj4) {
25030 {
25031 arg5 = (long)(SWIG_As_long(obj4));
25032 if (SWIG_arg_fail(5)) SWIG_fail;
25033 }
25034 }
25035 if (obj5) {
25036 {
25037 arg6 = wxString_in_helper(obj5);
25038 if (arg6 == NULL) SWIG_fail;
25039 temp6 = true;
25040 }
25041 }
25042 {
25043 if (!wxPyCheckForApp()) SWIG_fail;
25044 PyThreadState* __tstate = wxPyBeginAllowThreads();
25045 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25046
25047 wxPyEndAllowThreads(__tstate);
25048 if (PyErr_Occurred()) SWIG_fail;
25049 }
25050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25051 {
25052 if (temp6)
25053 delete arg6;
25054 }
25055 return resultobj;
25056 fail:
25057 {
25058 if (temp6)
25059 delete arg6;
25060 }
25061 return NULL;
25062 }
25063
25064
25065 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25066 PyObject *resultobj;
25067 wxWindow *result;
25068 char *kwnames[] = {
25069 NULL
25070 };
25071
25072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25073 {
25074 if (!wxPyCheckForApp()) SWIG_fail;
25075 PyThreadState* __tstate = wxPyBeginAllowThreads();
25076 result = (wxWindow *)new wxWindow();
25077
25078 wxPyEndAllowThreads(__tstate);
25079 if (PyErr_Occurred()) SWIG_fail;
25080 }
25081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25082 return resultobj;
25083 fail:
25084 return NULL;
25085 }
25086
25087
25088 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25089 PyObject *resultobj;
25090 wxWindow *arg1 = (wxWindow *) 0 ;
25091 wxWindow *arg2 = (wxWindow *) 0 ;
25092 int arg3 = (int) (int)-1 ;
25093 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25094 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25095 wxSize const &arg5_defvalue = wxDefaultSize ;
25096 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25097 long arg6 = (long) 0 ;
25098 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25099 wxString *arg7 = (wxString *) &arg7_defvalue ;
25100 bool result;
25101 wxPoint temp4 ;
25102 wxSize temp5 ;
25103 bool temp7 = false ;
25104 PyObject * obj0 = 0 ;
25105 PyObject * obj1 = 0 ;
25106 PyObject * obj2 = 0 ;
25107 PyObject * obj3 = 0 ;
25108 PyObject * obj4 = 0 ;
25109 PyObject * obj5 = 0 ;
25110 PyObject * obj6 = 0 ;
25111 char *kwnames[] = {
25112 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25113 };
25114
25115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25117 if (SWIG_arg_fail(1)) SWIG_fail;
25118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25119 if (SWIG_arg_fail(2)) SWIG_fail;
25120 if (obj2) {
25121 {
25122 arg3 = (int const)(SWIG_As_int(obj2));
25123 if (SWIG_arg_fail(3)) SWIG_fail;
25124 }
25125 }
25126 if (obj3) {
25127 {
25128 arg4 = &temp4;
25129 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25130 }
25131 }
25132 if (obj4) {
25133 {
25134 arg5 = &temp5;
25135 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25136 }
25137 }
25138 if (obj5) {
25139 {
25140 arg6 = (long)(SWIG_As_long(obj5));
25141 if (SWIG_arg_fail(6)) SWIG_fail;
25142 }
25143 }
25144 if (obj6) {
25145 {
25146 arg7 = wxString_in_helper(obj6);
25147 if (arg7 == NULL) SWIG_fail;
25148 temp7 = true;
25149 }
25150 }
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25154
25155 wxPyEndAllowThreads(__tstate);
25156 if (PyErr_Occurred()) SWIG_fail;
25157 }
25158 {
25159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25160 }
25161 {
25162 if (temp7)
25163 delete arg7;
25164 }
25165 return resultobj;
25166 fail:
25167 {
25168 if (temp7)
25169 delete arg7;
25170 }
25171 return NULL;
25172 }
25173
25174
25175 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25176 PyObject *resultobj;
25177 wxWindow *arg1 = (wxWindow *) 0 ;
25178 bool arg2 = (bool) false ;
25179 bool result;
25180 PyObject * obj0 = 0 ;
25181 PyObject * obj1 = 0 ;
25182 char *kwnames[] = {
25183 (char *) "self",(char *) "force", NULL
25184 };
25185
25186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25188 if (SWIG_arg_fail(1)) SWIG_fail;
25189 if (obj1) {
25190 {
25191 arg2 = (bool)(SWIG_As_bool(obj1));
25192 if (SWIG_arg_fail(2)) SWIG_fail;
25193 }
25194 }
25195 {
25196 PyThreadState* __tstate = wxPyBeginAllowThreads();
25197 result = (bool)(arg1)->Close(arg2);
25198
25199 wxPyEndAllowThreads(__tstate);
25200 if (PyErr_Occurred()) SWIG_fail;
25201 }
25202 {
25203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25204 }
25205 return resultobj;
25206 fail:
25207 return NULL;
25208 }
25209
25210
25211 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25212 PyObject *resultobj;
25213 wxWindow *arg1 = (wxWindow *) 0 ;
25214 bool result;
25215 PyObject * obj0 = 0 ;
25216 char *kwnames[] = {
25217 (char *) "self", NULL
25218 };
25219
25220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25222 if (SWIG_arg_fail(1)) SWIG_fail;
25223 {
25224 PyThreadState* __tstate = wxPyBeginAllowThreads();
25225 result = (bool)(arg1)->Destroy();
25226
25227 wxPyEndAllowThreads(__tstate);
25228 if (PyErr_Occurred()) SWIG_fail;
25229 }
25230 {
25231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25232 }
25233 return resultobj;
25234 fail:
25235 return NULL;
25236 }
25237
25238
25239 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25240 PyObject *resultobj;
25241 wxWindow *arg1 = (wxWindow *) 0 ;
25242 bool result;
25243 PyObject * obj0 = 0 ;
25244 char *kwnames[] = {
25245 (char *) "self", NULL
25246 };
25247
25248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25250 if (SWIG_arg_fail(1)) SWIG_fail;
25251 {
25252 PyThreadState* __tstate = wxPyBeginAllowThreads();
25253 result = (bool)(arg1)->DestroyChildren();
25254
25255 wxPyEndAllowThreads(__tstate);
25256 if (PyErr_Occurred()) SWIG_fail;
25257 }
25258 {
25259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25260 }
25261 return resultobj;
25262 fail:
25263 return NULL;
25264 }
25265
25266
25267 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25268 PyObject *resultobj;
25269 wxWindow *arg1 = (wxWindow *) 0 ;
25270 bool result;
25271 PyObject * obj0 = 0 ;
25272 char *kwnames[] = {
25273 (char *) "self", NULL
25274 };
25275
25276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25278 if (SWIG_arg_fail(1)) SWIG_fail;
25279 {
25280 PyThreadState* __tstate = wxPyBeginAllowThreads();
25281 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25282
25283 wxPyEndAllowThreads(__tstate);
25284 if (PyErr_Occurred()) SWIG_fail;
25285 }
25286 {
25287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25288 }
25289 return resultobj;
25290 fail:
25291 return NULL;
25292 }
25293
25294
25295 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25296 PyObject *resultobj;
25297 wxWindow *arg1 = (wxWindow *) 0 ;
25298 wxString *arg2 = 0 ;
25299 bool temp2 = false ;
25300 PyObject * obj0 = 0 ;
25301 PyObject * obj1 = 0 ;
25302 char *kwnames[] = {
25303 (char *) "self",(char *) "title", NULL
25304 };
25305
25306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25308 if (SWIG_arg_fail(1)) SWIG_fail;
25309 {
25310 arg2 = wxString_in_helper(obj1);
25311 if (arg2 == NULL) SWIG_fail;
25312 temp2 = true;
25313 }
25314 {
25315 PyThreadState* __tstate = wxPyBeginAllowThreads();
25316 (arg1)->SetTitle((wxString const &)*arg2);
25317
25318 wxPyEndAllowThreads(__tstate);
25319 if (PyErr_Occurred()) SWIG_fail;
25320 }
25321 Py_INCREF(Py_None); resultobj = Py_None;
25322 {
25323 if (temp2)
25324 delete arg2;
25325 }
25326 return resultobj;
25327 fail:
25328 {
25329 if (temp2)
25330 delete arg2;
25331 }
25332 return NULL;
25333 }
25334
25335
25336 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25337 PyObject *resultobj;
25338 wxWindow *arg1 = (wxWindow *) 0 ;
25339 wxString result;
25340 PyObject * obj0 = 0 ;
25341 char *kwnames[] = {
25342 (char *) "self", NULL
25343 };
25344
25345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25347 if (SWIG_arg_fail(1)) SWIG_fail;
25348 {
25349 PyThreadState* __tstate = wxPyBeginAllowThreads();
25350 result = ((wxWindow const *)arg1)->GetTitle();
25351
25352 wxPyEndAllowThreads(__tstate);
25353 if (PyErr_Occurred()) SWIG_fail;
25354 }
25355 {
25356 #if wxUSE_UNICODE
25357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25358 #else
25359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25360 #endif
25361 }
25362 return resultobj;
25363 fail:
25364 return NULL;
25365 }
25366
25367
25368 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25369 PyObject *resultobj;
25370 wxWindow *arg1 = (wxWindow *) 0 ;
25371 wxString *arg2 = 0 ;
25372 bool temp2 = false ;
25373 PyObject * obj0 = 0 ;
25374 PyObject * obj1 = 0 ;
25375 char *kwnames[] = {
25376 (char *) "self",(char *) "label", NULL
25377 };
25378
25379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25381 if (SWIG_arg_fail(1)) SWIG_fail;
25382 {
25383 arg2 = wxString_in_helper(obj1);
25384 if (arg2 == NULL) SWIG_fail;
25385 temp2 = true;
25386 }
25387 {
25388 PyThreadState* __tstate = wxPyBeginAllowThreads();
25389 (arg1)->SetLabel((wxString const &)*arg2);
25390
25391 wxPyEndAllowThreads(__tstate);
25392 if (PyErr_Occurred()) SWIG_fail;
25393 }
25394 Py_INCREF(Py_None); resultobj = Py_None;
25395 {
25396 if (temp2)
25397 delete arg2;
25398 }
25399 return resultobj;
25400 fail:
25401 {
25402 if (temp2)
25403 delete arg2;
25404 }
25405 return NULL;
25406 }
25407
25408
25409 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25410 PyObject *resultobj;
25411 wxWindow *arg1 = (wxWindow *) 0 ;
25412 wxString result;
25413 PyObject * obj0 = 0 ;
25414 char *kwnames[] = {
25415 (char *) "self", NULL
25416 };
25417
25418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25420 if (SWIG_arg_fail(1)) SWIG_fail;
25421 {
25422 PyThreadState* __tstate = wxPyBeginAllowThreads();
25423 result = ((wxWindow const *)arg1)->GetLabel();
25424
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 {
25429 #if wxUSE_UNICODE
25430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25431 #else
25432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25433 #endif
25434 }
25435 return resultobj;
25436 fail:
25437 return NULL;
25438 }
25439
25440
25441 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25442 PyObject *resultobj;
25443 wxWindow *arg1 = (wxWindow *) 0 ;
25444 wxString *arg2 = 0 ;
25445 bool temp2 = false ;
25446 PyObject * obj0 = 0 ;
25447 PyObject * obj1 = 0 ;
25448 char *kwnames[] = {
25449 (char *) "self",(char *) "name", NULL
25450 };
25451
25452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25454 if (SWIG_arg_fail(1)) SWIG_fail;
25455 {
25456 arg2 = wxString_in_helper(obj1);
25457 if (arg2 == NULL) SWIG_fail;
25458 temp2 = true;
25459 }
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 (arg1)->SetName((wxString const &)*arg2);
25463
25464 wxPyEndAllowThreads(__tstate);
25465 if (PyErr_Occurred()) SWIG_fail;
25466 }
25467 Py_INCREF(Py_None); resultobj = Py_None;
25468 {
25469 if (temp2)
25470 delete arg2;
25471 }
25472 return resultobj;
25473 fail:
25474 {
25475 if (temp2)
25476 delete arg2;
25477 }
25478 return NULL;
25479 }
25480
25481
25482 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25483 PyObject *resultobj;
25484 wxWindow *arg1 = (wxWindow *) 0 ;
25485 wxString result;
25486 PyObject * obj0 = 0 ;
25487 char *kwnames[] = {
25488 (char *) "self", NULL
25489 };
25490
25491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25493 if (SWIG_arg_fail(1)) SWIG_fail;
25494 {
25495 PyThreadState* __tstate = wxPyBeginAllowThreads();
25496 result = ((wxWindow const *)arg1)->GetName();
25497
25498 wxPyEndAllowThreads(__tstate);
25499 if (PyErr_Occurred()) SWIG_fail;
25500 }
25501 {
25502 #if wxUSE_UNICODE
25503 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25504 #else
25505 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25506 #endif
25507 }
25508 return resultobj;
25509 fail:
25510 return NULL;
25511 }
25512
25513
25514 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25515 PyObject *resultobj;
25516 wxWindow *arg1 = (wxWindow *) 0 ;
25517 wxWindowVariant arg2 ;
25518 PyObject * obj0 = 0 ;
25519 PyObject * obj1 = 0 ;
25520 char *kwnames[] = {
25521 (char *) "self",(char *) "variant", NULL
25522 };
25523
25524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25526 if (SWIG_arg_fail(1)) SWIG_fail;
25527 {
25528 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25529 if (SWIG_arg_fail(2)) SWIG_fail;
25530 }
25531 {
25532 PyThreadState* __tstate = wxPyBeginAllowThreads();
25533 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25534
25535 wxPyEndAllowThreads(__tstate);
25536 if (PyErr_Occurred()) SWIG_fail;
25537 }
25538 Py_INCREF(Py_None); resultobj = Py_None;
25539 return resultobj;
25540 fail:
25541 return NULL;
25542 }
25543
25544
25545 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25546 PyObject *resultobj;
25547 wxWindow *arg1 = (wxWindow *) 0 ;
25548 wxWindowVariant result;
25549 PyObject * obj0 = 0 ;
25550 char *kwnames[] = {
25551 (char *) "self", NULL
25552 };
25553
25554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25556 if (SWIG_arg_fail(1)) SWIG_fail;
25557 {
25558 PyThreadState* __tstate = wxPyBeginAllowThreads();
25559 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25560
25561 wxPyEndAllowThreads(__tstate);
25562 if (PyErr_Occurred()) SWIG_fail;
25563 }
25564 resultobj = SWIG_From_int((result));
25565 return resultobj;
25566 fail:
25567 return NULL;
25568 }
25569
25570
25571 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25572 PyObject *resultobj;
25573 wxWindow *arg1 = (wxWindow *) 0 ;
25574 int arg2 ;
25575 PyObject * obj0 = 0 ;
25576 PyObject * obj1 = 0 ;
25577 char *kwnames[] = {
25578 (char *) "self",(char *) "winid", NULL
25579 };
25580
25581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25583 if (SWIG_arg_fail(1)) SWIG_fail;
25584 {
25585 arg2 = (int)(SWIG_As_int(obj1));
25586 if (SWIG_arg_fail(2)) SWIG_fail;
25587 }
25588 {
25589 PyThreadState* __tstate = wxPyBeginAllowThreads();
25590 (arg1)->SetId(arg2);
25591
25592 wxPyEndAllowThreads(__tstate);
25593 if (PyErr_Occurred()) SWIG_fail;
25594 }
25595 Py_INCREF(Py_None); resultobj = Py_None;
25596 return resultobj;
25597 fail:
25598 return NULL;
25599 }
25600
25601
25602 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25603 PyObject *resultobj;
25604 wxWindow *arg1 = (wxWindow *) 0 ;
25605 int result;
25606 PyObject * obj0 = 0 ;
25607 char *kwnames[] = {
25608 (char *) "self", NULL
25609 };
25610
25611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25613 if (SWIG_arg_fail(1)) SWIG_fail;
25614 {
25615 PyThreadState* __tstate = wxPyBeginAllowThreads();
25616 result = (int)((wxWindow const *)arg1)->GetId();
25617
25618 wxPyEndAllowThreads(__tstate);
25619 if (PyErr_Occurred()) SWIG_fail;
25620 }
25621 {
25622 resultobj = SWIG_From_int((int)(result));
25623 }
25624 return resultobj;
25625 fail:
25626 return NULL;
25627 }
25628
25629
25630 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25631 PyObject *resultobj;
25632 int result;
25633 char *kwnames[] = {
25634 NULL
25635 };
25636
25637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25638 {
25639 PyThreadState* __tstate = wxPyBeginAllowThreads();
25640 result = (int)wxWindow::NewControlId();
25641
25642 wxPyEndAllowThreads(__tstate);
25643 if (PyErr_Occurred()) SWIG_fail;
25644 }
25645 {
25646 resultobj = SWIG_From_int((int)(result));
25647 }
25648 return resultobj;
25649 fail:
25650 return NULL;
25651 }
25652
25653
25654 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25655 PyObject *resultobj;
25656 int arg1 ;
25657 int result;
25658 PyObject * obj0 = 0 ;
25659 char *kwnames[] = {
25660 (char *) "winid", NULL
25661 };
25662
25663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25664 {
25665 arg1 = (int)(SWIG_As_int(obj0));
25666 if (SWIG_arg_fail(1)) SWIG_fail;
25667 }
25668 {
25669 PyThreadState* __tstate = wxPyBeginAllowThreads();
25670 result = (int)wxWindow::NextControlId(arg1);
25671
25672 wxPyEndAllowThreads(__tstate);
25673 if (PyErr_Occurred()) SWIG_fail;
25674 }
25675 {
25676 resultobj = SWIG_From_int((int)(result));
25677 }
25678 return resultobj;
25679 fail:
25680 return NULL;
25681 }
25682
25683
25684 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25685 PyObject *resultobj;
25686 int arg1 ;
25687 int result;
25688 PyObject * obj0 = 0 ;
25689 char *kwnames[] = {
25690 (char *) "winid", NULL
25691 };
25692
25693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25694 {
25695 arg1 = (int)(SWIG_As_int(obj0));
25696 if (SWIG_arg_fail(1)) SWIG_fail;
25697 }
25698 {
25699 PyThreadState* __tstate = wxPyBeginAllowThreads();
25700 result = (int)wxWindow::PrevControlId(arg1);
25701
25702 wxPyEndAllowThreads(__tstate);
25703 if (PyErr_Occurred()) SWIG_fail;
25704 }
25705 {
25706 resultobj = SWIG_From_int((int)(result));
25707 }
25708 return resultobj;
25709 fail:
25710 return NULL;
25711 }
25712
25713
25714 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25715 PyObject *resultobj;
25716 wxWindow *arg1 = (wxWindow *) 0 ;
25717 wxSize *arg2 = 0 ;
25718 wxSize temp2 ;
25719 PyObject * obj0 = 0 ;
25720 PyObject * obj1 = 0 ;
25721 char *kwnames[] = {
25722 (char *) "self",(char *) "size", NULL
25723 };
25724
25725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25727 if (SWIG_arg_fail(1)) SWIG_fail;
25728 {
25729 arg2 = &temp2;
25730 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25731 }
25732 {
25733 PyThreadState* __tstate = wxPyBeginAllowThreads();
25734 (arg1)->SetSize((wxSize const &)*arg2);
25735
25736 wxPyEndAllowThreads(__tstate);
25737 if (PyErr_Occurred()) SWIG_fail;
25738 }
25739 Py_INCREF(Py_None); resultobj = Py_None;
25740 return resultobj;
25741 fail:
25742 return NULL;
25743 }
25744
25745
25746 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25747 PyObject *resultobj;
25748 wxWindow *arg1 = (wxWindow *) 0 ;
25749 int arg2 ;
25750 int arg3 ;
25751 int arg4 ;
25752 int arg5 ;
25753 int arg6 = (int) wxSIZE_AUTO ;
25754 PyObject * obj0 = 0 ;
25755 PyObject * obj1 = 0 ;
25756 PyObject * obj2 = 0 ;
25757 PyObject * obj3 = 0 ;
25758 PyObject * obj4 = 0 ;
25759 PyObject * obj5 = 0 ;
25760 char *kwnames[] = {
25761 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25762 };
25763
25764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25766 if (SWIG_arg_fail(1)) SWIG_fail;
25767 {
25768 arg2 = (int)(SWIG_As_int(obj1));
25769 if (SWIG_arg_fail(2)) SWIG_fail;
25770 }
25771 {
25772 arg3 = (int)(SWIG_As_int(obj2));
25773 if (SWIG_arg_fail(3)) SWIG_fail;
25774 }
25775 {
25776 arg4 = (int)(SWIG_As_int(obj3));
25777 if (SWIG_arg_fail(4)) SWIG_fail;
25778 }
25779 {
25780 arg5 = (int)(SWIG_As_int(obj4));
25781 if (SWIG_arg_fail(5)) SWIG_fail;
25782 }
25783 if (obj5) {
25784 {
25785 arg6 = (int)(SWIG_As_int(obj5));
25786 if (SWIG_arg_fail(6)) SWIG_fail;
25787 }
25788 }
25789 {
25790 PyThreadState* __tstate = wxPyBeginAllowThreads();
25791 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25792
25793 wxPyEndAllowThreads(__tstate);
25794 if (PyErr_Occurred()) SWIG_fail;
25795 }
25796 Py_INCREF(Py_None); resultobj = Py_None;
25797 return resultobj;
25798 fail:
25799 return NULL;
25800 }
25801
25802
25803 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25804 PyObject *resultobj;
25805 wxWindow *arg1 = (wxWindow *) 0 ;
25806 wxRect *arg2 = 0 ;
25807 int arg3 = (int) wxSIZE_AUTO ;
25808 wxRect temp2 ;
25809 PyObject * obj0 = 0 ;
25810 PyObject * obj1 = 0 ;
25811 PyObject * obj2 = 0 ;
25812 char *kwnames[] = {
25813 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25814 };
25815
25816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25818 if (SWIG_arg_fail(1)) SWIG_fail;
25819 {
25820 arg2 = &temp2;
25821 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25822 }
25823 if (obj2) {
25824 {
25825 arg3 = (int)(SWIG_As_int(obj2));
25826 if (SWIG_arg_fail(3)) SWIG_fail;
25827 }
25828 }
25829 {
25830 PyThreadState* __tstate = wxPyBeginAllowThreads();
25831 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25832
25833 wxPyEndAllowThreads(__tstate);
25834 if (PyErr_Occurred()) SWIG_fail;
25835 }
25836 Py_INCREF(Py_None); resultobj = Py_None;
25837 return resultobj;
25838 fail:
25839 return NULL;
25840 }
25841
25842
25843 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25844 PyObject *resultobj;
25845 wxWindow *arg1 = (wxWindow *) 0 ;
25846 int arg2 ;
25847 int arg3 ;
25848 PyObject * obj0 = 0 ;
25849 PyObject * obj1 = 0 ;
25850 PyObject * obj2 = 0 ;
25851 char *kwnames[] = {
25852 (char *) "self",(char *) "width",(char *) "height", NULL
25853 };
25854
25855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25857 if (SWIG_arg_fail(1)) SWIG_fail;
25858 {
25859 arg2 = (int)(SWIG_As_int(obj1));
25860 if (SWIG_arg_fail(2)) SWIG_fail;
25861 }
25862 {
25863 arg3 = (int)(SWIG_As_int(obj2));
25864 if (SWIG_arg_fail(3)) SWIG_fail;
25865 }
25866 {
25867 PyThreadState* __tstate = wxPyBeginAllowThreads();
25868 (arg1)->SetSize(arg2,arg3);
25869
25870 wxPyEndAllowThreads(__tstate);
25871 if (PyErr_Occurred()) SWIG_fail;
25872 }
25873 Py_INCREF(Py_None); resultobj = Py_None;
25874 return resultobj;
25875 fail:
25876 return NULL;
25877 }
25878
25879
25880 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25881 PyObject *resultobj;
25882 wxWindow *arg1 = (wxWindow *) 0 ;
25883 wxPoint *arg2 = 0 ;
25884 int arg3 = (int) wxSIZE_USE_EXISTING ;
25885 wxPoint temp2 ;
25886 PyObject * obj0 = 0 ;
25887 PyObject * obj1 = 0 ;
25888 PyObject * obj2 = 0 ;
25889 char *kwnames[] = {
25890 (char *) "self",(char *) "pt",(char *) "flags", NULL
25891 };
25892
25893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25895 if (SWIG_arg_fail(1)) SWIG_fail;
25896 {
25897 arg2 = &temp2;
25898 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25899 }
25900 if (obj2) {
25901 {
25902 arg3 = (int)(SWIG_As_int(obj2));
25903 if (SWIG_arg_fail(3)) SWIG_fail;
25904 }
25905 }
25906 {
25907 PyThreadState* __tstate = wxPyBeginAllowThreads();
25908 (arg1)->Move((wxPoint const &)*arg2,arg3);
25909
25910 wxPyEndAllowThreads(__tstate);
25911 if (PyErr_Occurred()) SWIG_fail;
25912 }
25913 Py_INCREF(Py_None); resultobj = Py_None;
25914 return resultobj;
25915 fail:
25916 return NULL;
25917 }
25918
25919
25920 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25921 PyObject *resultobj;
25922 wxWindow *arg1 = (wxWindow *) 0 ;
25923 int arg2 ;
25924 int arg3 ;
25925 int arg4 = (int) wxSIZE_USE_EXISTING ;
25926 PyObject * obj0 = 0 ;
25927 PyObject * obj1 = 0 ;
25928 PyObject * obj2 = 0 ;
25929 PyObject * obj3 = 0 ;
25930 char *kwnames[] = {
25931 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25932 };
25933
25934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25936 if (SWIG_arg_fail(1)) SWIG_fail;
25937 {
25938 arg2 = (int)(SWIG_As_int(obj1));
25939 if (SWIG_arg_fail(2)) SWIG_fail;
25940 }
25941 {
25942 arg3 = (int)(SWIG_As_int(obj2));
25943 if (SWIG_arg_fail(3)) SWIG_fail;
25944 }
25945 if (obj3) {
25946 {
25947 arg4 = (int)(SWIG_As_int(obj3));
25948 if (SWIG_arg_fail(4)) SWIG_fail;
25949 }
25950 }
25951 {
25952 PyThreadState* __tstate = wxPyBeginAllowThreads();
25953 (arg1)->Move(arg2,arg3,arg4);
25954
25955 wxPyEndAllowThreads(__tstate);
25956 if (PyErr_Occurred()) SWIG_fail;
25957 }
25958 Py_INCREF(Py_None); resultobj = Py_None;
25959 return resultobj;
25960 fail:
25961 return NULL;
25962 }
25963
25964
25965 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25966 PyObject *resultobj;
25967 wxWindow *arg1 = (wxWindow *) 0 ;
25968 wxSize const &arg2_defvalue = wxDefaultSize ;
25969 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25970 wxSize temp2 ;
25971 PyObject * obj0 = 0 ;
25972 PyObject * obj1 = 0 ;
25973 char *kwnames[] = {
25974 (char *) "self",(char *) "size", NULL
25975 };
25976
25977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25979 if (SWIG_arg_fail(1)) SWIG_fail;
25980 if (obj1) {
25981 {
25982 arg2 = &temp2;
25983 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25984 }
25985 }
25986 {
25987 PyThreadState* __tstate = wxPyBeginAllowThreads();
25988 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25989
25990 wxPyEndAllowThreads(__tstate);
25991 if (PyErr_Occurred()) SWIG_fail;
25992 }
25993 Py_INCREF(Py_None); resultobj = Py_None;
25994 return resultobj;
25995 fail:
25996 return NULL;
25997 }
25998
25999
26000 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26001 PyObject *resultobj;
26002 wxWindow *arg1 = (wxWindow *) 0 ;
26003 PyObject * obj0 = 0 ;
26004 char *kwnames[] = {
26005 (char *) "self", NULL
26006 };
26007
26008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26010 if (SWIG_arg_fail(1)) SWIG_fail;
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 (arg1)->Raise();
26014
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 Py_INCREF(Py_None); resultobj = Py_None;
26019 return resultobj;
26020 fail:
26021 return NULL;
26022 }
26023
26024
26025 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26026 PyObject *resultobj;
26027 wxWindow *arg1 = (wxWindow *) 0 ;
26028 PyObject * obj0 = 0 ;
26029 char *kwnames[] = {
26030 (char *) "self", NULL
26031 };
26032
26033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26035 if (SWIG_arg_fail(1)) SWIG_fail;
26036 {
26037 PyThreadState* __tstate = wxPyBeginAllowThreads();
26038 (arg1)->Lower();
26039
26040 wxPyEndAllowThreads(__tstate);
26041 if (PyErr_Occurred()) SWIG_fail;
26042 }
26043 Py_INCREF(Py_None); resultobj = Py_None;
26044 return resultobj;
26045 fail:
26046 return NULL;
26047 }
26048
26049
26050 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26051 PyObject *resultobj;
26052 wxWindow *arg1 = (wxWindow *) 0 ;
26053 wxSize *arg2 = 0 ;
26054 wxSize temp2 ;
26055 PyObject * obj0 = 0 ;
26056 PyObject * obj1 = 0 ;
26057 char *kwnames[] = {
26058 (char *) "self",(char *) "size", NULL
26059 };
26060
26061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26063 if (SWIG_arg_fail(1)) SWIG_fail;
26064 {
26065 arg2 = &temp2;
26066 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26067 }
26068 {
26069 PyThreadState* __tstate = wxPyBeginAllowThreads();
26070 (arg1)->SetClientSize((wxSize const &)*arg2);
26071
26072 wxPyEndAllowThreads(__tstate);
26073 if (PyErr_Occurred()) SWIG_fail;
26074 }
26075 Py_INCREF(Py_None); resultobj = Py_None;
26076 return resultobj;
26077 fail:
26078 return NULL;
26079 }
26080
26081
26082 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26083 PyObject *resultobj;
26084 wxWindow *arg1 = (wxWindow *) 0 ;
26085 int arg2 ;
26086 int arg3 ;
26087 PyObject * obj0 = 0 ;
26088 PyObject * obj1 = 0 ;
26089 PyObject * obj2 = 0 ;
26090 char *kwnames[] = {
26091 (char *) "self",(char *) "width",(char *) "height", NULL
26092 };
26093
26094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26096 if (SWIG_arg_fail(1)) SWIG_fail;
26097 {
26098 arg2 = (int)(SWIG_As_int(obj1));
26099 if (SWIG_arg_fail(2)) SWIG_fail;
26100 }
26101 {
26102 arg3 = (int)(SWIG_As_int(obj2));
26103 if (SWIG_arg_fail(3)) SWIG_fail;
26104 }
26105 {
26106 PyThreadState* __tstate = wxPyBeginAllowThreads();
26107 (arg1)->SetClientSize(arg2,arg3);
26108
26109 wxPyEndAllowThreads(__tstate);
26110 if (PyErr_Occurred()) SWIG_fail;
26111 }
26112 Py_INCREF(Py_None); resultobj = Py_None;
26113 return resultobj;
26114 fail:
26115 return NULL;
26116 }
26117
26118
26119 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26120 PyObject *resultobj;
26121 wxWindow *arg1 = (wxWindow *) 0 ;
26122 wxRect *arg2 = 0 ;
26123 wxRect temp2 ;
26124 PyObject * obj0 = 0 ;
26125 PyObject * obj1 = 0 ;
26126 char *kwnames[] = {
26127 (char *) "self",(char *) "rect", NULL
26128 };
26129
26130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26132 if (SWIG_arg_fail(1)) SWIG_fail;
26133 {
26134 arg2 = &temp2;
26135 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26136 }
26137 {
26138 PyThreadState* __tstate = wxPyBeginAllowThreads();
26139 (arg1)->SetClientSize((wxRect const &)*arg2);
26140
26141 wxPyEndAllowThreads(__tstate);
26142 if (PyErr_Occurred()) SWIG_fail;
26143 }
26144 Py_INCREF(Py_None); resultobj = Py_None;
26145 return resultobj;
26146 fail:
26147 return NULL;
26148 }
26149
26150
26151 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26152 PyObject *resultobj;
26153 wxWindow *arg1 = (wxWindow *) 0 ;
26154 wxPoint result;
26155 PyObject * obj0 = 0 ;
26156 char *kwnames[] = {
26157 (char *) "self", NULL
26158 };
26159
26160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26162 if (SWIG_arg_fail(1)) SWIG_fail;
26163 {
26164 PyThreadState* __tstate = wxPyBeginAllowThreads();
26165 result = (arg1)->GetPosition();
26166
26167 wxPyEndAllowThreads(__tstate);
26168 if (PyErr_Occurred()) SWIG_fail;
26169 }
26170 {
26171 wxPoint * resultptr;
26172 resultptr = new wxPoint((wxPoint &)(result));
26173 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26174 }
26175 return resultobj;
26176 fail:
26177 return NULL;
26178 }
26179
26180
26181 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26182 PyObject *resultobj;
26183 wxWindow *arg1 = (wxWindow *) 0 ;
26184 int *arg2 = (int *) 0 ;
26185 int *arg3 = (int *) 0 ;
26186 int temp2 ;
26187 int res2 = 0 ;
26188 int temp3 ;
26189 int res3 = 0 ;
26190 PyObject * obj0 = 0 ;
26191 char *kwnames[] = {
26192 (char *) "self", NULL
26193 };
26194
26195 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26196 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26199 if (SWIG_arg_fail(1)) SWIG_fail;
26200 {
26201 PyThreadState* __tstate = wxPyBeginAllowThreads();
26202 (arg1)->GetPosition(arg2,arg3);
26203
26204 wxPyEndAllowThreads(__tstate);
26205 if (PyErr_Occurred()) SWIG_fail;
26206 }
26207 Py_INCREF(Py_None); resultobj = Py_None;
26208 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26209 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26210 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26211 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26212 return resultobj;
26213 fail:
26214 return NULL;
26215 }
26216
26217
26218 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26219 PyObject *resultobj;
26220 wxWindow *arg1 = (wxWindow *) 0 ;
26221 wxSize result;
26222 PyObject * obj0 = 0 ;
26223 char *kwnames[] = {
26224 (char *) "self", NULL
26225 };
26226
26227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26229 if (SWIG_arg_fail(1)) SWIG_fail;
26230 {
26231 PyThreadState* __tstate = wxPyBeginAllowThreads();
26232 result = ((wxWindow const *)arg1)->GetSize();
26233
26234 wxPyEndAllowThreads(__tstate);
26235 if (PyErr_Occurred()) SWIG_fail;
26236 }
26237 {
26238 wxSize * resultptr;
26239 resultptr = new wxSize((wxSize &)(result));
26240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26241 }
26242 return resultobj;
26243 fail:
26244 return NULL;
26245 }
26246
26247
26248 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26249 PyObject *resultobj;
26250 wxWindow *arg1 = (wxWindow *) 0 ;
26251 int *arg2 = (int *) 0 ;
26252 int *arg3 = (int *) 0 ;
26253 int temp2 ;
26254 int res2 = 0 ;
26255 int temp3 ;
26256 int res3 = 0 ;
26257 PyObject * obj0 = 0 ;
26258 char *kwnames[] = {
26259 (char *) "self", NULL
26260 };
26261
26262 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26263 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26266 if (SWIG_arg_fail(1)) SWIG_fail;
26267 {
26268 PyThreadState* __tstate = wxPyBeginAllowThreads();
26269 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26270
26271 wxPyEndAllowThreads(__tstate);
26272 if (PyErr_Occurred()) SWIG_fail;
26273 }
26274 Py_INCREF(Py_None); resultobj = Py_None;
26275 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26276 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26277 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26278 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26279 return resultobj;
26280 fail:
26281 return NULL;
26282 }
26283
26284
26285 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26286 PyObject *resultobj;
26287 wxWindow *arg1 = (wxWindow *) 0 ;
26288 wxRect result;
26289 PyObject * obj0 = 0 ;
26290 char *kwnames[] = {
26291 (char *) "self", NULL
26292 };
26293
26294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26299 result = ((wxWindow const *)arg1)->GetRect();
26300
26301 wxPyEndAllowThreads(__tstate);
26302 if (PyErr_Occurred()) SWIG_fail;
26303 }
26304 {
26305 wxRect * resultptr;
26306 resultptr = new wxRect((wxRect &)(result));
26307 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26308 }
26309 return resultobj;
26310 fail:
26311 return NULL;
26312 }
26313
26314
26315 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26316 PyObject *resultobj;
26317 wxWindow *arg1 = (wxWindow *) 0 ;
26318 wxSize result;
26319 PyObject * obj0 = 0 ;
26320 char *kwnames[] = {
26321 (char *) "self", NULL
26322 };
26323
26324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",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 = ((wxWindow const *)arg1)->GetClientSize();
26330
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 {
26335 wxSize * resultptr;
26336 resultptr = new wxSize((wxSize &)(result));
26337 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26338 }
26339 return resultobj;
26340 fail:
26341 return NULL;
26342 }
26343
26344
26345 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26346 PyObject *resultobj;
26347 wxWindow *arg1 = (wxWindow *) 0 ;
26348 int *arg2 = (int *) 0 ;
26349 int *arg3 = (int *) 0 ;
26350 int temp2 ;
26351 int res2 = 0 ;
26352 int temp3 ;
26353 int res3 = 0 ;
26354 PyObject * obj0 = 0 ;
26355 char *kwnames[] = {
26356 (char *) "self", NULL
26357 };
26358
26359 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26360 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26363 if (SWIG_arg_fail(1)) SWIG_fail;
26364 {
26365 PyThreadState* __tstate = wxPyBeginAllowThreads();
26366 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26367
26368 wxPyEndAllowThreads(__tstate);
26369 if (PyErr_Occurred()) SWIG_fail;
26370 }
26371 Py_INCREF(Py_None); resultobj = Py_None;
26372 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26373 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26374 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26375 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26376 return resultobj;
26377 fail:
26378 return NULL;
26379 }
26380
26381
26382 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26383 PyObject *resultobj;
26384 wxWindow *arg1 = (wxWindow *) 0 ;
26385 wxPoint result;
26386 PyObject * obj0 = 0 ;
26387 char *kwnames[] = {
26388 (char *) "self", NULL
26389 };
26390
26391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26393 if (SWIG_arg_fail(1)) SWIG_fail;
26394 {
26395 PyThreadState* __tstate = wxPyBeginAllowThreads();
26396 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26397
26398 wxPyEndAllowThreads(__tstate);
26399 if (PyErr_Occurred()) SWIG_fail;
26400 }
26401 {
26402 wxPoint * resultptr;
26403 resultptr = new wxPoint((wxPoint &)(result));
26404 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26405 }
26406 return resultobj;
26407 fail:
26408 return NULL;
26409 }
26410
26411
26412 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26413 PyObject *resultobj;
26414 wxWindow *arg1 = (wxWindow *) 0 ;
26415 wxRect result;
26416 PyObject * obj0 = 0 ;
26417 char *kwnames[] = {
26418 (char *) "self", NULL
26419 };
26420
26421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26423 if (SWIG_arg_fail(1)) SWIG_fail;
26424 {
26425 PyThreadState* __tstate = wxPyBeginAllowThreads();
26426 result = ((wxWindow const *)arg1)->GetClientRect();
26427
26428 wxPyEndAllowThreads(__tstate);
26429 if (PyErr_Occurred()) SWIG_fail;
26430 }
26431 {
26432 wxRect * resultptr;
26433 resultptr = new wxRect((wxRect &)(result));
26434 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26435 }
26436 return resultobj;
26437 fail:
26438 return NULL;
26439 }
26440
26441
26442 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26443 PyObject *resultobj;
26444 wxWindow *arg1 = (wxWindow *) 0 ;
26445 wxSize result;
26446 PyObject * obj0 = 0 ;
26447 char *kwnames[] = {
26448 (char *) "self", NULL
26449 };
26450
26451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26453 if (SWIG_arg_fail(1)) SWIG_fail;
26454 {
26455 PyThreadState* __tstate = wxPyBeginAllowThreads();
26456 result = ((wxWindow const *)arg1)->GetBestSize();
26457
26458 wxPyEndAllowThreads(__tstate);
26459 if (PyErr_Occurred()) SWIG_fail;
26460 }
26461 {
26462 wxSize * resultptr;
26463 resultptr = new wxSize((wxSize &)(result));
26464 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26465 }
26466 return resultobj;
26467 fail:
26468 return NULL;
26469 }
26470
26471
26472 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26473 PyObject *resultobj;
26474 wxWindow *arg1 = (wxWindow *) 0 ;
26475 int *arg2 = (int *) 0 ;
26476 int *arg3 = (int *) 0 ;
26477 int temp2 ;
26478 int res2 = 0 ;
26479 int temp3 ;
26480 int res3 = 0 ;
26481 PyObject * obj0 = 0 ;
26482 char *kwnames[] = {
26483 (char *) "self", NULL
26484 };
26485
26486 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26487 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26490 if (SWIG_arg_fail(1)) SWIG_fail;
26491 {
26492 PyThreadState* __tstate = wxPyBeginAllowThreads();
26493 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26494
26495 wxPyEndAllowThreads(__tstate);
26496 if (PyErr_Occurred()) SWIG_fail;
26497 }
26498 Py_INCREF(Py_None); resultobj = Py_None;
26499 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26500 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26501 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26502 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26503 return resultobj;
26504 fail:
26505 return NULL;
26506 }
26507
26508
26509 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26510 PyObject *resultobj;
26511 wxWindow *arg1 = (wxWindow *) 0 ;
26512 PyObject * obj0 = 0 ;
26513 char *kwnames[] = {
26514 (char *) "self", NULL
26515 };
26516
26517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26519 if (SWIG_arg_fail(1)) SWIG_fail;
26520 {
26521 PyThreadState* __tstate = wxPyBeginAllowThreads();
26522 (arg1)->InvalidateBestSize();
26523
26524 wxPyEndAllowThreads(__tstate);
26525 if (PyErr_Occurred()) SWIG_fail;
26526 }
26527 Py_INCREF(Py_None); resultobj = Py_None;
26528 return resultobj;
26529 fail:
26530 return NULL;
26531 }
26532
26533
26534 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26535 PyObject *resultobj;
26536 wxWindow *arg1 = (wxWindow *) 0 ;
26537 wxSize result;
26538 PyObject * obj0 = 0 ;
26539 char *kwnames[] = {
26540 (char *) "self", NULL
26541 };
26542
26543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26545 if (SWIG_arg_fail(1)) SWIG_fail;
26546 {
26547 PyThreadState* __tstate = wxPyBeginAllowThreads();
26548 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26549
26550 wxPyEndAllowThreads(__tstate);
26551 if (PyErr_Occurred()) SWIG_fail;
26552 }
26553 {
26554 wxSize * resultptr;
26555 resultptr = new wxSize((wxSize &)(result));
26556 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26557 }
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26565 PyObject *resultobj;
26566 wxWindow *arg1 = (wxWindow *) 0 ;
26567 wxSize result;
26568 PyObject * obj0 = 0 ;
26569 char *kwnames[] = {
26570 (char *) "self", NULL
26571 };
26572
26573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26575 if (SWIG_arg_fail(1)) SWIG_fail;
26576 {
26577 PyThreadState* __tstate = wxPyBeginAllowThreads();
26578 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26579
26580 wxPyEndAllowThreads(__tstate);
26581 if (PyErr_Occurred()) SWIG_fail;
26582 }
26583 {
26584 wxSize * resultptr;
26585 resultptr = new wxSize((wxSize &)(result));
26586 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26587 }
26588 return resultobj;
26589 fail:
26590 return NULL;
26591 }
26592
26593
26594 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26595 PyObject *resultobj;
26596 wxWindow *arg1 = (wxWindow *) 0 ;
26597 int arg2 = (int) wxBOTH ;
26598 PyObject * obj0 = 0 ;
26599 PyObject * obj1 = 0 ;
26600 char *kwnames[] = {
26601 (char *) "self",(char *) "direction", NULL
26602 };
26603
26604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",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 = (int)(SWIG_As_int(obj1));
26610 if (SWIG_arg_fail(2)) SWIG_fail;
26611 }
26612 }
26613 {
26614 PyThreadState* __tstate = wxPyBeginAllowThreads();
26615 (arg1)->Center(arg2);
26616
26617 wxPyEndAllowThreads(__tstate);
26618 if (PyErr_Occurred()) SWIG_fail;
26619 }
26620 Py_INCREF(Py_None); resultobj = Py_None;
26621 return resultobj;
26622 fail:
26623 return NULL;
26624 }
26625
26626
26627 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26628 PyObject *resultobj;
26629 wxWindow *arg1 = (wxWindow *) 0 ;
26630 int arg2 = (int) wxBOTH ;
26631 PyObject * obj0 = 0 ;
26632 PyObject * obj1 = 0 ;
26633 char *kwnames[] = {
26634 (char *) "self",(char *) "dir", NULL
26635 };
26636
26637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26639 if (SWIG_arg_fail(1)) SWIG_fail;
26640 if (obj1) {
26641 {
26642 arg2 = (int)(SWIG_As_int(obj1));
26643 if (SWIG_arg_fail(2)) SWIG_fail;
26644 }
26645 }
26646 {
26647 PyThreadState* __tstate = wxPyBeginAllowThreads();
26648 (arg1)->CenterOnScreen(arg2);
26649
26650 wxPyEndAllowThreads(__tstate);
26651 if (PyErr_Occurred()) SWIG_fail;
26652 }
26653 Py_INCREF(Py_None); resultobj = Py_None;
26654 return resultobj;
26655 fail:
26656 return NULL;
26657 }
26658
26659
26660 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26661 PyObject *resultobj;
26662 wxWindow *arg1 = (wxWindow *) 0 ;
26663 int arg2 = (int) wxBOTH ;
26664 PyObject * obj0 = 0 ;
26665 PyObject * obj1 = 0 ;
26666 char *kwnames[] = {
26667 (char *) "self",(char *) "dir", NULL
26668 };
26669
26670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26672 if (SWIG_arg_fail(1)) SWIG_fail;
26673 if (obj1) {
26674 {
26675 arg2 = (int)(SWIG_As_int(obj1));
26676 if (SWIG_arg_fail(2)) SWIG_fail;
26677 }
26678 }
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 (arg1)->CenterOnParent(arg2);
26682
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 Py_INCREF(Py_None); resultobj = Py_None;
26687 return resultobj;
26688 fail:
26689 return NULL;
26690 }
26691
26692
26693 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26694 PyObject *resultobj;
26695 wxWindow *arg1 = (wxWindow *) 0 ;
26696 PyObject * obj0 = 0 ;
26697 char *kwnames[] = {
26698 (char *) "self", NULL
26699 };
26700
26701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26703 if (SWIG_arg_fail(1)) SWIG_fail;
26704 {
26705 PyThreadState* __tstate = wxPyBeginAllowThreads();
26706 (arg1)->Fit();
26707
26708 wxPyEndAllowThreads(__tstate);
26709 if (PyErr_Occurred()) SWIG_fail;
26710 }
26711 Py_INCREF(Py_None); resultobj = Py_None;
26712 return resultobj;
26713 fail:
26714 return NULL;
26715 }
26716
26717
26718 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26719 PyObject *resultobj;
26720 wxWindow *arg1 = (wxWindow *) 0 ;
26721 PyObject * obj0 = 0 ;
26722 char *kwnames[] = {
26723 (char *) "self", NULL
26724 };
26725
26726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26728 if (SWIG_arg_fail(1)) SWIG_fail;
26729 {
26730 PyThreadState* __tstate = wxPyBeginAllowThreads();
26731 (arg1)->FitInside();
26732
26733 wxPyEndAllowThreads(__tstate);
26734 if (PyErr_Occurred()) SWIG_fail;
26735 }
26736 Py_INCREF(Py_None); resultobj = Py_None;
26737 return resultobj;
26738 fail:
26739 return NULL;
26740 }
26741
26742
26743 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26744 PyObject *resultobj;
26745 wxWindow *arg1 = (wxWindow *) 0 ;
26746 int arg2 ;
26747 int arg3 ;
26748 int arg4 = (int) -1 ;
26749 int arg5 = (int) -1 ;
26750 int arg6 = (int) -1 ;
26751 int arg7 = (int) -1 ;
26752 PyObject * obj0 = 0 ;
26753 PyObject * obj1 = 0 ;
26754 PyObject * obj2 = 0 ;
26755 PyObject * obj3 = 0 ;
26756 PyObject * obj4 = 0 ;
26757 PyObject * obj5 = 0 ;
26758 PyObject * obj6 = 0 ;
26759 char *kwnames[] = {
26760 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26761 };
26762
26763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26765 if (SWIG_arg_fail(1)) SWIG_fail;
26766 {
26767 arg2 = (int)(SWIG_As_int(obj1));
26768 if (SWIG_arg_fail(2)) SWIG_fail;
26769 }
26770 {
26771 arg3 = (int)(SWIG_As_int(obj2));
26772 if (SWIG_arg_fail(3)) SWIG_fail;
26773 }
26774 if (obj3) {
26775 {
26776 arg4 = (int)(SWIG_As_int(obj3));
26777 if (SWIG_arg_fail(4)) SWIG_fail;
26778 }
26779 }
26780 if (obj4) {
26781 {
26782 arg5 = (int)(SWIG_As_int(obj4));
26783 if (SWIG_arg_fail(5)) SWIG_fail;
26784 }
26785 }
26786 if (obj5) {
26787 {
26788 arg6 = (int)(SWIG_As_int(obj5));
26789 if (SWIG_arg_fail(6)) SWIG_fail;
26790 }
26791 }
26792 if (obj6) {
26793 {
26794 arg7 = (int)(SWIG_As_int(obj6));
26795 if (SWIG_arg_fail(7)) SWIG_fail;
26796 }
26797 }
26798 {
26799 PyThreadState* __tstate = wxPyBeginAllowThreads();
26800 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26801
26802 wxPyEndAllowThreads(__tstate);
26803 if (PyErr_Occurred()) SWIG_fail;
26804 }
26805 Py_INCREF(Py_None); resultobj = Py_None;
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26813 PyObject *resultobj;
26814 wxWindow *arg1 = (wxWindow *) 0 ;
26815 wxSize *arg2 = 0 ;
26816 wxSize const &arg3_defvalue = wxDefaultSize ;
26817 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26818 wxSize const &arg4_defvalue = wxDefaultSize ;
26819 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26820 wxSize temp2 ;
26821 wxSize temp3 ;
26822 wxSize temp4 ;
26823 PyObject * obj0 = 0 ;
26824 PyObject * obj1 = 0 ;
26825 PyObject * obj2 = 0 ;
26826 PyObject * obj3 = 0 ;
26827 char *kwnames[] = {
26828 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26829 };
26830
26831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26833 if (SWIG_arg_fail(1)) SWIG_fail;
26834 {
26835 arg2 = &temp2;
26836 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26837 }
26838 if (obj2) {
26839 {
26840 arg3 = &temp3;
26841 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26842 }
26843 }
26844 if (obj3) {
26845 {
26846 arg4 = &temp4;
26847 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26848 }
26849 }
26850 {
26851 PyThreadState* __tstate = wxPyBeginAllowThreads();
26852 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26853
26854 wxPyEndAllowThreads(__tstate);
26855 if (PyErr_Occurred()) SWIG_fail;
26856 }
26857 Py_INCREF(Py_None); resultobj = Py_None;
26858 return resultobj;
26859 fail:
26860 return NULL;
26861 }
26862
26863
26864 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26865 PyObject *resultobj;
26866 wxWindow *arg1 = (wxWindow *) 0 ;
26867 int arg2 ;
26868 int arg3 ;
26869 int arg4 = (int) -1 ;
26870 int arg5 = (int) -1 ;
26871 PyObject * obj0 = 0 ;
26872 PyObject * obj1 = 0 ;
26873 PyObject * obj2 = 0 ;
26874 PyObject * obj3 = 0 ;
26875 PyObject * obj4 = 0 ;
26876 char *kwnames[] = {
26877 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26878 };
26879
26880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26882 if (SWIG_arg_fail(1)) SWIG_fail;
26883 {
26884 arg2 = (int)(SWIG_As_int(obj1));
26885 if (SWIG_arg_fail(2)) SWIG_fail;
26886 }
26887 {
26888 arg3 = (int)(SWIG_As_int(obj2));
26889 if (SWIG_arg_fail(3)) SWIG_fail;
26890 }
26891 if (obj3) {
26892 {
26893 arg4 = (int)(SWIG_As_int(obj3));
26894 if (SWIG_arg_fail(4)) SWIG_fail;
26895 }
26896 }
26897 if (obj4) {
26898 {
26899 arg5 = (int)(SWIG_As_int(obj4));
26900 if (SWIG_arg_fail(5)) SWIG_fail;
26901 }
26902 }
26903 {
26904 PyThreadState* __tstate = wxPyBeginAllowThreads();
26905 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26906
26907 wxPyEndAllowThreads(__tstate);
26908 if (PyErr_Occurred()) SWIG_fail;
26909 }
26910 Py_INCREF(Py_None); resultobj = Py_None;
26911 return resultobj;
26912 fail:
26913 return NULL;
26914 }
26915
26916
26917 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26918 PyObject *resultobj;
26919 wxWindow *arg1 = (wxWindow *) 0 ;
26920 wxSize *arg2 = 0 ;
26921 wxSize const &arg3_defvalue = wxDefaultSize ;
26922 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26923 wxSize temp2 ;
26924 wxSize temp3 ;
26925 PyObject * obj0 = 0 ;
26926 PyObject * obj1 = 0 ;
26927 PyObject * obj2 = 0 ;
26928 char *kwnames[] = {
26929 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26930 };
26931
26932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26934 if (SWIG_arg_fail(1)) SWIG_fail;
26935 {
26936 arg2 = &temp2;
26937 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26938 }
26939 if (obj2) {
26940 {
26941 arg3 = &temp3;
26942 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26943 }
26944 }
26945 {
26946 PyThreadState* __tstate = wxPyBeginAllowThreads();
26947 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26948
26949 wxPyEndAllowThreads(__tstate);
26950 if (PyErr_Occurred()) SWIG_fail;
26951 }
26952 Py_INCREF(Py_None); resultobj = Py_None;
26953 return resultobj;
26954 fail:
26955 return NULL;
26956 }
26957
26958
26959 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26960 PyObject *resultobj;
26961 wxWindow *arg1 = (wxWindow *) 0 ;
26962 wxSize result;
26963 PyObject * obj0 = 0 ;
26964 char *kwnames[] = {
26965 (char *) "self", NULL
26966 };
26967
26968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26970 if (SWIG_arg_fail(1)) SWIG_fail;
26971 {
26972 PyThreadState* __tstate = wxPyBeginAllowThreads();
26973 result = ((wxWindow const *)arg1)->GetMaxSize();
26974
26975 wxPyEndAllowThreads(__tstate);
26976 if (PyErr_Occurred()) SWIG_fail;
26977 }
26978 {
26979 wxSize * resultptr;
26980 resultptr = new wxSize((wxSize &)(result));
26981 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26982 }
26983 return resultobj;
26984 fail:
26985 return NULL;
26986 }
26987
26988
26989 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26990 PyObject *resultobj;
26991 wxWindow *arg1 = (wxWindow *) 0 ;
26992 wxSize result;
26993 PyObject * obj0 = 0 ;
26994 char *kwnames[] = {
26995 (char *) "self", NULL
26996 };
26997
26998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27000 if (SWIG_arg_fail(1)) SWIG_fail;
27001 {
27002 PyThreadState* __tstate = wxPyBeginAllowThreads();
27003 result = ((wxWindow const *)arg1)->GetMinSize();
27004
27005 wxPyEndAllowThreads(__tstate);
27006 if (PyErr_Occurred()) SWIG_fail;
27007 }
27008 {
27009 wxSize * resultptr;
27010 resultptr = new wxSize((wxSize &)(result));
27011 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27012 }
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27020 PyObject *resultobj;
27021 wxWindow *arg1 = (wxWindow *) 0 ;
27022 wxSize *arg2 = 0 ;
27023 wxSize temp2 ;
27024 PyObject * obj0 = 0 ;
27025 PyObject * obj1 = 0 ;
27026 char *kwnames[] = {
27027 (char *) "self",(char *) "minSize", NULL
27028 };
27029
27030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
27035 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27036 }
27037 {
27038 PyThreadState* __tstate = wxPyBeginAllowThreads();
27039 (arg1)->SetMinSize((wxSize const &)*arg2);
27040
27041 wxPyEndAllowThreads(__tstate);
27042 if (PyErr_Occurred()) SWIG_fail;
27043 }
27044 Py_INCREF(Py_None); resultobj = Py_None;
27045 return resultobj;
27046 fail:
27047 return NULL;
27048 }
27049
27050
27051 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27052 PyObject *resultobj;
27053 wxWindow *arg1 = (wxWindow *) 0 ;
27054 wxSize *arg2 = 0 ;
27055 wxSize temp2 ;
27056 PyObject * obj0 = 0 ;
27057 PyObject * obj1 = 0 ;
27058 char *kwnames[] = {
27059 (char *) "self",(char *) "maxSize", NULL
27060 };
27061
27062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27064 if (SWIG_arg_fail(1)) SWIG_fail;
27065 {
27066 arg2 = &temp2;
27067 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27068 }
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 (arg1)->SetMaxSize((wxSize const &)*arg2);
27072
27073 wxPyEndAllowThreads(__tstate);
27074 if (PyErr_Occurred()) SWIG_fail;
27075 }
27076 Py_INCREF(Py_None); resultobj = Py_None;
27077 return resultobj;
27078 fail:
27079 return NULL;
27080 }
27081
27082
27083 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27084 PyObject *resultobj;
27085 wxWindow *arg1 = (wxWindow *) 0 ;
27086 int result;
27087 PyObject * obj0 = 0 ;
27088 char *kwnames[] = {
27089 (char *) "self", NULL
27090 };
27091
27092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27094 if (SWIG_arg_fail(1)) SWIG_fail;
27095 {
27096 PyThreadState* __tstate = wxPyBeginAllowThreads();
27097 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27098
27099 wxPyEndAllowThreads(__tstate);
27100 if (PyErr_Occurred()) SWIG_fail;
27101 }
27102 {
27103 resultobj = SWIG_From_int((int)(result));
27104 }
27105 return resultobj;
27106 fail:
27107 return NULL;
27108 }
27109
27110
27111 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27112 PyObject *resultobj;
27113 wxWindow *arg1 = (wxWindow *) 0 ;
27114 int result;
27115 PyObject * obj0 = 0 ;
27116 char *kwnames[] = {
27117 (char *) "self", NULL
27118 };
27119
27120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27122 if (SWIG_arg_fail(1)) SWIG_fail;
27123 {
27124 PyThreadState* __tstate = wxPyBeginAllowThreads();
27125 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27126
27127 wxPyEndAllowThreads(__tstate);
27128 if (PyErr_Occurred()) SWIG_fail;
27129 }
27130 {
27131 resultobj = SWIG_From_int((int)(result));
27132 }
27133 return resultobj;
27134 fail:
27135 return NULL;
27136 }
27137
27138
27139 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27140 PyObject *resultobj;
27141 wxWindow *arg1 = (wxWindow *) 0 ;
27142 int result;
27143 PyObject * obj0 = 0 ;
27144 char *kwnames[] = {
27145 (char *) "self", NULL
27146 };
27147
27148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27150 if (SWIG_arg_fail(1)) SWIG_fail;
27151 {
27152 PyThreadState* __tstate = wxPyBeginAllowThreads();
27153 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27154
27155 wxPyEndAllowThreads(__tstate);
27156 if (PyErr_Occurred()) SWIG_fail;
27157 }
27158 {
27159 resultobj = SWIG_From_int((int)(result));
27160 }
27161 return resultobj;
27162 fail:
27163 return NULL;
27164 }
27165
27166
27167 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27168 PyObject *resultobj;
27169 wxWindow *arg1 = (wxWindow *) 0 ;
27170 int result;
27171 PyObject * obj0 = 0 ;
27172 char *kwnames[] = {
27173 (char *) "self", NULL
27174 };
27175
27176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27178 if (SWIG_arg_fail(1)) SWIG_fail;
27179 {
27180 PyThreadState* __tstate = wxPyBeginAllowThreads();
27181 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27182
27183 wxPyEndAllowThreads(__tstate);
27184 if (PyErr_Occurred()) SWIG_fail;
27185 }
27186 {
27187 resultobj = SWIG_From_int((int)(result));
27188 }
27189 return resultobj;
27190 fail:
27191 return NULL;
27192 }
27193
27194
27195 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27196 PyObject *resultobj;
27197 wxWindow *arg1 = (wxWindow *) 0 ;
27198 wxSize *arg2 = 0 ;
27199 wxSize temp2 ;
27200 PyObject * obj0 = 0 ;
27201 PyObject * obj1 = 0 ;
27202 char *kwnames[] = {
27203 (char *) "self",(char *) "size", NULL
27204 };
27205
27206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27208 if (SWIG_arg_fail(1)) SWIG_fail;
27209 {
27210 arg2 = &temp2;
27211 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27212 }
27213 {
27214 PyThreadState* __tstate = wxPyBeginAllowThreads();
27215 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27216
27217 wxPyEndAllowThreads(__tstate);
27218 if (PyErr_Occurred()) SWIG_fail;
27219 }
27220 Py_INCREF(Py_None); resultobj = Py_None;
27221 return resultobj;
27222 fail:
27223 return NULL;
27224 }
27225
27226
27227 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27228 PyObject *resultobj;
27229 wxWindow *arg1 = (wxWindow *) 0 ;
27230 int arg2 ;
27231 int arg3 ;
27232 PyObject * obj0 = 0 ;
27233 PyObject * obj1 = 0 ;
27234 PyObject * obj2 = 0 ;
27235 char *kwnames[] = {
27236 (char *) "self",(char *) "w",(char *) "h", NULL
27237 };
27238
27239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27241 if (SWIG_arg_fail(1)) SWIG_fail;
27242 {
27243 arg2 = (int)(SWIG_As_int(obj1));
27244 if (SWIG_arg_fail(2)) SWIG_fail;
27245 }
27246 {
27247 arg3 = (int)(SWIG_As_int(obj2));
27248 if (SWIG_arg_fail(3)) SWIG_fail;
27249 }
27250 {
27251 PyThreadState* __tstate = wxPyBeginAllowThreads();
27252 (arg1)->SetVirtualSize(arg2,arg3);
27253
27254 wxPyEndAllowThreads(__tstate);
27255 if (PyErr_Occurred()) SWIG_fail;
27256 }
27257 Py_INCREF(Py_None); resultobj = Py_None;
27258 return resultobj;
27259 fail:
27260 return NULL;
27261 }
27262
27263
27264 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27265 PyObject *resultobj;
27266 wxWindow *arg1 = (wxWindow *) 0 ;
27267 wxSize result;
27268 PyObject * obj0 = 0 ;
27269 char *kwnames[] = {
27270 (char *) "self", NULL
27271 };
27272
27273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27275 if (SWIG_arg_fail(1)) SWIG_fail;
27276 {
27277 PyThreadState* __tstate = wxPyBeginAllowThreads();
27278 result = ((wxWindow const *)arg1)->GetVirtualSize();
27279
27280 wxPyEndAllowThreads(__tstate);
27281 if (PyErr_Occurred()) SWIG_fail;
27282 }
27283 {
27284 wxSize * resultptr;
27285 resultptr = new wxSize((wxSize &)(result));
27286 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27287 }
27288 return resultobj;
27289 fail:
27290 return NULL;
27291 }
27292
27293
27294 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27295 PyObject *resultobj;
27296 wxWindow *arg1 = (wxWindow *) 0 ;
27297 int *arg2 = (int *) 0 ;
27298 int *arg3 = (int *) 0 ;
27299 int temp2 ;
27300 int res2 = 0 ;
27301 int temp3 ;
27302 int res3 = 0 ;
27303 PyObject * obj0 = 0 ;
27304 char *kwnames[] = {
27305 (char *) "self", NULL
27306 };
27307
27308 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27309 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27312 if (SWIG_arg_fail(1)) SWIG_fail;
27313 {
27314 PyThreadState* __tstate = wxPyBeginAllowThreads();
27315 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27316
27317 wxPyEndAllowThreads(__tstate);
27318 if (PyErr_Occurred()) SWIG_fail;
27319 }
27320 Py_INCREF(Py_None); resultobj = Py_None;
27321 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27322 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27323 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27324 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27325 return resultobj;
27326 fail:
27327 return NULL;
27328 }
27329
27330
27331 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27332 PyObject *resultobj;
27333 wxWindow *arg1 = (wxWindow *) 0 ;
27334 wxSize result;
27335 PyObject * obj0 = 0 ;
27336 char *kwnames[] = {
27337 (char *) "self", NULL
27338 };
27339
27340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27342 if (SWIG_arg_fail(1)) SWIG_fail;
27343 {
27344 PyThreadState* __tstate = wxPyBeginAllowThreads();
27345 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27346
27347 wxPyEndAllowThreads(__tstate);
27348 if (PyErr_Occurred()) SWIG_fail;
27349 }
27350 {
27351 wxSize * resultptr;
27352 resultptr = new wxSize((wxSize &)(result));
27353 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27354 }
27355 return resultobj;
27356 fail:
27357 return NULL;
27358 }
27359
27360
27361 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27362 PyObject *resultobj;
27363 wxWindow *arg1 = (wxWindow *) 0 ;
27364 bool arg2 = (bool) true ;
27365 bool result;
27366 PyObject * obj0 = 0 ;
27367 PyObject * obj1 = 0 ;
27368 char *kwnames[] = {
27369 (char *) "self",(char *) "show", NULL
27370 };
27371
27372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) 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 if (obj1) {
27376 {
27377 arg2 = (bool)(SWIG_As_bool(obj1));
27378 if (SWIG_arg_fail(2)) SWIG_fail;
27379 }
27380 }
27381 {
27382 PyThreadState* __tstate = wxPyBeginAllowThreads();
27383 result = (bool)(arg1)->Show(arg2);
27384
27385 wxPyEndAllowThreads(__tstate);
27386 if (PyErr_Occurred()) SWIG_fail;
27387 }
27388 {
27389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27390 }
27391 return resultobj;
27392 fail:
27393 return NULL;
27394 }
27395
27396
27397 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27398 PyObject *resultobj;
27399 wxWindow *arg1 = (wxWindow *) 0 ;
27400 bool result;
27401 PyObject * obj0 = 0 ;
27402 char *kwnames[] = {
27403 (char *) "self", NULL
27404 };
27405
27406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27408 if (SWIG_arg_fail(1)) SWIG_fail;
27409 {
27410 PyThreadState* __tstate = wxPyBeginAllowThreads();
27411 result = (bool)(arg1)->Hide();
27412
27413 wxPyEndAllowThreads(__tstate);
27414 if (PyErr_Occurred()) SWIG_fail;
27415 }
27416 {
27417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27418 }
27419 return resultobj;
27420 fail:
27421 return NULL;
27422 }
27423
27424
27425 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27426 PyObject *resultobj;
27427 wxWindow *arg1 = (wxWindow *) 0 ;
27428 bool arg2 = (bool) true ;
27429 bool result;
27430 PyObject * obj0 = 0 ;
27431 PyObject * obj1 = 0 ;
27432 char *kwnames[] = {
27433 (char *) "self",(char *) "enable", NULL
27434 };
27435
27436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27438 if (SWIG_arg_fail(1)) SWIG_fail;
27439 if (obj1) {
27440 {
27441 arg2 = (bool)(SWIG_As_bool(obj1));
27442 if (SWIG_arg_fail(2)) SWIG_fail;
27443 }
27444 }
27445 {
27446 PyThreadState* __tstate = wxPyBeginAllowThreads();
27447 result = (bool)(arg1)->Enable(arg2);
27448
27449 wxPyEndAllowThreads(__tstate);
27450 if (PyErr_Occurred()) SWIG_fail;
27451 }
27452 {
27453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27454 }
27455 return resultobj;
27456 fail:
27457 return NULL;
27458 }
27459
27460
27461 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27462 PyObject *resultobj;
27463 wxWindow *arg1 = (wxWindow *) 0 ;
27464 bool result;
27465 PyObject * obj0 = 0 ;
27466 char *kwnames[] = {
27467 (char *) "self", NULL
27468 };
27469
27470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27472 if (SWIG_arg_fail(1)) SWIG_fail;
27473 {
27474 PyThreadState* __tstate = wxPyBeginAllowThreads();
27475 result = (bool)(arg1)->Disable();
27476
27477 wxPyEndAllowThreads(__tstate);
27478 if (PyErr_Occurred()) SWIG_fail;
27479 }
27480 {
27481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27482 }
27483 return resultobj;
27484 fail:
27485 return NULL;
27486 }
27487
27488
27489 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27490 PyObject *resultobj;
27491 wxWindow *arg1 = (wxWindow *) 0 ;
27492 bool result;
27493 PyObject * obj0 = 0 ;
27494 char *kwnames[] = {
27495 (char *) "self", NULL
27496 };
27497
27498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27500 if (SWIG_arg_fail(1)) SWIG_fail;
27501 {
27502 PyThreadState* __tstate = wxPyBeginAllowThreads();
27503 result = (bool)((wxWindow const *)arg1)->IsShown();
27504
27505 wxPyEndAllowThreads(__tstate);
27506 if (PyErr_Occurred()) SWIG_fail;
27507 }
27508 {
27509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27510 }
27511 return resultobj;
27512 fail:
27513 return NULL;
27514 }
27515
27516
27517 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27518 PyObject *resultobj;
27519 wxWindow *arg1 = (wxWindow *) 0 ;
27520 bool result;
27521 PyObject * obj0 = 0 ;
27522 char *kwnames[] = {
27523 (char *) "self", NULL
27524 };
27525
27526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27528 if (SWIG_arg_fail(1)) SWIG_fail;
27529 {
27530 PyThreadState* __tstate = wxPyBeginAllowThreads();
27531 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27532
27533 wxPyEndAllowThreads(__tstate);
27534 if (PyErr_Occurred()) SWIG_fail;
27535 }
27536 {
27537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27538 }
27539 return resultobj;
27540 fail:
27541 return NULL;
27542 }
27543
27544
27545 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27546 PyObject *resultobj;
27547 wxWindow *arg1 = (wxWindow *) 0 ;
27548 long arg2 ;
27549 PyObject * obj0 = 0 ;
27550 PyObject * obj1 = 0 ;
27551 char *kwnames[] = {
27552 (char *) "self",(char *) "style", NULL
27553 };
27554
27555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27557 if (SWIG_arg_fail(1)) SWIG_fail;
27558 {
27559 arg2 = (long)(SWIG_As_long(obj1));
27560 if (SWIG_arg_fail(2)) SWIG_fail;
27561 }
27562 {
27563 PyThreadState* __tstate = wxPyBeginAllowThreads();
27564 (arg1)->SetWindowStyleFlag(arg2);
27565
27566 wxPyEndAllowThreads(__tstate);
27567 if (PyErr_Occurred()) SWIG_fail;
27568 }
27569 Py_INCREF(Py_None); resultobj = Py_None;
27570 return resultobj;
27571 fail:
27572 return NULL;
27573 }
27574
27575
27576 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27577 PyObject *resultobj;
27578 wxWindow *arg1 = (wxWindow *) 0 ;
27579 long result;
27580 PyObject * obj0 = 0 ;
27581 char *kwnames[] = {
27582 (char *) "self", NULL
27583 };
27584
27585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27587 if (SWIG_arg_fail(1)) SWIG_fail;
27588 {
27589 PyThreadState* __tstate = wxPyBeginAllowThreads();
27590 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27591
27592 wxPyEndAllowThreads(__tstate);
27593 if (PyErr_Occurred()) SWIG_fail;
27594 }
27595 {
27596 resultobj = SWIG_From_long((long)(result));
27597 }
27598 return resultobj;
27599 fail:
27600 return NULL;
27601 }
27602
27603
27604 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27605 PyObject *resultobj;
27606 wxWindow *arg1 = (wxWindow *) 0 ;
27607 int arg2 ;
27608 bool result;
27609 PyObject * obj0 = 0 ;
27610 PyObject * obj1 = 0 ;
27611 char *kwnames[] = {
27612 (char *) "self",(char *) "flag", NULL
27613 };
27614
27615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27617 if (SWIG_arg_fail(1)) SWIG_fail;
27618 {
27619 arg2 = (int)(SWIG_As_int(obj1));
27620 if (SWIG_arg_fail(2)) SWIG_fail;
27621 }
27622 {
27623 PyThreadState* __tstate = wxPyBeginAllowThreads();
27624 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27625
27626 wxPyEndAllowThreads(__tstate);
27627 if (PyErr_Occurred()) SWIG_fail;
27628 }
27629 {
27630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27631 }
27632 return resultobj;
27633 fail:
27634 return NULL;
27635 }
27636
27637
27638 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27639 PyObject *resultobj;
27640 wxWindow *arg1 = (wxWindow *) 0 ;
27641 bool result;
27642 PyObject * obj0 = 0 ;
27643 char *kwnames[] = {
27644 (char *) "self", NULL
27645 };
27646
27647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27649 if (SWIG_arg_fail(1)) SWIG_fail;
27650 {
27651 PyThreadState* __tstate = wxPyBeginAllowThreads();
27652 result = (bool)((wxWindow const *)arg1)->IsRetained();
27653
27654 wxPyEndAllowThreads(__tstate);
27655 if (PyErr_Occurred()) SWIG_fail;
27656 }
27657 {
27658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27659 }
27660 return resultobj;
27661 fail:
27662 return NULL;
27663 }
27664
27665
27666 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27667 PyObject *resultobj;
27668 wxWindow *arg1 = (wxWindow *) 0 ;
27669 long arg2 ;
27670 PyObject * obj0 = 0 ;
27671 PyObject * obj1 = 0 ;
27672 char *kwnames[] = {
27673 (char *) "self",(char *) "exStyle", NULL
27674 };
27675
27676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27678 if (SWIG_arg_fail(1)) SWIG_fail;
27679 {
27680 arg2 = (long)(SWIG_As_long(obj1));
27681 if (SWIG_arg_fail(2)) SWIG_fail;
27682 }
27683 {
27684 PyThreadState* __tstate = wxPyBeginAllowThreads();
27685 (arg1)->SetExtraStyle(arg2);
27686
27687 wxPyEndAllowThreads(__tstate);
27688 if (PyErr_Occurred()) SWIG_fail;
27689 }
27690 Py_INCREF(Py_None); resultobj = Py_None;
27691 return resultobj;
27692 fail:
27693 return NULL;
27694 }
27695
27696
27697 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27698 PyObject *resultobj;
27699 wxWindow *arg1 = (wxWindow *) 0 ;
27700 long result;
27701 PyObject * obj0 = 0 ;
27702 char *kwnames[] = {
27703 (char *) "self", NULL
27704 };
27705
27706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27708 if (SWIG_arg_fail(1)) SWIG_fail;
27709 {
27710 PyThreadState* __tstate = wxPyBeginAllowThreads();
27711 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27712
27713 wxPyEndAllowThreads(__tstate);
27714 if (PyErr_Occurred()) SWIG_fail;
27715 }
27716 {
27717 resultobj = SWIG_From_long((long)(result));
27718 }
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj;
27727 wxWindow *arg1 = (wxWindow *) 0 ;
27728 bool arg2 = (bool) true ;
27729 PyObject * obj0 = 0 ;
27730 PyObject * obj1 = 0 ;
27731 char *kwnames[] = {
27732 (char *) "self",(char *) "modal", NULL
27733 };
27734
27735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27737 if (SWIG_arg_fail(1)) SWIG_fail;
27738 if (obj1) {
27739 {
27740 arg2 = (bool)(SWIG_As_bool(obj1));
27741 if (SWIG_arg_fail(2)) SWIG_fail;
27742 }
27743 }
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 (arg1)->MakeModal(arg2);
27747
27748 wxPyEndAllowThreads(__tstate);
27749 if (PyErr_Occurred()) SWIG_fail;
27750 }
27751 Py_INCREF(Py_None); resultobj = Py_None;
27752 return resultobj;
27753 fail:
27754 return NULL;
27755 }
27756
27757
27758 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27759 PyObject *resultobj;
27760 wxWindow *arg1 = (wxWindow *) 0 ;
27761 bool arg2 ;
27762 PyObject * obj0 = 0 ;
27763 PyObject * obj1 = 0 ;
27764 char *kwnames[] = {
27765 (char *) "self",(char *) "enableTheme", NULL
27766 };
27767
27768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27770 if (SWIG_arg_fail(1)) SWIG_fail;
27771 {
27772 arg2 = (bool)(SWIG_As_bool(obj1));
27773 if (SWIG_arg_fail(2)) SWIG_fail;
27774 }
27775 {
27776 PyThreadState* __tstate = wxPyBeginAllowThreads();
27777 (arg1)->SetThemeEnabled(arg2);
27778
27779 wxPyEndAllowThreads(__tstate);
27780 if (PyErr_Occurred()) SWIG_fail;
27781 }
27782 Py_INCREF(Py_None); resultobj = Py_None;
27783 return resultobj;
27784 fail:
27785 return NULL;
27786 }
27787
27788
27789 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27790 PyObject *resultobj;
27791 wxWindow *arg1 = (wxWindow *) 0 ;
27792 bool result;
27793 PyObject * obj0 = 0 ;
27794 char *kwnames[] = {
27795 (char *) "self", NULL
27796 };
27797
27798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27800 if (SWIG_arg_fail(1)) SWIG_fail;
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27804
27805 wxPyEndAllowThreads(__tstate);
27806 if (PyErr_Occurred()) SWIG_fail;
27807 }
27808 {
27809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27810 }
27811 return resultobj;
27812 fail:
27813 return NULL;
27814 }
27815
27816
27817 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27818 PyObject *resultobj;
27819 wxWindow *arg1 = (wxWindow *) 0 ;
27820 PyObject * obj0 = 0 ;
27821 char *kwnames[] = {
27822 (char *) "self", NULL
27823 };
27824
27825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27827 if (SWIG_arg_fail(1)) SWIG_fail;
27828 {
27829 PyThreadState* __tstate = wxPyBeginAllowThreads();
27830 (arg1)->SetFocus();
27831
27832 wxPyEndAllowThreads(__tstate);
27833 if (PyErr_Occurred()) SWIG_fail;
27834 }
27835 Py_INCREF(Py_None); resultobj = Py_None;
27836 return resultobj;
27837 fail:
27838 return NULL;
27839 }
27840
27841
27842 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27843 PyObject *resultobj;
27844 wxWindow *arg1 = (wxWindow *) 0 ;
27845 PyObject * obj0 = 0 ;
27846 char *kwnames[] = {
27847 (char *) "self", NULL
27848 };
27849
27850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27852 if (SWIG_arg_fail(1)) SWIG_fail;
27853 {
27854 PyThreadState* __tstate = wxPyBeginAllowThreads();
27855 (arg1)->SetFocusFromKbd();
27856
27857 wxPyEndAllowThreads(__tstate);
27858 if (PyErr_Occurred()) SWIG_fail;
27859 }
27860 Py_INCREF(Py_None); resultobj = Py_None;
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27868 PyObject *resultobj;
27869 wxWindow *result;
27870 char *kwnames[] = {
27871 NULL
27872 };
27873
27874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27875 {
27876 if (!wxPyCheckForApp()) SWIG_fail;
27877 PyThreadState* __tstate = wxPyBeginAllowThreads();
27878 result = (wxWindow *)wxWindow::FindFocus();
27879
27880 wxPyEndAllowThreads(__tstate);
27881 if (PyErr_Occurred()) SWIG_fail;
27882 }
27883 {
27884 resultobj = wxPyMake_wxObject(result, 0);
27885 }
27886 return resultobj;
27887 fail:
27888 return NULL;
27889 }
27890
27891
27892 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27893 PyObject *resultobj;
27894 wxWindow *arg1 = (wxWindow *) 0 ;
27895 bool result;
27896 PyObject * obj0 = 0 ;
27897 char *kwnames[] = {
27898 (char *) "self", NULL
27899 };
27900
27901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27903 if (SWIG_arg_fail(1)) SWIG_fail;
27904 {
27905 PyThreadState* __tstate = wxPyBeginAllowThreads();
27906 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27907
27908 wxPyEndAllowThreads(__tstate);
27909 if (PyErr_Occurred()) SWIG_fail;
27910 }
27911 {
27912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27913 }
27914 return resultobj;
27915 fail:
27916 return NULL;
27917 }
27918
27919
27920 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27921 PyObject *resultobj;
27922 wxWindow *arg1 = (wxWindow *) 0 ;
27923 bool result;
27924 PyObject * obj0 = 0 ;
27925 char *kwnames[] = {
27926 (char *) "self", NULL
27927 };
27928
27929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27931 if (SWIG_arg_fail(1)) SWIG_fail;
27932 {
27933 PyThreadState* __tstate = wxPyBeginAllowThreads();
27934 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27935
27936 wxPyEndAllowThreads(__tstate);
27937 if (PyErr_Occurred()) SWIG_fail;
27938 }
27939 {
27940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27941 }
27942 return resultobj;
27943 fail:
27944 return NULL;
27945 }
27946
27947
27948 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27949 PyObject *resultobj;
27950 wxWindow *arg1 = (wxWindow *) 0 ;
27951 wxWindow *result;
27952 PyObject * obj0 = 0 ;
27953 char *kwnames[] = {
27954 (char *) "self", NULL
27955 };
27956
27957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27959 if (SWIG_arg_fail(1)) SWIG_fail;
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27963
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 {
27968 resultobj = wxPyMake_wxObject(result, 0);
27969 }
27970 return resultobj;
27971 fail:
27972 return NULL;
27973 }
27974
27975
27976 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27977 PyObject *resultobj;
27978 wxWindow *arg1 = (wxWindow *) 0 ;
27979 wxWindow *arg2 = (wxWindow *) 0 ;
27980 wxWindow *result;
27981 PyObject * obj0 = 0 ;
27982 PyObject * obj1 = 0 ;
27983 char *kwnames[] = {
27984 (char *) "self",(char *) "child", NULL
27985 };
27986
27987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27989 if (SWIG_arg_fail(1)) SWIG_fail;
27990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27991 if (SWIG_arg_fail(2)) SWIG_fail;
27992 {
27993 PyThreadState* __tstate = wxPyBeginAllowThreads();
27994 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27995
27996 wxPyEndAllowThreads(__tstate);
27997 if (PyErr_Occurred()) SWIG_fail;
27998 }
27999 {
28000 resultobj = wxPyMake_wxObject(result, 0);
28001 }
28002 return resultobj;
28003 fail:
28004 return NULL;
28005 }
28006
28007
28008 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28009 PyObject *resultobj;
28010 wxWindow *arg1 = (wxWindow *) 0 ;
28011 wxWindow *arg2 = (wxWindow *) 0 ;
28012 PyObject * obj0 = 0 ;
28013 PyObject * obj1 = 0 ;
28014 char *kwnames[] = {
28015 (char *) "self",(char *) "win", NULL
28016 };
28017
28018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28020 if (SWIG_arg_fail(1)) SWIG_fail;
28021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28022 if (SWIG_arg_fail(2)) SWIG_fail;
28023 {
28024 PyThreadState* __tstate = wxPyBeginAllowThreads();
28025 (arg1)->SetTmpDefaultItem(arg2);
28026
28027 wxPyEndAllowThreads(__tstate);
28028 if (PyErr_Occurred()) SWIG_fail;
28029 }
28030 Py_INCREF(Py_None); resultobj = Py_None;
28031 return resultobj;
28032 fail:
28033 return NULL;
28034 }
28035
28036
28037 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28038 PyObject *resultobj;
28039 wxWindow *arg1 = (wxWindow *) 0 ;
28040 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28041 bool result;
28042 PyObject * obj0 = 0 ;
28043 PyObject * obj1 = 0 ;
28044 char *kwnames[] = {
28045 (char *) "self",(char *) "flags", NULL
28046 };
28047
28048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28050 if (SWIG_arg_fail(1)) SWIG_fail;
28051 if (obj1) {
28052 {
28053 arg2 = (int)(SWIG_As_int(obj1));
28054 if (SWIG_arg_fail(2)) SWIG_fail;
28055 }
28056 }
28057 {
28058 PyThreadState* __tstate = wxPyBeginAllowThreads();
28059 result = (bool)(arg1)->Navigate(arg2);
28060
28061 wxPyEndAllowThreads(__tstate);
28062 if (PyErr_Occurred()) SWIG_fail;
28063 }
28064 {
28065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28066 }
28067 return resultobj;
28068 fail:
28069 return NULL;
28070 }
28071
28072
28073 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28074 PyObject *resultobj;
28075 wxWindow *arg1 = (wxWindow *) 0 ;
28076 wxWindow *arg2 = (wxWindow *) 0 ;
28077 PyObject * obj0 = 0 ;
28078 PyObject * obj1 = 0 ;
28079 char *kwnames[] = {
28080 (char *) "self",(char *) "win", NULL
28081 };
28082
28083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28085 if (SWIG_arg_fail(1)) SWIG_fail;
28086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28087 if (SWIG_arg_fail(2)) SWIG_fail;
28088 {
28089 PyThreadState* __tstate = wxPyBeginAllowThreads();
28090 (arg1)->MoveAfterInTabOrder(arg2);
28091
28092 wxPyEndAllowThreads(__tstate);
28093 if (PyErr_Occurred()) SWIG_fail;
28094 }
28095 Py_INCREF(Py_None); resultobj = Py_None;
28096 return resultobj;
28097 fail:
28098 return NULL;
28099 }
28100
28101
28102 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28103 PyObject *resultobj;
28104 wxWindow *arg1 = (wxWindow *) 0 ;
28105 wxWindow *arg2 = (wxWindow *) 0 ;
28106 PyObject * obj0 = 0 ;
28107 PyObject * obj1 = 0 ;
28108 char *kwnames[] = {
28109 (char *) "self",(char *) "win", NULL
28110 };
28111
28112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28114 if (SWIG_arg_fail(1)) SWIG_fail;
28115 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28116 if (SWIG_arg_fail(2)) SWIG_fail;
28117 {
28118 PyThreadState* __tstate = wxPyBeginAllowThreads();
28119 (arg1)->MoveBeforeInTabOrder(arg2);
28120
28121 wxPyEndAllowThreads(__tstate);
28122 if (PyErr_Occurred()) SWIG_fail;
28123 }
28124 Py_INCREF(Py_None); resultobj = Py_None;
28125 return resultobj;
28126 fail:
28127 return NULL;
28128 }
28129
28130
28131 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28132 PyObject *resultobj;
28133 wxWindow *arg1 = (wxWindow *) 0 ;
28134 PyObject *result;
28135 PyObject * obj0 = 0 ;
28136 char *kwnames[] = {
28137 (char *) "self", NULL
28138 };
28139
28140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28142 if (SWIG_arg_fail(1)) SWIG_fail;
28143 {
28144 PyThreadState* __tstate = wxPyBeginAllowThreads();
28145 result = (PyObject *)wxWindow_GetChildren(arg1);
28146
28147 wxPyEndAllowThreads(__tstate);
28148 if (PyErr_Occurred()) SWIG_fail;
28149 }
28150 resultobj = result;
28151 return resultobj;
28152 fail:
28153 return NULL;
28154 }
28155
28156
28157 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28158 PyObject *resultobj;
28159 wxWindow *arg1 = (wxWindow *) 0 ;
28160 wxWindow *result;
28161 PyObject * obj0 = 0 ;
28162 char *kwnames[] = {
28163 (char *) "self", NULL
28164 };
28165
28166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28168 if (SWIG_arg_fail(1)) SWIG_fail;
28169 {
28170 PyThreadState* __tstate = wxPyBeginAllowThreads();
28171 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28172
28173 wxPyEndAllowThreads(__tstate);
28174 if (PyErr_Occurred()) SWIG_fail;
28175 }
28176 {
28177 resultobj = wxPyMake_wxObject(result, 0);
28178 }
28179 return resultobj;
28180 fail:
28181 return NULL;
28182 }
28183
28184
28185 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28186 PyObject *resultobj;
28187 wxWindow *arg1 = (wxWindow *) 0 ;
28188 wxWindow *result;
28189 PyObject * obj0 = 0 ;
28190 char *kwnames[] = {
28191 (char *) "self", NULL
28192 };
28193
28194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
28199 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28200
28201 wxPyEndAllowThreads(__tstate);
28202 if (PyErr_Occurred()) SWIG_fail;
28203 }
28204 {
28205 resultobj = wxPyMake_wxObject(result, 0);
28206 }
28207 return resultobj;
28208 fail:
28209 return NULL;
28210 }
28211
28212
28213 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28214 PyObject *resultobj;
28215 wxWindow *arg1 = (wxWindow *) 0 ;
28216 bool result;
28217 PyObject * obj0 = 0 ;
28218 char *kwnames[] = {
28219 (char *) "self", NULL
28220 };
28221
28222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28224 if (SWIG_arg_fail(1)) SWIG_fail;
28225 {
28226 PyThreadState* __tstate = wxPyBeginAllowThreads();
28227 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28228
28229 wxPyEndAllowThreads(__tstate);
28230 if (PyErr_Occurred()) SWIG_fail;
28231 }
28232 {
28233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28234 }
28235 return resultobj;
28236 fail:
28237 return NULL;
28238 }
28239
28240
28241 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28242 PyObject *resultobj;
28243 wxWindow *arg1 = (wxWindow *) 0 ;
28244 wxWindow *arg2 = (wxWindow *) 0 ;
28245 bool result;
28246 PyObject * obj0 = 0 ;
28247 PyObject * obj1 = 0 ;
28248 char *kwnames[] = {
28249 (char *) "self",(char *) "newParent", NULL
28250 };
28251
28252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28254 if (SWIG_arg_fail(1)) SWIG_fail;
28255 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28256 if (SWIG_arg_fail(2)) SWIG_fail;
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 result = (bool)(arg1)->Reparent(arg2);
28260
28261 wxPyEndAllowThreads(__tstate);
28262 if (PyErr_Occurred()) SWIG_fail;
28263 }
28264 {
28265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28266 }
28267 return resultobj;
28268 fail:
28269 return NULL;
28270 }
28271
28272
28273 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28274 PyObject *resultobj;
28275 wxWindow *arg1 = (wxWindow *) 0 ;
28276 wxWindow *arg2 = (wxWindow *) 0 ;
28277 PyObject * obj0 = 0 ;
28278 PyObject * obj1 = 0 ;
28279 char *kwnames[] = {
28280 (char *) "self",(char *) "child", NULL
28281 };
28282
28283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28285 if (SWIG_arg_fail(1)) SWIG_fail;
28286 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28287 if (SWIG_arg_fail(2)) SWIG_fail;
28288 {
28289 PyThreadState* __tstate = wxPyBeginAllowThreads();
28290 (arg1)->AddChild(arg2);
28291
28292 wxPyEndAllowThreads(__tstate);
28293 if (PyErr_Occurred()) SWIG_fail;
28294 }
28295 Py_INCREF(Py_None); resultobj = Py_None;
28296 return resultobj;
28297 fail:
28298 return NULL;
28299 }
28300
28301
28302 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28303 PyObject *resultobj;
28304 wxWindow *arg1 = (wxWindow *) 0 ;
28305 wxWindow *arg2 = (wxWindow *) 0 ;
28306 PyObject * obj0 = 0 ;
28307 PyObject * obj1 = 0 ;
28308 char *kwnames[] = {
28309 (char *) "self",(char *) "child", NULL
28310 };
28311
28312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28314 if (SWIG_arg_fail(1)) SWIG_fail;
28315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28316 if (SWIG_arg_fail(2)) SWIG_fail;
28317 {
28318 PyThreadState* __tstate = wxPyBeginAllowThreads();
28319 (arg1)->RemoveChild(arg2);
28320
28321 wxPyEndAllowThreads(__tstate);
28322 if (PyErr_Occurred()) SWIG_fail;
28323 }
28324 Py_INCREF(Py_None); resultobj = Py_None;
28325 return resultobj;
28326 fail:
28327 return NULL;
28328 }
28329
28330
28331 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28332 PyObject *resultobj;
28333 wxWindow *arg1 = (wxWindow *) 0 ;
28334 long arg2 ;
28335 wxWindow *result;
28336 PyObject * obj0 = 0 ;
28337 PyObject * obj1 = 0 ;
28338 char *kwnames[] = {
28339 (char *) "self",(char *) "winid", NULL
28340 };
28341
28342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) 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 = (long)(SWIG_As_long(obj1));
28347 if (SWIG_arg_fail(2)) SWIG_fail;
28348 }
28349 {
28350 PyThreadState* __tstate = wxPyBeginAllowThreads();
28351 result = (wxWindow *)(arg1)->FindWindow(arg2);
28352
28353 wxPyEndAllowThreads(__tstate);
28354 if (PyErr_Occurred()) SWIG_fail;
28355 }
28356 {
28357 resultobj = wxPyMake_wxObject(result, 0);
28358 }
28359 return resultobj;
28360 fail:
28361 return NULL;
28362 }
28363
28364
28365 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28366 PyObject *resultobj;
28367 wxWindow *arg1 = (wxWindow *) 0 ;
28368 wxString *arg2 = 0 ;
28369 wxWindow *result;
28370 bool temp2 = false ;
28371 PyObject * obj0 = 0 ;
28372 PyObject * obj1 = 0 ;
28373 char *kwnames[] = {
28374 (char *) "self",(char *) "name", NULL
28375 };
28376
28377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28379 if (SWIG_arg_fail(1)) SWIG_fail;
28380 {
28381 arg2 = wxString_in_helper(obj1);
28382 if (arg2 == NULL) SWIG_fail;
28383 temp2 = true;
28384 }
28385 {
28386 PyThreadState* __tstate = wxPyBeginAllowThreads();
28387 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28388
28389 wxPyEndAllowThreads(__tstate);
28390 if (PyErr_Occurred()) SWIG_fail;
28391 }
28392 {
28393 resultobj = wxPyMake_wxObject(result, 0);
28394 }
28395 {
28396 if (temp2)
28397 delete arg2;
28398 }
28399 return resultobj;
28400 fail:
28401 {
28402 if (temp2)
28403 delete arg2;
28404 }
28405 return NULL;
28406 }
28407
28408
28409 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28410 PyObject *resultobj;
28411 wxWindow *arg1 = (wxWindow *) 0 ;
28412 wxEvtHandler *result;
28413 PyObject * obj0 = 0 ;
28414 char *kwnames[] = {
28415 (char *) "self", NULL
28416 };
28417
28418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28420 if (SWIG_arg_fail(1)) SWIG_fail;
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28424
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 {
28429 resultobj = wxPyMake_wxObject(result, 0);
28430 }
28431 return resultobj;
28432 fail:
28433 return NULL;
28434 }
28435
28436
28437 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28438 PyObject *resultobj;
28439 wxWindow *arg1 = (wxWindow *) 0 ;
28440 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28441 PyObject * obj0 = 0 ;
28442 PyObject * obj1 = 0 ;
28443 char *kwnames[] = {
28444 (char *) "self",(char *) "handler", NULL
28445 };
28446
28447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28449 if (SWIG_arg_fail(1)) SWIG_fail;
28450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28451 if (SWIG_arg_fail(2)) SWIG_fail;
28452 {
28453 PyThreadState* __tstate = wxPyBeginAllowThreads();
28454 (arg1)->SetEventHandler(arg2);
28455
28456 wxPyEndAllowThreads(__tstate);
28457 if (PyErr_Occurred()) SWIG_fail;
28458 }
28459 Py_INCREF(Py_None); resultobj = Py_None;
28460 return resultobj;
28461 fail:
28462 return NULL;
28463 }
28464
28465
28466 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28467 PyObject *resultobj;
28468 wxWindow *arg1 = (wxWindow *) 0 ;
28469 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28470 PyObject * obj0 = 0 ;
28471 PyObject * obj1 = 0 ;
28472 char *kwnames[] = {
28473 (char *) "self",(char *) "handler", NULL
28474 };
28475
28476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28478 if (SWIG_arg_fail(1)) SWIG_fail;
28479 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28480 if (SWIG_arg_fail(2)) SWIG_fail;
28481 {
28482 PyThreadState* __tstate = wxPyBeginAllowThreads();
28483 (arg1)->PushEventHandler(arg2);
28484
28485 wxPyEndAllowThreads(__tstate);
28486 if (PyErr_Occurred()) SWIG_fail;
28487 }
28488 Py_INCREF(Py_None); resultobj = Py_None;
28489 return resultobj;
28490 fail:
28491 return NULL;
28492 }
28493
28494
28495 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28496 PyObject *resultobj;
28497 wxWindow *arg1 = (wxWindow *) 0 ;
28498 bool arg2 = (bool) false ;
28499 wxEvtHandler *result;
28500 PyObject * obj0 = 0 ;
28501 PyObject * obj1 = 0 ;
28502 char *kwnames[] = {
28503 (char *) "self",(char *) "deleteHandler", NULL
28504 };
28505
28506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28508 if (SWIG_arg_fail(1)) SWIG_fail;
28509 if (obj1) {
28510 {
28511 arg2 = (bool)(SWIG_As_bool(obj1));
28512 if (SWIG_arg_fail(2)) SWIG_fail;
28513 }
28514 }
28515 {
28516 PyThreadState* __tstate = wxPyBeginAllowThreads();
28517 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28518
28519 wxPyEndAllowThreads(__tstate);
28520 if (PyErr_Occurred()) SWIG_fail;
28521 }
28522 {
28523 resultobj = wxPyMake_wxObject(result, 0);
28524 }
28525 return resultobj;
28526 fail:
28527 return NULL;
28528 }
28529
28530
28531 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28532 PyObject *resultobj;
28533 wxWindow *arg1 = (wxWindow *) 0 ;
28534 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28535 bool result;
28536 PyObject * obj0 = 0 ;
28537 PyObject * obj1 = 0 ;
28538 char *kwnames[] = {
28539 (char *) "self",(char *) "handler", NULL
28540 };
28541
28542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28544 if (SWIG_arg_fail(1)) SWIG_fail;
28545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28546 if (SWIG_arg_fail(2)) SWIG_fail;
28547 {
28548 PyThreadState* __tstate = wxPyBeginAllowThreads();
28549 result = (bool)(arg1)->RemoveEventHandler(arg2);
28550
28551 wxPyEndAllowThreads(__tstate);
28552 if (PyErr_Occurred()) SWIG_fail;
28553 }
28554 {
28555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28556 }
28557 return resultobj;
28558 fail:
28559 return NULL;
28560 }
28561
28562
28563 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28564 PyObject *resultobj;
28565 wxWindow *arg1 = (wxWindow *) 0 ;
28566 wxValidator *arg2 = 0 ;
28567 PyObject * obj0 = 0 ;
28568 PyObject * obj1 = 0 ;
28569 char *kwnames[] = {
28570 (char *) "self",(char *) "validator", NULL
28571 };
28572
28573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28575 if (SWIG_arg_fail(1)) SWIG_fail;
28576 {
28577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28578 if (SWIG_arg_fail(2)) SWIG_fail;
28579 if (arg2 == NULL) {
28580 SWIG_null_ref("wxValidator");
28581 }
28582 if (SWIG_arg_fail(2)) SWIG_fail;
28583 }
28584 {
28585 PyThreadState* __tstate = wxPyBeginAllowThreads();
28586 (arg1)->SetValidator((wxValidator const &)*arg2);
28587
28588 wxPyEndAllowThreads(__tstate);
28589 if (PyErr_Occurred()) SWIG_fail;
28590 }
28591 Py_INCREF(Py_None); resultobj = Py_None;
28592 return resultobj;
28593 fail:
28594 return NULL;
28595 }
28596
28597
28598 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28599 PyObject *resultobj;
28600 wxWindow *arg1 = (wxWindow *) 0 ;
28601 wxValidator *result;
28602 PyObject * obj0 = 0 ;
28603 char *kwnames[] = {
28604 (char *) "self", NULL
28605 };
28606
28607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28609 if (SWIG_arg_fail(1)) SWIG_fail;
28610 {
28611 PyThreadState* __tstate = wxPyBeginAllowThreads();
28612 result = (wxValidator *)(arg1)->GetValidator();
28613
28614 wxPyEndAllowThreads(__tstate);
28615 if (PyErr_Occurred()) SWIG_fail;
28616 }
28617 {
28618 resultobj = wxPyMake_wxObject(result, 0);
28619 }
28620 return resultobj;
28621 fail:
28622 return NULL;
28623 }
28624
28625
28626 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28627 PyObject *resultobj;
28628 wxWindow *arg1 = (wxWindow *) 0 ;
28629 bool result;
28630 PyObject * obj0 = 0 ;
28631 char *kwnames[] = {
28632 (char *) "self", NULL
28633 };
28634
28635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28637 if (SWIG_arg_fail(1)) SWIG_fail;
28638 {
28639 PyThreadState* __tstate = wxPyBeginAllowThreads();
28640 result = (bool)(arg1)->Validate();
28641
28642 wxPyEndAllowThreads(__tstate);
28643 if (PyErr_Occurred()) SWIG_fail;
28644 }
28645 {
28646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28647 }
28648 return resultobj;
28649 fail:
28650 return NULL;
28651 }
28652
28653
28654 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28655 PyObject *resultobj;
28656 wxWindow *arg1 = (wxWindow *) 0 ;
28657 bool result;
28658 PyObject * obj0 = 0 ;
28659 char *kwnames[] = {
28660 (char *) "self", NULL
28661 };
28662
28663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28665 if (SWIG_arg_fail(1)) SWIG_fail;
28666 {
28667 PyThreadState* __tstate = wxPyBeginAllowThreads();
28668 result = (bool)(arg1)->TransferDataToWindow();
28669
28670 wxPyEndAllowThreads(__tstate);
28671 if (PyErr_Occurred()) SWIG_fail;
28672 }
28673 {
28674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28675 }
28676 return resultobj;
28677 fail:
28678 return NULL;
28679 }
28680
28681
28682 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28683 PyObject *resultobj;
28684 wxWindow *arg1 = (wxWindow *) 0 ;
28685 bool result;
28686 PyObject * obj0 = 0 ;
28687 char *kwnames[] = {
28688 (char *) "self", NULL
28689 };
28690
28691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28693 if (SWIG_arg_fail(1)) SWIG_fail;
28694 {
28695 PyThreadState* __tstate = wxPyBeginAllowThreads();
28696 result = (bool)(arg1)->TransferDataFromWindow();
28697
28698 wxPyEndAllowThreads(__tstate);
28699 if (PyErr_Occurred()) SWIG_fail;
28700 }
28701 {
28702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28703 }
28704 return resultobj;
28705 fail:
28706 return NULL;
28707 }
28708
28709
28710 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28711 PyObject *resultobj;
28712 wxWindow *arg1 = (wxWindow *) 0 ;
28713 PyObject * obj0 = 0 ;
28714 char *kwnames[] = {
28715 (char *) "self", NULL
28716 };
28717
28718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28720 if (SWIG_arg_fail(1)) SWIG_fail;
28721 {
28722 PyThreadState* __tstate = wxPyBeginAllowThreads();
28723 (arg1)->InitDialog();
28724
28725 wxPyEndAllowThreads(__tstate);
28726 if (PyErr_Occurred()) SWIG_fail;
28727 }
28728 Py_INCREF(Py_None); resultobj = Py_None;
28729 return resultobj;
28730 fail:
28731 return NULL;
28732 }
28733
28734
28735 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28736 PyObject *resultobj;
28737 wxWindow *arg1 = (wxWindow *) 0 ;
28738 wxAcceleratorTable *arg2 = 0 ;
28739 PyObject * obj0 = 0 ;
28740 PyObject * obj1 = 0 ;
28741 char *kwnames[] = {
28742 (char *) "self",(char *) "accel", NULL
28743 };
28744
28745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28747 if (SWIG_arg_fail(1)) SWIG_fail;
28748 {
28749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28750 if (SWIG_arg_fail(2)) SWIG_fail;
28751 if (arg2 == NULL) {
28752 SWIG_null_ref("wxAcceleratorTable");
28753 }
28754 if (SWIG_arg_fail(2)) SWIG_fail;
28755 }
28756 {
28757 PyThreadState* __tstate = wxPyBeginAllowThreads();
28758 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28759
28760 wxPyEndAllowThreads(__tstate);
28761 if (PyErr_Occurred()) SWIG_fail;
28762 }
28763 Py_INCREF(Py_None); resultobj = Py_None;
28764 return resultobj;
28765 fail:
28766 return NULL;
28767 }
28768
28769
28770 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28771 PyObject *resultobj;
28772 wxWindow *arg1 = (wxWindow *) 0 ;
28773 wxAcceleratorTable *result;
28774 PyObject * obj0 = 0 ;
28775 char *kwnames[] = {
28776 (char *) "self", NULL
28777 };
28778
28779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28781 if (SWIG_arg_fail(1)) SWIG_fail;
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28785
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28797 PyObject *resultobj;
28798 wxWindow *arg1 = (wxWindow *) 0 ;
28799 int arg2 ;
28800 int arg3 ;
28801 int arg4 ;
28802 bool result;
28803 PyObject * obj0 = 0 ;
28804 PyObject * obj1 = 0 ;
28805 PyObject * obj2 = 0 ;
28806 PyObject * obj3 = 0 ;
28807 char *kwnames[] = {
28808 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28809 };
28810
28811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28813 if (SWIG_arg_fail(1)) SWIG_fail;
28814 {
28815 arg2 = (int)(SWIG_As_int(obj1));
28816 if (SWIG_arg_fail(2)) SWIG_fail;
28817 }
28818 {
28819 arg3 = (int)(SWIG_As_int(obj2));
28820 if (SWIG_arg_fail(3)) SWIG_fail;
28821 }
28822 {
28823 arg4 = (int)(SWIG_As_int(obj3));
28824 if (SWIG_arg_fail(4)) SWIG_fail;
28825 }
28826 {
28827 PyThreadState* __tstate = wxPyBeginAllowThreads();
28828 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28829
28830 wxPyEndAllowThreads(__tstate);
28831 if (PyErr_Occurred()) SWIG_fail;
28832 }
28833 {
28834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28835 }
28836 return resultobj;
28837 fail:
28838 return NULL;
28839 }
28840
28841
28842 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28843 PyObject *resultobj;
28844 wxWindow *arg1 = (wxWindow *) 0 ;
28845 int arg2 ;
28846 bool result;
28847 PyObject * obj0 = 0 ;
28848 PyObject * obj1 = 0 ;
28849 char *kwnames[] = {
28850 (char *) "self",(char *) "hotkeyId", NULL
28851 };
28852
28853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28855 if (SWIG_arg_fail(1)) SWIG_fail;
28856 {
28857 arg2 = (int)(SWIG_As_int(obj1));
28858 if (SWIG_arg_fail(2)) SWIG_fail;
28859 }
28860 {
28861 PyThreadState* __tstate = wxPyBeginAllowThreads();
28862 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28863
28864 wxPyEndAllowThreads(__tstate);
28865 if (PyErr_Occurred()) SWIG_fail;
28866 }
28867 {
28868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28869 }
28870 return resultobj;
28871 fail:
28872 return NULL;
28873 }
28874
28875
28876 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28877 PyObject *resultobj;
28878 wxWindow *arg1 = (wxWindow *) 0 ;
28879 wxPoint *arg2 = 0 ;
28880 wxPoint result;
28881 wxPoint temp2 ;
28882 PyObject * obj0 = 0 ;
28883 PyObject * obj1 = 0 ;
28884 char *kwnames[] = {
28885 (char *) "self",(char *) "pt", NULL
28886 };
28887
28888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28890 if (SWIG_arg_fail(1)) SWIG_fail;
28891 {
28892 arg2 = &temp2;
28893 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28894 }
28895 {
28896 PyThreadState* __tstate = wxPyBeginAllowThreads();
28897 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28898
28899 wxPyEndAllowThreads(__tstate);
28900 if (PyErr_Occurred()) SWIG_fail;
28901 }
28902 {
28903 wxPoint * resultptr;
28904 resultptr = new wxPoint((wxPoint &)(result));
28905 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28906 }
28907 return resultobj;
28908 fail:
28909 return NULL;
28910 }
28911
28912
28913 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28914 PyObject *resultobj;
28915 wxWindow *arg1 = (wxWindow *) 0 ;
28916 wxSize *arg2 = 0 ;
28917 wxSize result;
28918 wxSize temp2 ;
28919 PyObject * obj0 = 0 ;
28920 PyObject * obj1 = 0 ;
28921 char *kwnames[] = {
28922 (char *) "self",(char *) "sz", NULL
28923 };
28924
28925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28927 if (SWIG_arg_fail(1)) SWIG_fail;
28928 {
28929 arg2 = &temp2;
28930 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28931 }
28932 {
28933 PyThreadState* __tstate = wxPyBeginAllowThreads();
28934 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28935
28936 wxPyEndAllowThreads(__tstate);
28937 if (PyErr_Occurred()) SWIG_fail;
28938 }
28939 {
28940 wxSize * resultptr;
28941 resultptr = new wxSize((wxSize &)(result));
28942 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28943 }
28944 return resultobj;
28945 fail:
28946 return NULL;
28947 }
28948
28949
28950 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28951 PyObject *resultobj;
28952 wxWindow *arg1 = (wxWindow *) 0 ;
28953 wxPoint *arg2 = 0 ;
28954 wxPoint result;
28955 wxPoint temp2 ;
28956 PyObject * obj0 = 0 ;
28957 PyObject * obj1 = 0 ;
28958 char *kwnames[] = {
28959 (char *) "self",(char *) "pt", NULL
28960 };
28961
28962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28964 if (SWIG_arg_fail(1)) SWIG_fail;
28965 {
28966 arg2 = &temp2;
28967 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28968 }
28969 {
28970 PyThreadState* __tstate = wxPyBeginAllowThreads();
28971 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28972
28973 wxPyEndAllowThreads(__tstate);
28974 if (PyErr_Occurred()) SWIG_fail;
28975 }
28976 {
28977 wxPoint * resultptr;
28978 resultptr = new wxPoint((wxPoint &)(result));
28979 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28980 }
28981 return resultobj;
28982 fail:
28983 return NULL;
28984 }
28985
28986
28987 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28988 PyObject *resultobj;
28989 wxWindow *arg1 = (wxWindow *) 0 ;
28990 wxSize *arg2 = 0 ;
28991 wxSize result;
28992 wxSize temp2 ;
28993 PyObject * obj0 = 0 ;
28994 PyObject * obj1 = 0 ;
28995 char *kwnames[] = {
28996 (char *) "self",(char *) "sz", NULL
28997 };
28998
28999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29001 if (SWIG_arg_fail(1)) SWIG_fail;
29002 {
29003 arg2 = &temp2;
29004 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29005 }
29006 {
29007 PyThreadState* __tstate = wxPyBeginAllowThreads();
29008 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29009
29010 wxPyEndAllowThreads(__tstate);
29011 if (PyErr_Occurred()) SWIG_fail;
29012 }
29013 {
29014 wxSize * resultptr;
29015 resultptr = new wxSize((wxSize &)(result));
29016 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29017 }
29018 return resultobj;
29019 fail:
29020 return NULL;
29021 }
29022
29023
29024 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29025 PyObject *resultobj;
29026 wxWindow *arg1 = (wxWindow *) 0 ;
29027 wxPoint *arg2 = 0 ;
29028 wxPoint result;
29029 wxPoint temp2 ;
29030 PyObject * obj0 = 0 ;
29031 PyObject * obj1 = 0 ;
29032 char *kwnames[] = {
29033 (char *) "self",(char *) "pt", NULL
29034 };
29035
29036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29038 if (SWIG_arg_fail(1)) SWIG_fail;
29039 {
29040 arg2 = &temp2;
29041 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29042 }
29043 {
29044 PyThreadState* __tstate = wxPyBeginAllowThreads();
29045 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29046
29047 wxPyEndAllowThreads(__tstate);
29048 if (PyErr_Occurred()) SWIG_fail;
29049 }
29050 {
29051 wxPoint * resultptr;
29052 resultptr = new wxPoint((wxPoint &)(result));
29053 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29054 }
29055 return resultobj;
29056 fail:
29057 return NULL;
29058 }
29059
29060
29061 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29062 PyObject *resultobj;
29063 wxWindow *arg1 = (wxWindow *) 0 ;
29064 wxSize *arg2 = 0 ;
29065 wxSize result;
29066 wxSize temp2 ;
29067 PyObject * obj0 = 0 ;
29068 PyObject * obj1 = 0 ;
29069 char *kwnames[] = {
29070 (char *) "self",(char *) "sz", NULL
29071 };
29072
29073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29075 if (SWIG_arg_fail(1)) SWIG_fail;
29076 {
29077 arg2 = &temp2;
29078 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29079 }
29080 {
29081 PyThreadState* __tstate = wxPyBeginAllowThreads();
29082 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29083
29084 wxPyEndAllowThreads(__tstate);
29085 if (PyErr_Occurred()) SWIG_fail;
29086 }
29087 {
29088 wxSize * resultptr;
29089 resultptr = new wxSize((wxSize &)(result));
29090 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29091 }
29092 return resultobj;
29093 fail:
29094 return NULL;
29095 }
29096
29097
29098 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29099 PyObject *resultobj;
29100 wxWindow *arg1 = (wxWindow *) 0 ;
29101 int arg2 ;
29102 int arg3 ;
29103 PyObject * obj0 = 0 ;
29104 PyObject * obj1 = 0 ;
29105 PyObject * obj2 = 0 ;
29106 char *kwnames[] = {
29107 (char *) "self",(char *) "x",(char *) "y", NULL
29108 };
29109
29110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29112 if (SWIG_arg_fail(1)) SWIG_fail;
29113 {
29114 arg2 = (int)(SWIG_As_int(obj1));
29115 if (SWIG_arg_fail(2)) SWIG_fail;
29116 }
29117 {
29118 arg3 = (int)(SWIG_As_int(obj2));
29119 if (SWIG_arg_fail(3)) SWIG_fail;
29120 }
29121 {
29122 PyThreadState* __tstate = wxPyBeginAllowThreads();
29123 (arg1)->WarpPointer(arg2,arg3);
29124
29125 wxPyEndAllowThreads(__tstate);
29126 if (PyErr_Occurred()) SWIG_fail;
29127 }
29128 Py_INCREF(Py_None); resultobj = Py_None;
29129 return resultobj;
29130 fail:
29131 return NULL;
29132 }
29133
29134
29135 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29136 PyObject *resultobj;
29137 wxWindow *arg1 = (wxWindow *) 0 ;
29138 PyObject * obj0 = 0 ;
29139 char *kwnames[] = {
29140 (char *) "self", NULL
29141 };
29142
29143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29145 if (SWIG_arg_fail(1)) SWIG_fail;
29146 {
29147 PyThreadState* __tstate = wxPyBeginAllowThreads();
29148 (arg1)->CaptureMouse();
29149
29150 wxPyEndAllowThreads(__tstate);
29151 if (PyErr_Occurred()) SWIG_fail;
29152 }
29153 Py_INCREF(Py_None); resultobj = Py_None;
29154 return resultobj;
29155 fail:
29156 return NULL;
29157 }
29158
29159
29160 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29161 PyObject *resultobj;
29162 wxWindow *arg1 = (wxWindow *) 0 ;
29163 PyObject * obj0 = 0 ;
29164 char *kwnames[] = {
29165 (char *) "self", NULL
29166 };
29167
29168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29170 if (SWIG_arg_fail(1)) SWIG_fail;
29171 {
29172 PyThreadState* __tstate = wxPyBeginAllowThreads();
29173 (arg1)->ReleaseMouse();
29174
29175 wxPyEndAllowThreads(__tstate);
29176 if (PyErr_Occurred()) SWIG_fail;
29177 }
29178 Py_INCREF(Py_None); resultobj = Py_None;
29179 return resultobj;
29180 fail:
29181 return NULL;
29182 }
29183
29184
29185 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29186 PyObject *resultobj;
29187 wxWindow *result;
29188 char *kwnames[] = {
29189 NULL
29190 };
29191
29192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29193 {
29194 if (!wxPyCheckForApp()) SWIG_fail;
29195 PyThreadState* __tstate = wxPyBeginAllowThreads();
29196 result = (wxWindow *)wxWindow::GetCapture();
29197
29198 wxPyEndAllowThreads(__tstate);
29199 if (PyErr_Occurred()) SWIG_fail;
29200 }
29201 {
29202 resultobj = wxPyMake_wxObject(result, 0);
29203 }
29204 return resultobj;
29205 fail:
29206 return NULL;
29207 }
29208
29209
29210 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29211 PyObject *resultobj;
29212 wxWindow *arg1 = (wxWindow *) 0 ;
29213 bool result;
29214 PyObject * obj0 = 0 ;
29215 char *kwnames[] = {
29216 (char *) "self", NULL
29217 };
29218
29219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
29224 result = (bool)((wxWindow const *)arg1)->HasCapture();
29225
29226 wxPyEndAllowThreads(__tstate);
29227 if (PyErr_Occurred()) SWIG_fail;
29228 }
29229 {
29230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29231 }
29232 return resultobj;
29233 fail:
29234 return NULL;
29235 }
29236
29237
29238 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29239 PyObject *resultobj;
29240 wxWindow *arg1 = (wxWindow *) 0 ;
29241 bool arg2 = (bool) true ;
29242 wxRect *arg3 = (wxRect *) NULL ;
29243 PyObject * obj0 = 0 ;
29244 PyObject * obj1 = 0 ;
29245 PyObject * obj2 = 0 ;
29246 char *kwnames[] = {
29247 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29248 };
29249
29250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29252 if (SWIG_arg_fail(1)) SWIG_fail;
29253 if (obj1) {
29254 {
29255 arg2 = (bool)(SWIG_As_bool(obj1));
29256 if (SWIG_arg_fail(2)) SWIG_fail;
29257 }
29258 }
29259 if (obj2) {
29260 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29261 if (SWIG_arg_fail(3)) SWIG_fail;
29262 }
29263 {
29264 PyThreadState* __tstate = wxPyBeginAllowThreads();
29265 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29266
29267 wxPyEndAllowThreads(__tstate);
29268 if (PyErr_Occurred()) SWIG_fail;
29269 }
29270 Py_INCREF(Py_None); resultobj = Py_None;
29271 return resultobj;
29272 fail:
29273 return NULL;
29274 }
29275
29276
29277 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29278 PyObject *resultobj;
29279 wxWindow *arg1 = (wxWindow *) 0 ;
29280 wxRect *arg2 = 0 ;
29281 bool arg3 = (bool) true ;
29282 wxRect temp2 ;
29283 PyObject * obj0 = 0 ;
29284 PyObject * obj1 = 0 ;
29285 PyObject * obj2 = 0 ;
29286 char *kwnames[] = {
29287 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29288 };
29289
29290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29292 if (SWIG_arg_fail(1)) SWIG_fail;
29293 {
29294 arg2 = &temp2;
29295 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29296 }
29297 if (obj2) {
29298 {
29299 arg3 = (bool)(SWIG_As_bool(obj2));
29300 if (SWIG_arg_fail(3)) SWIG_fail;
29301 }
29302 }
29303 {
29304 PyThreadState* __tstate = wxPyBeginAllowThreads();
29305 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29306
29307 wxPyEndAllowThreads(__tstate);
29308 if (PyErr_Occurred()) SWIG_fail;
29309 }
29310 Py_INCREF(Py_None); resultobj = Py_None;
29311 return resultobj;
29312 fail:
29313 return NULL;
29314 }
29315
29316
29317 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29318 PyObject *resultobj;
29319 wxWindow *arg1 = (wxWindow *) 0 ;
29320 PyObject * obj0 = 0 ;
29321 char *kwnames[] = {
29322 (char *) "self", NULL
29323 };
29324
29325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29327 if (SWIG_arg_fail(1)) SWIG_fail;
29328 {
29329 PyThreadState* __tstate = wxPyBeginAllowThreads();
29330 (arg1)->Update();
29331
29332 wxPyEndAllowThreads(__tstate);
29333 if (PyErr_Occurred()) SWIG_fail;
29334 }
29335 Py_INCREF(Py_None); resultobj = Py_None;
29336 return resultobj;
29337 fail:
29338 return NULL;
29339 }
29340
29341
29342 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29343 PyObject *resultobj;
29344 wxWindow *arg1 = (wxWindow *) 0 ;
29345 PyObject * obj0 = 0 ;
29346 char *kwnames[] = {
29347 (char *) "self", NULL
29348 };
29349
29350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29352 if (SWIG_arg_fail(1)) SWIG_fail;
29353 {
29354 PyThreadState* __tstate = wxPyBeginAllowThreads();
29355 (arg1)->ClearBackground();
29356
29357 wxPyEndAllowThreads(__tstate);
29358 if (PyErr_Occurred()) SWIG_fail;
29359 }
29360 Py_INCREF(Py_None); resultobj = Py_None;
29361 return resultobj;
29362 fail:
29363 return NULL;
29364 }
29365
29366
29367 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29368 PyObject *resultobj;
29369 wxWindow *arg1 = (wxWindow *) 0 ;
29370 PyObject * obj0 = 0 ;
29371 char *kwnames[] = {
29372 (char *) "self", NULL
29373 };
29374
29375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29377 if (SWIG_arg_fail(1)) SWIG_fail;
29378 {
29379 PyThreadState* __tstate = wxPyBeginAllowThreads();
29380 (arg1)->Freeze();
29381
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 Py_INCREF(Py_None); resultobj = Py_None;
29386 return resultobj;
29387 fail:
29388 return NULL;
29389 }
29390
29391
29392 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29393 PyObject *resultobj;
29394 wxWindow *arg1 = (wxWindow *) 0 ;
29395 PyObject * obj0 = 0 ;
29396 char *kwnames[] = {
29397 (char *) "self", NULL
29398 };
29399
29400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29402 if (SWIG_arg_fail(1)) SWIG_fail;
29403 {
29404 PyThreadState* __tstate = wxPyBeginAllowThreads();
29405 (arg1)->Thaw();
29406
29407 wxPyEndAllowThreads(__tstate);
29408 if (PyErr_Occurred()) SWIG_fail;
29409 }
29410 Py_INCREF(Py_None); resultobj = Py_None;
29411 return resultobj;
29412 fail:
29413 return NULL;
29414 }
29415
29416
29417 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29418 PyObject *resultobj;
29419 wxWindow *arg1 = (wxWindow *) 0 ;
29420 wxDC *arg2 = 0 ;
29421 PyObject * obj0 = 0 ;
29422 PyObject * obj1 = 0 ;
29423 char *kwnames[] = {
29424 (char *) "self",(char *) "dc", NULL
29425 };
29426
29427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29429 if (SWIG_arg_fail(1)) SWIG_fail;
29430 {
29431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29432 if (SWIG_arg_fail(2)) SWIG_fail;
29433 if (arg2 == NULL) {
29434 SWIG_null_ref("wxDC");
29435 }
29436 if (SWIG_arg_fail(2)) SWIG_fail;
29437 }
29438 {
29439 PyThreadState* __tstate = wxPyBeginAllowThreads();
29440 (arg1)->PrepareDC(*arg2);
29441
29442 wxPyEndAllowThreads(__tstate);
29443 if (PyErr_Occurred()) SWIG_fail;
29444 }
29445 Py_INCREF(Py_None); resultobj = Py_None;
29446 return resultobj;
29447 fail:
29448 return NULL;
29449 }
29450
29451
29452 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29453 PyObject *resultobj;
29454 wxWindow *arg1 = (wxWindow *) 0 ;
29455 wxRegion *result;
29456 PyObject * obj0 = 0 ;
29457 char *kwnames[] = {
29458 (char *) "self", NULL
29459 };
29460
29461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29463 if (SWIG_arg_fail(1)) SWIG_fail;
29464 {
29465 PyThreadState* __tstate = wxPyBeginAllowThreads();
29466 {
29467 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29468 result = (wxRegion *) &_result_ref;
29469 }
29470
29471 wxPyEndAllowThreads(__tstate);
29472 if (PyErr_Occurred()) SWIG_fail;
29473 }
29474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29475 return resultobj;
29476 fail:
29477 return NULL;
29478 }
29479
29480
29481 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29482 PyObject *resultobj;
29483 wxWindow *arg1 = (wxWindow *) 0 ;
29484 wxRect result;
29485 PyObject * obj0 = 0 ;
29486 char *kwnames[] = {
29487 (char *) "self", NULL
29488 };
29489
29490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29492 if (SWIG_arg_fail(1)) SWIG_fail;
29493 {
29494 PyThreadState* __tstate = wxPyBeginAllowThreads();
29495 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29496
29497 wxPyEndAllowThreads(__tstate);
29498 if (PyErr_Occurred()) SWIG_fail;
29499 }
29500 {
29501 wxRect * resultptr;
29502 resultptr = new wxRect((wxRect &)(result));
29503 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29504 }
29505 return resultobj;
29506 fail:
29507 return NULL;
29508 }
29509
29510
29511 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29512 PyObject *resultobj;
29513 wxWindow *arg1 = (wxWindow *) 0 ;
29514 int arg2 ;
29515 int arg3 ;
29516 int arg4 = (int) 1 ;
29517 int arg5 = (int) 1 ;
29518 bool result;
29519 PyObject * obj0 = 0 ;
29520 PyObject * obj1 = 0 ;
29521 PyObject * obj2 = 0 ;
29522 PyObject * obj3 = 0 ;
29523 PyObject * obj4 = 0 ;
29524 char *kwnames[] = {
29525 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29526 };
29527
29528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29530 if (SWIG_arg_fail(1)) SWIG_fail;
29531 {
29532 arg2 = (int)(SWIG_As_int(obj1));
29533 if (SWIG_arg_fail(2)) SWIG_fail;
29534 }
29535 {
29536 arg3 = (int)(SWIG_As_int(obj2));
29537 if (SWIG_arg_fail(3)) SWIG_fail;
29538 }
29539 if (obj3) {
29540 {
29541 arg4 = (int)(SWIG_As_int(obj3));
29542 if (SWIG_arg_fail(4)) SWIG_fail;
29543 }
29544 }
29545 if (obj4) {
29546 {
29547 arg5 = (int)(SWIG_As_int(obj4));
29548 if (SWIG_arg_fail(5)) SWIG_fail;
29549 }
29550 }
29551 {
29552 PyThreadState* __tstate = wxPyBeginAllowThreads();
29553 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29554
29555 wxPyEndAllowThreads(__tstate);
29556 if (PyErr_Occurred()) SWIG_fail;
29557 }
29558 {
29559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29560 }
29561 return resultobj;
29562 fail:
29563 return NULL;
29564 }
29565
29566
29567 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29568 PyObject *resultobj;
29569 wxWindow *arg1 = (wxWindow *) 0 ;
29570 wxPoint *arg2 = 0 ;
29571 bool result;
29572 wxPoint temp2 ;
29573 PyObject * obj0 = 0 ;
29574 PyObject * obj1 = 0 ;
29575 char *kwnames[] = {
29576 (char *) "self",(char *) "pt", NULL
29577 };
29578
29579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29581 if (SWIG_arg_fail(1)) SWIG_fail;
29582 {
29583 arg2 = &temp2;
29584 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29585 }
29586 {
29587 PyThreadState* __tstate = wxPyBeginAllowThreads();
29588 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29589
29590 wxPyEndAllowThreads(__tstate);
29591 if (PyErr_Occurred()) SWIG_fail;
29592 }
29593 {
29594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29595 }
29596 return resultobj;
29597 fail:
29598 return NULL;
29599 }
29600
29601
29602 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29603 PyObject *resultobj;
29604 wxWindow *arg1 = (wxWindow *) 0 ;
29605 wxRect *arg2 = 0 ;
29606 bool result;
29607 wxRect temp2 ;
29608 PyObject * obj0 = 0 ;
29609 PyObject * obj1 = 0 ;
29610 char *kwnames[] = {
29611 (char *) "self",(char *) "rect", NULL
29612 };
29613
29614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29616 if (SWIG_arg_fail(1)) SWIG_fail;
29617 {
29618 arg2 = &temp2;
29619 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29620 }
29621 {
29622 PyThreadState* __tstate = wxPyBeginAllowThreads();
29623 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29624
29625 wxPyEndAllowThreads(__tstate);
29626 if (PyErr_Occurred()) SWIG_fail;
29627 }
29628 {
29629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29630 }
29631 return resultobj;
29632 fail:
29633 return NULL;
29634 }
29635
29636
29637 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29638 PyObject *resultobj;
29639 wxWindow *arg1 = (wxWindow *) 0 ;
29640 wxVisualAttributes result;
29641 PyObject * obj0 = 0 ;
29642 char *kwnames[] = {
29643 (char *) "self", NULL
29644 };
29645
29646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29648 if (SWIG_arg_fail(1)) SWIG_fail;
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29652
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 {
29657 wxVisualAttributes * resultptr;
29658 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29659 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29660 }
29661 return resultobj;
29662 fail:
29663 return NULL;
29664 }
29665
29666
29667 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29668 PyObject *resultobj;
29669 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29670 wxVisualAttributes result;
29671 PyObject * obj0 = 0 ;
29672 char *kwnames[] = {
29673 (char *) "variant", NULL
29674 };
29675
29676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29677 if (obj0) {
29678 {
29679 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29680 if (SWIG_arg_fail(1)) SWIG_fail;
29681 }
29682 }
29683 {
29684 if (!wxPyCheckForApp()) SWIG_fail;
29685 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29687
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 {
29692 wxVisualAttributes * resultptr;
29693 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29695 }
29696 return resultobj;
29697 fail:
29698 return NULL;
29699 }
29700
29701
29702 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29703 PyObject *resultobj;
29704 wxWindow *arg1 = (wxWindow *) 0 ;
29705 wxColour *arg2 = 0 ;
29706 bool result;
29707 wxColour temp2 ;
29708 PyObject * obj0 = 0 ;
29709 PyObject * obj1 = 0 ;
29710 char *kwnames[] = {
29711 (char *) "self",(char *) "colour", NULL
29712 };
29713
29714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29716 if (SWIG_arg_fail(1)) SWIG_fail;
29717 {
29718 arg2 = &temp2;
29719 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29720 }
29721 {
29722 PyThreadState* __tstate = wxPyBeginAllowThreads();
29723 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29724
29725 wxPyEndAllowThreads(__tstate);
29726 if (PyErr_Occurred()) SWIG_fail;
29727 }
29728 {
29729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29730 }
29731 return resultobj;
29732 fail:
29733 return NULL;
29734 }
29735
29736
29737 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29738 PyObject *resultobj;
29739 wxWindow *arg1 = (wxWindow *) 0 ;
29740 wxColour *arg2 = 0 ;
29741 wxColour temp2 ;
29742 PyObject * obj0 = 0 ;
29743 PyObject * obj1 = 0 ;
29744 char *kwnames[] = {
29745 (char *) "self",(char *) "colour", NULL
29746 };
29747
29748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29750 if (SWIG_arg_fail(1)) SWIG_fail;
29751 {
29752 arg2 = &temp2;
29753 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29754 }
29755 {
29756 PyThreadState* __tstate = wxPyBeginAllowThreads();
29757 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29758
29759 wxPyEndAllowThreads(__tstate);
29760 if (PyErr_Occurred()) SWIG_fail;
29761 }
29762 Py_INCREF(Py_None); resultobj = Py_None;
29763 return resultobj;
29764 fail:
29765 return NULL;
29766 }
29767
29768
29769 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29770 PyObject *resultobj;
29771 wxWindow *arg1 = (wxWindow *) 0 ;
29772 wxColour *arg2 = 0 ;
29773 bool result;
29774 wxColour temp2 ;
29775 PyObject * obj0 = 0 ;
29776 PyObject * obj1 = 0 ;
29777 char *kwnames[] = {
29778 (char *) "self",(char *) "colour", NULL
29779 };
29780
29781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29783 if (SWIG_arg_fail(1)) SWIG_fail;
29784 {
29785 arg2 = &temp2;
29786 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29787 }
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29791
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 {
29796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29797 }
29798 return resultobj;
29799 fail:
29800 return NULL;
29801 }
29802
29803
29804 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29805 PyObject *resultobj;
29806 wxWindow *arg1 = (wxWindow *) 0 ;
29807 wxColour *arg2 = 0 ;
29808 wxColour temp2 ;
29809 PyObject * obj0 = 0 ;
29810 PyObject * obj1 = 0 ;
29811 char *kwnames[] = {
29812 (char *) "self",(char *) "colour", NULL
29813 };
29814
29815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29817 if (SWIG_arg_fail(1)) SWIG_fail;
29818 {
29819 arg2 = &temp2;
29820 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29821 }
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29825
29826 wxPyEndAllowThreads(__tstate);
29827 if (PyErr_Occurred()) SWIG_fail;
29828 }
29829 Py_INCREF(Py_None); resultobj = Py_None;
29830 return resultobj;
29831 fail:
29832 return NULL;
29833 }
29834
29835
29836 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29837 PyObject *resultobj;
29838 wxWindow *arg1 = (wxWindow *) 0 ;
29839 wxColour result;
29840 PyObject * obj0 = 0 ;
29841 char *kwnames[] = {
29842 (char *) "self", NULL
29843 };
29844
29845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29847 if (SWIG_arg_fail(1)) SWIG_fail;
29848 {
29849 PyThreadState* __tstate = wxPyBeginAllowThreads();
29850 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29851
29852 wxPyEndAllowThreads(__tstate);
29853 if (PyErr_Occurred()) SWIG_fail;
29854 }
29855 {
29856 wxColour * resultptr;
29857 resultptr = new wxColour((wxColour &)(result));
29858 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29859 }
29860 return resultobj;
29861 fail:
29862 return NULL;
29863 }
29864
29865
29866 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29867 PyObject *resultobj;
29868 wxWindow *arg1 = (wxWindow *) 0 ;
29869 wxColour result;
29870 PyObject * obj0 = 0 ;
29871 char *kwnames[] = {
29872 (char *) "self", NULL
29873 };
29874
29875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29877 if (SWIG_arg_fail(1)) SWIG_fail;
29878 {
29879 PyThreadState* __tstate = wxPyBeginAllowThreads();
29880 result = ((wxWindow const *)arg1)->GetForegroundColour();
29881
29882 wxPyEndAllowThreads(__tstate);
29883 if (PyErr_Occurred()) SWIG_fail;
29884 }
29885 {
29886 wxColour * resultptr;
29887 resultptr = new wxColour((wxColour &)(result));
29888 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29889 }
29890 return resultobj;
29891 fail:
29892 return NULL;
29893 }
29894
29895
29896 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29897 PyObject *resultobj;
29898 wxWindow *arg1 = (wxWindow *) 0 ;
29899 bool result;
29900 PyObject * obj0 = 0 ;
29901 char *kwnames[] = {
29902 (char *) "self", NULL
29903 };
29904
29905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29907 if (SWIG_arg_fail(1)) SWIG_fail;
29908 {
29909 PyThreadState* __tstate = wxPyBeginAllowThreads();
29910 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29911
29912 wxPyEndAllowThreads(__tstate);
29913 if (PyErr_Occurred()) SWIG_fail;
29914 }
29915 {
29916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29917 }
29918 return resultobj;
29919 fail:
29920 return NULL;
29921 }
29922
29923
29924 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29925 PyObject *resultobj;
29926 wxWindow *arg1 = (wxWindow *) 0 ;
29927 bool result;
29928 PyObject * obj0 = 0 ;
29929 char *kwnames[] = {
29930 (char *) "self", NULL
29931 };
29932
29933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29935 if (SWIG_arg_fail(1)) SWIG_fail;
29936 {
29937 PyThreadState* __tstate = wxPyBeginAllowThreads();
29938 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29939
29940 wxPyEndAllowThreads(__tstate);
29941 if (PyErr_Occurred()) SWIG_fail;
29942 }
29943 {
29944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29945 }
29946 return resultobj;
29947 fail:
29948 return NULL;
29949 }
29950
29951
29952 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29953 PyObject *resultobj;
29954 wxWindow *arg1 = (wxWindow *) 0 ;
29955 wxBackgroundStyle arg2 ;
29956 bool result;
29957 PyObject * obj0 = 0 ;
29958 PyObject * obj1 = 0 ;
29959 char *kwnames[] = {
29960 (char *) "self",(char *) "style", NULL
29961 };
29962
29963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29965 if (SWIG_arg_fail(1)) SWIG_fail;
29966 {
29967 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29968 if (SWIG_arg_fail(2)) SWIG_fail;
29969 }
29970 {
29971 PyThreadState* __tstate = wxPyBeginAllowThreads();
29972 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29973
29974 wxPyEndAllowThreads(__tstate);
29975 if (PyErr_Occurred()) SWIG_fail;
29976 }
29977 {
29978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29979 }
29980 return resultobj;
29981 fail:
29982 return NULL;
29983 }
29984
29985
29986 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29987 PyObject *resultobj;
29988 wxWindow *arg1 = (wxWindow *) 0 ;
29989 wxBackgroundStyle result;
29990 PyObject * obj0 = 0 ;
29991 char *kwnames[] = {
29992 (char *) "self", NULL
29993 };
29994
29995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29997 if (SWIG_arg_fail(1)) SWIG_fail;
29998 {
29999 PyThreadState* __tstate = wxPyBeginAllowThreads();
30000 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30001
30002 wxPyEndAllowThreads(__tstate);
30003 if (PyErr_Occurred()) SWIG_fail;
30004 }
30005 resultobj = SWIG_From_int((result));
30006 return resultobj;
30007 fail:
30008 return NULL;
30009 }
30010
30011
30012 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30013 PyObject *resultobj;
30014 wxWindow *arg1 = (wxWindow *) 0 ;
30015 bool result;
30016 PyObject * obj0 = 0 ;
30017 char *kwnames[] = {
30018 (char *) "self", NULL
30019 };
30020
30021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30023 if (SWIG_arg_fail(1)) SWIG_fail;
30024 {
30025 PyThreadState* __tstate = wxPyBeginAllowThreads();
30026 result = (bool)(arg1)->HasTransparentBackground();
30027
30028 wxPyEndAllowThreads(__tstate);
30029 if (PyErr_Occurred()) SWIG_fail;
30030 }
30031 {
30032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30033 }
30034 return resultobj;
30035 fail:
30036 return NULL;
30037 }
30038
30039
30040 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30041 PyObject *resultobj;
30042 wxWindow *arg1 = (wxWindow *) 0 ;
30043 wxCursor *arg2 = 0 ;
30044 bool result;
30045 PyObject * obj0 = 0 ;
30046 PyObject * obj1 = 0 ;
30047 char *kwnames[] = {
30048 (char *) "self",(char *) "cursor", NULL
30049 };
30050
30051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30053 if (SWIG_arg_fail(1)) SWIG_fail;
30054 {
30055 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30056 if (SWIG_arg_fail(2)) SWIG_fail;
30057 if (arg2 == NULL) {
30058 SWIG_null_ref("wxCursor");
30059 }
30060 if (SWIG_arg_fail(2)) SWIG_fail;
30061 }
30062 {
30063 PyThreadState* __tstate = wxPyBeginAllowThreads();
30064 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30065
30066 wxPyEndAllowThreads(__tstate);
30067 if (PyErr_Occurred()) SWIG_fail;
30068 }
30069 {
30070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30071 }
30072 return resultobj;
30073 fail:
30074 return NULL;
30075 }
30076
30077
30078 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30079 PyObject *resultobj;
30080 wxWindow *arg1 = (wxWindow *) 0 ;
30081 wxCursor result;
30082 PyObject * obj0 = 0 ;
30083 char *kwnames[] = {
30084 (char *) "self", NULL
30085 };
30086
30087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30089 if (SWIG_arg_fail(1)) SWIG_fail;
30090 {
30091 PyThreadState* __tstate = wxPyBeginAllowThreads();
30092 result = (arg1)->GetCursor();
30093
30094 wxPyEndAllowThreads(__tstate);
30095 if (PyErr_Occurred()) SWIG_fail;
30096 }
30097 {
30098 wxCursor * resultptr;
30099 resultptr = new wxCursor((wxCursor &)(result));
30100 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30101 }
30102 return resultobj;
30103 fail:
30104 return NULL;
30105 }
30106
30107
30108 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30109 PyObject *resultobj;
30110 wxWindow *arg1 = (wxWindow *) 0 ;
30111 wxFont *arg2 = 0 ;
30112 bool result;
30113 PyObject * obj0 = 0 ;
30114 PyObject * obj1 = 0 ;
30115 char *kwnames[] = {
30116 (char *) "self",(char *) "font", NULL
30117 };
30118
30119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30121 if (SWIG_arg_fail(1)) SWIG_fail;
30122 {
30123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30124 if (SWIG_arg_fail(2)) SWIG_fail;
30125 if (arg2 == NULL) {
30126 SWIG_null_ref("wxFont");
30127 }
30128 if (SWIG_arg_fail(2)) SWIG_fail;
30129 }
30130 {
30131 PyThreadState* __tstate = wxPyBeginAllowThreads();
30132 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30133
30134 wxPyEndAllowThreads(__tstate);
30135 if (PyErr_Occurred()) SWIG_fail;
30136 }
30137 {
30138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30139 }
30140 return resultobj;
30141 fail:
30142 return NULL;
30143 }
30144
30145
30146 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30147 PyObject *resultobj;
30148 wxWindow *arg1 = (wxWindow *) 0 ;
30149 wxFont *arg2 = 0 ;
30150 PyObject * obj0 = 0 ;
30151 PyObject * obj1 = 0 ;
30152 char *kwnames[] = {
30153 (char *) "self",(char *) "font", NULL
30154 };
30155
30156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30158 if (SWIG_arg_fail(1)) SWIG_fail;
30159 {
30160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30161 if (SWIG_arg_fail(2)) SWIG_fail;
30162 if (arg2 == NULL) {
30163 SWIG_null_ref("wxFont");
30164 }
30165 if (SWIG_arg_fail(2)) SWIG_fail;
30166 }
30167 {
30168 PyThreadState* __tstate = wxPyBeginAllowThreads();
30169 (arg1)->SetOwnFont((wxFont const &)*arg2);
30170
30171 wxPyEndAllowThreads(__tstate);
30172 if (PyErr_Occurred()) SWIG_fail;
30173 }
30174 Py_INCREF(Py_None); resultobj = Py_None;
30175 return resultobj;
30176 fail:
30177 return NULL;
30178 }
30179
30180
30181 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30182 PyObject *resultobj;
30183 wxWindow *arg1 = (wxWindow *) 0 ;
30184 wxFont result;
30185 PyObject * obj0 = 0 ;
30186 char *kwnames[] = {
30187 (char *) "self", NULL
30188 };
30189
30190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30192 if (SWIG_arg_fail(1)) SWIG_fail;
30193 {
30194 PyThreadState* __tstate = wxPyBeginAllowThreads();
30195 result = (arg1)->GetFont();
30196
30197 wxPyEndAllowThreads(__tstate);
30198 if (PyErr_Occurred()) SWIG_fail;
30199 }
30200 {
30201 wxFont * resultptr;
30202 resultptr = new wxFont((wxFont &)(result));
30203 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30204 }
30205 return resultobj;
30206 fail:
30207 return NULL;
30208 }
30209
30210
30211 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30212 PyObject *resultobj;
30213 wxWindow *arg1 = (wxWindow *) 0 ;
30214 wxCaret *arg2 = (wxCaret *) 0 ;
30215 PyObject * obj0 = 0 ;
30216 PyObject * obj1 = 0 ;
30217 char *kwnames[] = {
30218 (char *) "self",(char *) "caret", NULL
30219 };
30220
30221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30223 if (SWIG_arg_fail(1)) SWIG_fail;
30224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30225 if (SWIG_arg_fail(2)) SWIG_fail;
30226 {
30227 PyThreadState* __tstate = wxPyBeginAllowThreads();
30228 (arg1)->SetCaret(arg2);
30229
30230 wxPyEndAllowThreads(__tstate);
30231 if (PyErr_Occurred()) SWIG_fail;
30232 }
30233 Py_INCREF(Py_None); resultobj = Py_None;
30234 return resultobj;
30235 fail:
30236 return NULL;
30237 }
30238
30239
30240 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30241 PyObject *resultobj;
30242 wxWindow *arg1 = (wxWindow *) 0 ;
30243 wxCaret *result;
30244 PyObject * obj0 = 0 ;
30245 char *kwnames[] = {
30246 (char *) "self", NULL
30247 };
30248
30249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30251 if (SWIG_arg_fail(1)) SWIG_fail;
30252 {
30253 PyThreadState* __tstate = wxPyBeginAllowThreads();
30254 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30255
30256 wxPyEndAllowThreads(__tstate);
30257 if (PyErr_Occurred()) SWIG_fail;
30258 }
30259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30260 return resultobj;
30261 fail:
30262 return NULL;
30263 }
30264
30265
30266 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30267 PyObject *resultobj;
30268 wxWindow *arg1 = (wxWindow *) 0 ;
30269 int result;
30270 PyObject * obj0 = 0 ;
30271 char *kwnames[] = {
30272 (char *) "self", NULL
30273 };
30274
30275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30277 if (SWIG_arg_fail(1)) SWIG_fail;
30278 {
30279 PyThreadState* __tstate = wxPyBeginAllowThreads();
30280 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30281
30282 wxPyEndAllowThreads(__tstate);
30283 if (PyErr_Occurred()) SWIG_fail;
30284 }
30285 {
30286 resultobj = SWIG_From_int((int)(result));
30287 }
30288 return resultobj;
30289 fail:
30290 return NULL;
30291 }
30292
30293
30294 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30295 PyObject *resultobj;
30296 wxWindow *arg1 = (wxWindow *) 0 ;
30297 int result;
30298 PyObject * obj0 = 0 ;
30299 char *kwnames[] = {
30300 (char *) "self", NULL
30301 };
30302
30303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30305 if (SWIG_arg_fail(1)) SWIG_fail;
30306 {
30307 PyThreadState* __tstate = wxPyBeginAllowThreads();
30308 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30309
30310 wxPyEndAllowThreads(__tstate);
30311 if (PyErr_Occurred()) SWIG_fail;
30312 }
30313 {
30314 resultobj = SWIG_From_int((int)(result));
30315 }
30316 return resultobj;
30317 fail:
30318 return NULL;
30319 }
30320
30321
30322 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30323 PyObject *resultobj;
30324 wxWindow *arg1 = (wxWindow *) 0 ;
30325 wxString *arg2 = 0 ;
30326 int *arg3 = (int *) 0 ;
30327 int *arg4 = (int *) 0 ;
30328 bool temp2 = false ;
30329 int temp3 ;
30330 int res3 = 0 ;
30331 int temp4 ;
30332 int res4 = 0 ;
30333 PyObject * obj0 = 0 ;
30334 PyObject * obj1 = 0 ;
30335 char *kwnames[] = {
30336 (char *) "self",(char *) "string", NULL
30337 };
30338
30339 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30340 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30343 if (SWIG_arg_fail(1)) SWIG_fail;
30344 {
30345 arg2 = wxString_in_helper(obj1);
30346 if (arg2 == NULL) SWIG_fail;
30347 temp2 = true;
30348 }
30349 {
30350 PyThreadState* __tstate = wxPyBeginAllowThreads();
30351 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30352
30353 wxPyEndAllowThreads(__tstate);
30354 if (PyErr_Occurred()) SWIG_fail;
30355 }
30356 Py_INCREF(Py_None); resultobj = Py_None;
30357 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30358 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30359 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30360 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30361 {
30362 if (temp2)
30363 delete arg2;
30364 }
30365 return resultobj;
30366 fail:
30367 {
30368 if (temp2)
30369 delete arg2;
30370 }
30371 return NULL;
30372 }
30373
30374
30375 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30376 PyObject *resultobj;
30377 wxWindow *arg1 = (wxWindow *) 0 ;
30378 wxString *arg2 = 0 ;
30379 int *arg3 = (int *) 0 ;
30380 int *arg4 = (int *) 0 ;
30381 int *arg5 = (int *) 0 ;
30382 int *arg6 = (int *) 0 ;
30383 wxFont *arg7 = (wxFont *) NULL ;
30384 bool temp2 = false ;
30385 int temp3 ;
30386 int res3 = 0 ;
30387 int temp4 ;
30388 int res4 = 0 ;
30389 int temp5 ;
30390 int res5 = 0 ;
30391 int temp6 ;
30392 int res6 = 0 ;
30393 PyObject * obj0 = 0 ;
30394 PyObject * obj1 = 0 ;
30395 PyObject * obj2 = 0 ;
30396 char *kwnames[] = {
30397 (char *) "self",(char *) "string",(char *) "font", NULL
30398 };
30399
30400 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30401 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30402 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30403 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30406 if (SWIG_arg_fail(1)) SWIG_fail;
30407 {
30408 arg2 = wxString_in_helper(obj1);
30409 if (arg2 == NULL) SWIG_fail;
30410 temp2 = true;
30411 }
30412 if (obj2) {
30413 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30414 if (SWIG_arg_fail(7)) SWIG_fail;
30415 }
30416 {
30417 PyThreadState* __tstate = wxPyBeginAllowThreads();
30418 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30419
30420 wxPyEndAllowThreads(__tstate);
30421 if (PyErr_Occurred()) SWIG_fail;
30422 }
30423 Py_INCREF(Py_None); resultobj = Py_None;
30424 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30425 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30426 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30427 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30428 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30429 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30430 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30431 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30432 {
30433 if (temp2)
30434 delete arg2;
30435 }
30436 return resultobj;
30437 fail:
30438 {
30439 if (temp2)
30440 delete arg2;
30441 }
30442 return NULL;
30443 }
30444
30445
30446 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30447 PyObject *resultobj;
30448 wxWindow *arg1 = (wxWindow *) 0 ;
30449 int *arg2 = (int *) 0 ;
30450 int *arg3 = (int *) 0 ;
30451 int temp2 ;
30452 int res2 = 0 ;
30453 int temp3 ;
30454 int res3 = 0 ;
30455 PyObject * obj0 = 0 ;
30456 PyObject * obj1 = 0 ;
30457 PyObject * obj2 = 0 ;
30458 char *kwnames[] = {
30459 (char *) "self",(char *) "x",(char *) "y", NULL
30460 };
30461
30462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30464 if (SWIG_arg_fail(1)) SWIG_fail;
30465 {
30466 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30467 temp2 = SWIG_As_int(obj1);
30468 if (SWIG_arg_fail(2)) SWIG_fail;
30469 arg2 = &temp2;
30470 res2 = SWIG_NEWOBJ;
30471 }
30472 }
30473 {
30474 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30475 temp3 = SWIG_As_int(obj2);
30476 if (SWIG_arg_fail(3)) SWIG_fail;
30477 arg3 = &temp3;
30478 res3 = SWIG_NEWOBJ;
30479 }
30480 }
30481 {
30482 PyThreadState* __tstate = wxPyBeginAllowThreads();
30483 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30484
30485 wxPyEndAllowThreads(__tstate);
30486 if (PyErr_Occurred()) SWIG_fail;
30487 }
30488 Py_INCREF(Py_None); resultobj = Py_None;
30489 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30490 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30491 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30492 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30493 return resultobj;
30494 fail:
30495 return NULL;
30496 }
30497
30498
30499 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30500 PyObject *resultobj;
30501 wxWindow *arg1 = (wxWindow *) 0 ;
30502 int *arg2 = (int *) 0 ;
30503 int *arg3 = (int *) 0 ;
30504 int temp2 ;
30505 int res2 = 0 ;
30506 int temp3 ;
30507 int res3 = 0 ;
30508 PyObject * obj0 = 0 ;
30509 PyObject * obj1 = 0 ;
30510 PyObject * obj2 = 0 ;
30511 char *kwnames[] = {
30512 (char *) "self",(char *) "x",(char *) "y", NULL
30513 };
30514
30515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30517 if (SWIG_arg_fail(1)) SWIG_fail;
30518 {
30519 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30520 temp2 = SWIG_As_int(obj1);
30521 if (SWIG_arg_fail(2)) SWIG_fail;
30522 arg2 = &temp2;
30523 res2 = SWIG_NEWOBJ;
30524 }
30525 }
30526 {
30527 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30528 temp3 = SWIG_As_int(obj2);
30529 if (SWIG_arg_fail(3)) SWIG_fail;
30530 arg3 = &temp3;
30531 res3 = SWIG_NEWOBJ;
30532 }
30533 }
30534 {
30535 PyThreadState* __tstate = wxPyBeginAllowThreads();
30536 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30537
30538 wxPyEndAllowThreads(__tstate);
30539 if (PyErr_Occurred()) SWIG_fail;
30540 }
30541 Py_INCREF(Py_None); resultobj = Py_None;
30542 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30543 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30544 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30545 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30553 PyObject *resultobj;
30554 wxWindow *arg1 = (wxWindow *) 0 ;
30555 wxPoint *arg2 = 0 ;
30556 wxPoint result;
30557 wxPoint temp2 ;
30558 PyObject * obj0 = 0 ;
30559 PyObject * obj1 = 0 ;
30560 char *kwnames[] = {
30561 (char *) "self",(char *) "pt", NULL
30562 };
30563
30564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30566 if (SWIG_arg_fail(1)) SWIG_fail;
30567 {
30568 arg2 = &temp2;
30569 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30570 }
30571 {
30572 PyThreadState* __tstate = wxPyBeginAllowThreads();
30573 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30574
30575 wxPyEndAllowThreads(__tstate);
30576 if (PyErr_Occurred()) SWIG_fail;
30577 }
30578 {
30579 wxPoint * resultptr;
30580 resultptr = new wxPoint((wxPoint &)(result));
30581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30582 }
30583 return resultobj;
30584 fail:
30585 return NULL;
30586 }
30587
30588
30589 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30590 PyObject *resultobj;
30591 wxWindow *arg1 = (wxWindow *) 0 ;
30592 wxPoint *arg2 = 0 ;
30593 wxPoint result;
30594 wxPoint temp2 ;
30595 PyObject * obj0 = 0 ;
30596 PyObject * obj1 = 0 ;
30597 char *kwnames[] = {
30598 (char *) "self",(char *) "pt", NULL
30599 };
30600
30601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30603 if (SWIG_arg_fail(1)) SWIG_fail;
30604 {
30605 arg2 = &temp2;
30606 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30607 }
30608 {
30609 PyThreadState* __tstate = wxPyBeginAllowThreads();
30610 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30611
30612 wxPyEndAllowThreads(__tstate);
30613 if (PyErr_Occurred()) SWIG_fail;
30614 }
30615 {
30616 wxPoint * resultptr;
30617 resultptr = new wxPoint((wxPoint &)(result));
30618 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30619 }
30620 return resultobj;
30621 fail:
30622 return NULL;
30623 }
30624
30625
30626 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30627 PyObject *resultobj;
30628 wxWindow *arg1 = (wxWindow *) 0 ;
30629 int arg2 ;
30630 int arg3 ;
30631 wxHitTest result;
30632 PyObject * obj0 = 0 ;
30633 PyObject * obj1 = 0 ;
30634 PyObject * obj2 = 0 ;
30635 char *kwnames[] = {
30636 (char *) "self",(char *) "x",(char *) "y", NULL
30637 };
30638
30639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30641 if (SWIG_arg_fail(1)) SWIG_fail;
30642 {
30643 arg2 = (int)(SWIG_As_int(obj1));
30644 if (SWIG_arg_fail(2)) SWIG_fail;
30645 }
30646 {
30647 arg3 = (int)(SWIG_As_int(obj2));
30648 if (SWIG_arg_fail(3)) SWIG_fail;
30649 }
30650 {
30651 PyThreadState* __tstate = wxPyBeginAllowThreads();
30652 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30653
30654 wxPyEndAllowThreads(__tstate);
30655 if (PyErr_Occurred()) SWIG_fail;
30656 }
30657 resultobj = SWIG_From_int((result));
30658 return resultobj;
30659 fail:
30660 return NULL;
30661 }
30662
30663
30664 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30665 PyObject *resultobj;
30666 wxWindow *arg1 = (wxWindow *) 0 ;
30667 wxPoint *arg2 = 0 ;
30668 wxHitTest result;
30669 wxPoint temp2 ;
30670 PyObject * obj0 = 0 ;
30671 PyObject * obj1 = 0 ;
30672 char *kwnames[] = {
30673 (char *) "self",(char *) "pt", NULL
30674 };
30675
30676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30678 if (SWIG_arg_fail(1)) SWIG_fail;
30679 {
30680 arg2 = &temp2;
30681 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30682 }
30683 {
30684 PyThreadState* __tstate = wxPyBeginAllowThreads();
30685 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30686
30687 wxPyEndAllowThreads(__tstate);
30688 if (PyErr_Occurred()) SWIG_fail;
30689 }
30690 resultobj = SWIG_From_int((result));
30691 return resultobj;
30692 fail:
30693 return NULL;
30694 }
30695
30696
30697 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30698 PyObject *resultobj;
30699 wxWindow *arg1 = (wxWindow *) 0 ;
30700 long arg2 ;
30701 wxBorder result;
30702 PyObject * obj0 = 0 ;
30703 PyObject * obj1 = 0 ;
30704
30705 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30707 if (SWIG_arg_fail(1)) SWIG_fail;
30708 {
30709 arg2 = (long)(SWIG_As_long(obj1));
30710 if (SWIG_arg_fail(2)) SWIG_fail;
30711 }
30712 {
30713 PyThreadState* __tstate = wxPyBeginAllowThreads();
30714 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30715
30716 wxPyEndAllowThreads(__tstate);
30717 if (PyErr_Occurred()) SWIG_fail;
30718 }
30719 resultobj = SWIG_From_int((result));
30720 return resultobj;
30721 fail:
30722 return NULL;
30723 }
30724
30725
30726 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30727 PyObject *resultobj;
30728 wxWindow *arg1 = (wxWindow *) 0 ;
30729 wxBorder result;
30730 PyObject * obj0 = 0 ;
30731
30732 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30734 if (SWIG_arg_fail(1)) SWIG_fail;
30735 {
30736 PyThreadState* __tstate = wxPyBeginAllowThreads();
30737 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30738
30739 wxPyEndAllowThreads(__tstate);
30740 if (PyErr_Occurred()) SWIG_fail;
30741 }
30742 resultobj = SWIG_From_int((result));
30743 return resultobj;
30744 fail:
30745 return NULL;
30746 }
30747
30748
30749 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30750 int argc;
30751 PyObject *argv[3];
30752 int ii;
30753
30754 argc = PyObject_Length(args);
30755 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30756 argv[ii] = PyTuple_GetItem(args,ii);
30757 }
30758 if (argc == 1) {
30759 int _v;
30760 {
30761 void *ptr;
30762 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30763 _v = 0;
30764 PyErr_Clear();
30765 } else {
30766 _v = 1;
30767 }
30768 }
30769 if (_v) {
30770 return _wrap_Window_GetBorder__SWIG_1(self,args);
30771 }
30772 }
30773 if (argc == 2) {
30774 int _v;
30775 {
30776 void *ptr;
30777 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30778 _v = 0;
30779 PyErr_Clear();
30780 } else {
30781 _v = 1;
30782 }
30783 }
30784 if (_v) {
30785 _v = SWIG_Check_long(argv[1]);
30786 if (_v) {
30787 return _wrap_Window_GetBorder__SWIG_0(self,args);
30788 }
30789 }
30790 }
30791
30792 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30793 return NULL;
30794 }
30795
30796
30797 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30798 PyObject *resultobj;
30799 wxWindow *arg1 = (wxWindow *) 0 ;
30800 long arg2 = (long) wxUPDATE_UI_NONE ;
30801 PyObject * obj0 = 0 ;
30802 PyObject * obj1 = 0 ;
30803 char *kwnames[] = {
30804 (char *) "self",(char *) "flags", NULL
30805 };
30806
30807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30809 if (SWIG_arg_fail(1)) SWIG_fail;
30810 if (obj1) {
30811 {
30812 arg2 = (long)(SWIG_As_long(obj1));
30813 if (SWIG_arg_fail(2)) SWIG_fail;
30814 }
30815 }
30816 {
30817 PyThreadState* __tstate = wxPyBeginAllowThreads();
30818 (arg1)->UpdateWindowUI(arg2);
30819
30820 wxPyEndAllowThreads(__tstate);
30821 if (PyErr_Occurred()) SWIG_fail;
30822 }
30823 Py_INCREF(Py_None); resultobj = Py_None;
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30831 PyObject *resultobj;
30832 wxWindow *arg1 = (wxWindow *) 0 ;
30833 wxMenu *arg2 = (wxMenu *) 0 ;
30834 int arg3 = (int) -1 ;
30835 int arg4 = (int) -1 ;
30836 bool result;
30837 PyObject * obj0 = 0 ;
30838 PyObject * obj1 = 0 ;
30839 PyObject * obj2 = 0 ;
30840 PyObject * obj3 = 0 ;
30841 char *kwnames[] = {
30842 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30843 };
30844
30845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30847 if (SWIG_arg_fail(1)) SWIG_fail;
30848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30849 if (SWIG_arg_fail(2)) SWIG_fail;
30850 if (obj2) {
30851 {
30852 arg3 = (int)(SWIG_As_int(obj2));
30853 if (SWIG_arg_fail(3)) SWIG_fail;
30854 }
30855 }
30856 if (obj3) {
30857 {
30858 arg4 = (int)(SWIG_As_int(obj3));
30859 if (SWIG_arg_fail(4)) SWIG_fail;
30860 }
30861 }
30862 {
30863 PyThreadState* __tstate = wxPyBeginAllowThreads();
30864 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30865
30866 wxPyEndAllowThreads(__tstate);
30867 if (PyErr_Occurred()) SWIG_fail;
30868 }
30869 {
30870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30871 }
30872 return resultobj;
30873 fail:
30874 return NULL;
30875 }
30876
30877
30878 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30879 PyObject *resultobj;
30880 wxWindow *arg1 = (wxWindow *) 0 ;
30881 wxMenu *arg2 = (wxMenu *) 0 ;
30882 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30883 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30884 bool result;
30885 wxPoint temp3 ;
30886 PyObject * obj0 = 0 ;
30887 PyObject * obj1 = 0 ;
30888 PyObject * obj2 = 0 ;
30889 char *kwnames[] = {
30890 (char *) "self",(char *) "menu",(char *) "pos", NULL
30891 };
30892
30893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30895 if (SWIG_arg_fail(1)) SWIG_fail;
30896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30897 if (SWIG_arg_fail(2)) SWIG_fail;
30898 if (obj2) {
30899 {
30900 arg3 = &temp3;
30901 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30902 }
30903 }
30904 {
30905 PyThreadState* __tstate = wxPyBeginAllowThreads();
30906 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30907
30908 wxPyEndAllowThreads(__tstate);
30909 if (PyErr_Occurred()) SWIG_fail;
30910 }
30911 {
30912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30913 }
30914 return resultobj;
30915 fail:
30916 return NULL;
30917 }
30918
30919
30920 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30921 PyObject *resultobj;
30922 wxWindow *arg1 = (wxWindow *) 0 ;
30923 long result;
30924 PyObject * obj0 = 0 ;
30925 char *kwnames[] = {
30926 (char *) "self", NULL
30927 };
30928
30929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30931 if (SWIG_arg_fail(1)) SWIG_fail;
30932 {
30933 PyThreadState* __tstate = wxPyBeginAllowThreads();
30934 result = (long)wxWindow_GetHandle(arg1);
30935
30936 wxPyEndAllowThreads(__tstate);
30937 if (PyErr_Occurred()) SWIG_fail;
30938 }
30939 {
30940 resultobj = SWIG_From_long((long)(result));
30941 }
30942 return resultobj;
30943 fail:
30944 return NULL;
30945 }
30946
30947
30948 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30949 PyObject *resultobj;
30950 wxWindow *arg1 = (wxWindow *) 0 ;
30951 long arg2 ;
30952 PyObject * obj0 = 0 ;
30953 PyObject * obj1 = 0 ;
30954 char *kwnames[] = {
30955 (char *) "self",(char *) "handle", NULL
30956 };
30957
30958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30960 if (SWIG_arg_fail(1)) SWIG_fail;
30961 {
30962 arg2 = (long)(SWIG_As_long(obj1));
30963 if (SWIG_arg_fail(2)) SWIG_fail;
30964 }
30965 {
30966 PyThreadState* __tstate = wxPyBeginAllowThreads();
30967 wxWindow_AssociateHandle(arg1,arg2);
30968
30969 wxPyEndAllowThreads(__tstate);
30970 if (PyErr_Occurred()) SWIG_fail;
30971 }
30972 Py_INCREF(Py_None); resultobj = Py_None;
30973 return resultobj;
30974 fail:
30975 return NULL;
30976 }
30977
30978
30979 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30980 PyObject *resultobj;
30981 wxWindow *arg1 = (wxWindow *) 0 ;
30982 PyObject * obj0 = 0 ;
30983 char *kwnames[] = {
30984 (char *) "self", NULL
30985 };
30986
30987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30989 if (SWIG_arg_fail(1)) SWIG_fail;
30990 {
30991 PyThreadState* __tstate = wxPyBeginAllowThreads();
30992 (arg1)->DissociateHandle();
30993
30994 wxPyEndAllowThreads(__tstate);
30995 if (PyErr_Occurred()) SWIG_fail;
30996 }
30997 Py_INCREF(Py_None); resultobj = Py_None;
30998 return resultobj;
30999 fail:
31000 return NULL;
31001 }
31002
31003
31004 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31005 PyObject *resultobj;
31006 wxWindow *arg1 = (wxWindow *) 0 ;
31007 int arg2 ;
31008 bool result;
31009 PyObject * obj0 = 0 ;
31010 PyObject * obj1 = 0 ;
31011 char *kwnames[] = {
31012 (char *) "self",(char *) "orient", NULL
31013 };
31014
31015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31017 if (SWIG_arg_fail(1)) SWIG_fail;
31018 {
31019 arg2 = (int)(SWIG_As_int(obj1));
31020 if (SWIG_arg_fail(2)) SWIG_fail;
31021 }
31022 {
31023 PyThreadState* __tstate = wxPyBeginAllowThreads();
31024 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31025
31026 wxPyEndAllowThreads(__tstate);
31027 if (PyErr_Occurred()) SWIG_fail;
31028 }
31029 {
31030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31031 }
31032 return resultobj;
31033 fail:
31034 return NULL;
31035 }
31036
31037
31038 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31039 PyObject *resultobj;
31040 wxWindow *arg1 = (wxWindow *) 0 ;
31041 int arg2 ;
31042 int arg3 ;
31043 int arg4 ;
31044 int arg5 ;
31045 bool arg6 = (bool) true ;
31046 PyObject * obj0 = 0 ;
31047 PyObject * obj1 = 0 ;
31048 PyObject * obj2 = 0 ;
31049 PyObject * obj3 = 0 ;
31050 PyObject * obj4 = 0 ;
31051 PyObject * obj5 = 0 ;
31052 char *kwnames[] = {
31053 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31054 };
31055
31056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31058 if (SWIG_arg_fail(1)) SWIG_fail;
31059 {
31060 arg2 = (int)(SWIG_As_int(obj1));
31061 if (SWIG_arg_fail(2)) SWIG_fail;
31062 }
31063 {
31064 arg3 = (int)(SWIG_As_int(obj2));
31065 if (SWIG_arg_fail(3)) SWIG_fail;
31066 }
31067 {
31068 arg4 = (int)(SWIG_As_int(obj3));
31069 if (SWIG_arg_fail(4)) SWIG_fail;
31070 }
31071 {
31072 arg5 = (int)(SWIG_As_int(obj4));
31073 if (SWIG_arg_fail(5)) SWIG_fail;
31074 }
31075 if (obj5) {
31076 {
31077 arg6 = (bool)(SWIG_As_bool(obj5));
31078 if (SWIG_arg_fail(6)) SWIG_fail;
31079 }
31080 }
31081 {
31082 PyThreadState* __tstate = wxPyBeginAllowThreads();
31083 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31084
31085 wxPyEndAllowThreads(__tstate);
31086 if (PyErr_Occurred()) SWIG_fail;
31087 }
31088 Py_INCREF(Py_None); resultobj = Py_None;
31089 return resultobj;
31090 fail:
31091 return NULL;
31092 }
31093
31094
31095 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31096 PyObject *resultobj;
31097 wxWindow *arg1 = (wxWindow *) 0 ;
31098 int arg2 ;
31099 int arg3 ;
31100 bool arg4 = (bool) true ;
31101 PyObject * obj0 = 0 ;
31102 PyObject * obj1 = 0 ;
31103 PyObject * obj2 = 0 ;
31104 PyObject * obj3 = 0 ;
31105 char *kwnames[] = {
31106 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31107 };
31108
31109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31111 if (SWIG_arg_fail(1)) SWIG_fail;
31112 {
31113 arg2 = (int)(SWIG_As_int(obj1));
31114 if (SWIG_arg_fail(2)) SWIG_fail;
31115 }
31116 {
31117 arg3 = (int)(SWIG_As_int(obj2));
31118 if (SWIG_arg_fail(3)) SWIG_fail;
31119 }
31120 if (obj3) {
31121 {
31122 arg4 = (bool)(SWIG_As_bool(obj3));
31123 if (SWIG_arg_fail(4)) SWIG_fail;
31124 }
31125 }
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 (arg1)->SetScrollPos(arg2,arg3,arg4);
31129
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 Py_INCREF(Py_None); resultobj = Py_None;
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31141 PyObject *resultobj;
31142 wxWindow *arg1 = (wxWindow *) 0 ;
31143 int arg2 ;
31144 int result;
31145 PyObject * obj0 = 0 ;
31146 PyObject * obj1 = 0 ;
31147 char *kwnames[] = {
31148 (char *) "self",(char *) "orientation", NULL
31149 };
31150
31151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31153 if (SWIG_arg_fail(1)) SWIG_fail;
31154 {
31155 arg2 = (int)(SWIG_As_int(obj1));
31156 if (SWIG_arg_fail(2)) SWIG_fail;
31157 }
31158 {
31159 PyThreadState* __tstate = wxPyBeginAllowThreads();
31160 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31161
31162 wxPyEndAllowThreads(__tstate);
31163 if (PyErr_Occurred()) SWIG_fail;
31164 }
31165 {
31166 resultobj = SWIG_From_int((int)(result));
31167 }
31168 return resultobj;
31169 fail:
31170 return NULL;
31171 }
31172
31173
31174 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31175 PyObject *resultobj;
31176 wxWindow *arg1 = (wxWindow *) 0 ;
31177 int arg2 ;
31178 int result;
31179 PyObject * obj0 = 0 ;
31180 PyObject * obj1 = 0 ;
31181 char *kwnames[] = {
31182 (char *) "self",(char *) "orientation", NULL
31183 };
31184
31185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31187 if (SWIG_arg_fail(1)) SWIG_fail;
31188 {
31189 arg2 = (int)(SWIG_As_int(obj1));
31190 if (SWIG_arg_fail(2)) SWIG_fail;
31191 }
31192 {
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31195
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 {
31200 resultobj = SWIG_From_int((int)(result));
31201 }
31202 return resultobj;
31203 fail:
31204 return NULL;
31205 }
31206
31207
31208 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31209 PyObject *resultobj;
31210 wxWindow *arg1 = (wxWindow *) 0 ;
31211 int arg2 ;
31212 int result;
31213 PyObject * obj0 = 0 ;
31214 PyObject * obj1 = 0 ;
31215 char *kwnames[] = {
31216 (char *) "self",(char *) "orientation", NULL
31217 };
31218
31219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31221 if (SWIG_arg_fail(1)) SWIG_fail;
31222 {
31223 arg2 = (int)(SWIG_As_int(obj1));
31224 if (SWIG_arg_fail(2)) SWIG_fail;
31225 }
31226 {
31227 PyThreadState* __tstate = wxPyBeginAllowThreads();
31228 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31229
31230 wxPyEndAllowThreads(__tstate);
31231 if (PyErr_Occurred()) SWIG_fail;
31232 }
31233 {
31234 resultobj = SWIG_From_int((int)(result));
31235 }
31236 return resultobj;
31237 fail:
31238 return NULL;
31239 }
31240
31241
31242 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31243 PyObject *resultobj;
31244 wxWindow *arg1 = (wxWindow *) 0 ;
31245 int arg2 ;
31246 int arg3 ;
31247 wxRect *arg4 = (wxRect *) NULL ;
31248 PyObject * obj0 = 0 ;
31249 PyObject * obj1 = 0 ;
31250 PyObject * obj2 = 0 ;
31251 PyObject * obj3 = 0 ;
31252 char *kwnames[] = {
31253 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31254 };
31255
31256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31258 if (SWIG_arg_fail(1)) SWIG_fail;
31259 {
31260 arg2 = (int)(SWIG_As_int(obj1));
31261 if (SWIG_arg_fail(2)) SWIG_fail;
31262 }
31263 {
31264 arg3 = (int)(SWIG_As_int(obj2));
31265 if (SWIG_arg_fail(3)) SWIG_fail;
31266 }
31267 if (obj3) {
31268 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31269 if (SWIG_arg_fail(4)) SWIG_fail;
31270 }
31271 {
31272 PyThreadState* __tstate = wxPyBeginAllowThreads();
31273 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31274
31275 wxPyEndAllowThreads(__tstate);
31276 if (PyErr_Occurred()) SWIG_fail;
31277 }
31278 Py_INCREF(Py_None); resultobj = Py_None;
31279 return resultobj;
31280 fail:
31281 return NULL;
31282 }
31283
31284
31285 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31286 PyObject *resultobj;
31287 wxWindow *arg1 = (wxWindow *) 0 ;
31288 int arg2 ;
31289 bool result;
31290 PyObject * obj0 = 0 ;
31291 PyObject * obj1 = 0 ;
31292 char *kwnames[] = {
31293 (char *) "self",(char *) "lines", NULL
31294 };
31295
31296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31298 if (SWIG_arg_fail(1)) SWIG_fail;
31299 {
31300 arg2 = (int)(SWIG_As_int(obj1));
31301 if (SWIG_arg_fail(2)) SWIG_fail;
31302 }
31303 {
31304 PyThreadState* __tstate = wxPyBeginAllowThreads();
31305 result = (bool)(arg1)->ScrollLines(arg2);
31306
31307 wxPyEndAllowThreads(__tstate);
31308 if (PyErr_Occurred()) SWIG_fail;
31309 }
31310 {
31311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31312 }
31313 return resultobj;
31314 fail:
31315 return NULL;
31316 }
31317
31318
31319 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31320 PyObject *resultobj;
31321 wxWindow *arg1 = (wxWindow *) 0 ;
31322 int arg2 ;
31323 bool result;
31324 PyObject * obj0 = 0 ;
31325 PyObject * obj1 = 0 ;
31326 char *kwnames[] = {
31327 (char *) "self",(char *) "pages", NULL
31328 };
31329
31330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31332 if (SWIG_arg_fail(1)) SWIG_fail;
31333 {
31334 arg2 = (int)(SWIG_As_int(obj1));
31335 if (SWIG_arg_fail(2)) SWIG_fail;
31336 }
31337 {
31338 PyThreadState* __tstate = wxPyBeginAllowThreads();
31339 result = (bool)(arg1)->ScrollPages(arg2);
31340
31341 wxPyEndAllowThreads(__tstate);
31342 if (PyErr_Occurred()) SWIG_fail;
31343 }
31344 {
31345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31346 }
31347 return resultobj;
31348 fail:
31349 return NULL;
31350 }
31351
31352
31353 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31354 PyObject *resultobj;
31355 wxWindow *arg1 = (wxWindow *) 0 ;
31356 bool result;
31357 PyObject * obj0 = 0 ;
31358 char *kwnames[] = {
31359 (char *) "self", NULL
31360 };
31361
31362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31364 if (SWIG_arg_fail(1)) SWIG_fail;
31365 {
31366 PyThreadState* __tstate = wxPyBeginAllowThreads();
31367 result = (bool)(arg1)->LineUp();
31368
31369 wxPyEndAllowThreads(__tstate);
31370 if (PyErr_Occurred()) SWIG_fail;
31371 }
31372 {
31373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31374 }
31375 return resultobj;
31376 fail:
31377 return NULL;
31378 }
31379
31380
31381 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31382 PyObject *resultobj;
31383 wxWindow *arg1 = (wxWindow *) 0 ;
31384 bool result;
31385 PyObject * obj0 = 0 ;
31386 char *kwnames[] = {
31387 (char *) "self", NULL
31388 };
31389
31390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31392 if (SWIG_arg_fail(1)) SWIG_fail;
31393 {
31394 PyThreadState* __tstate = wxPyBeginAllowThreads();
31395 result = (bool)(arg1)->LineDown();
31396
31397 wxPyEndAllowThreads(__tstate);
31398 if (PyErr_Occurred()) SWIG_fail;
31399 }
31400 {
31401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31402 }
31403 return resultobj;
31404 fail:
31405 return NULL;
31406 }
31407
31408
31409 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31410 PyObject *resultobj;
31411 wxWindow *arg1 = (wxWindow *) 0 ;
31412 bool result;
31413 PyObject * obj0 = 0 ;
31414 char *kwnames[] = {
31415 (char *) "self", NULL
31416 };
31417
31418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31420 if (SWIG_arg_fail(1)) SWIG_fail;
31421 {
31422 PyThreadState* __tstate = wxPyBeginAllowThreads();
31423 result = (bool)(arg1)->PageUp();
31424
31425 wxPyEndAllowThreads(__tstate);
31426 if (PyErr_Occurred()) SWIG_fail;
31427 }
31428 {
31429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31430 }
31431 return resultobj;
31432 fail:
31433 return NULL;
31434 }
31435
31436
31437 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31438 PyObject *resultobj;
31439 wxWindow *arg1 = (wxWindow *) 0 ;
31440 bool result;
31441 PyObject * obj0 = 0 ;
31442 char *kwnames[] = {
31443 (char *) "self", NULL
31444 };
31445
31446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31448 if (SWIG_arg_fail(1)) SWIG_fail;
31449 {
31450 PyThreadState* __tstate = wxPyBeginAllowThreads();
31451 result = (bool)(arg1)->PageDown();
31452
31453 wxPyEndAllowThreads(__tstate);
31454 if (PyErr_Occurred()) SWIG_fail;
31455 }
31456 {
31457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31458 }
31459 return resultobj;
31460 fail:
31461 return NULL;
31462 }
31463
31464
31465 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31466 PyObject *resultobj;
31467 wxWindow *arg1 = (wxWindow *) 0 ;
31468 wxString *arg2 = 0 ;
31469 bool temp2 = false ;
31470 PyObject * obj0 = 0 ;
31471 PyObject * obj1 = 0 ;
31472 char *kwnames[] = {
31473 (char *) "self",(char *) "text", NULL
31474 };
31475
31476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31478 if (SWIG_arg_fail(1)) SWIG_fail;
31479 {
31480 arg2 = wxString_in_helper(obj1);
31481 if (arg2 == NULL) SWIG_fail;
31482 temp2 = true;
31483 }
31484 {
31485 PyThreadState* __tstate = wxPyBeginAllowThreads();
31486 (arg1)->SetHelpText((wxString const &)*arg2);
31487
31488 wxPyEndAllowThreads(__tstate);
31489 if (PyErr_Occurred()) SWIG_fail;
31490 }
31491 Py_INCREF(Py_None); resultobj = Py_None;
31492 {
31493 if (temp2)
31494 delete arg2;
31495 }
31496 return resultobj;
31497 fail:
31498 {
31499 if (temp2)
31500 delete arg2;
31501 }
31502 return NULL;
31503 }
31504
31505
31506 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31507 PyObject *resultobj;
31508 wxWindow *arg1 = (wxWindow *) 0 ;
31509 wxString *arg2 = 0 ;
31510 bool temp2 = false ;
31511 PyObject * obj0 = 0 ;
31512 PyObject * obj1 = 0 ;
31513 char *kwnames[] = {
31514 (char *) "self",(char *) "text", NULL
31515 };
31516
31517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31519 if (SWIG_arg_fail(1)) SWIG_fail;
31520 {
31521 arg2 = wxString_in_helper(obj1);
31522 if (arg2 == NULL) SWIG_fail;
31523 temp2 = true;
31524 }
31525 {
31526 PyThreadState* __tstate = wxPyBeginAllowThreads();
31527 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31528
31529 wxPyEndAllowThreads(__tstate);
31530 if (PyErr_Occurred()) SWIG_fail;
31531 }
31532 Py_INCREF(Py_None); resultobj = Py_None;
31533 {
31534 if (temp2)
31535 delete arg2;
31536 }
31537 return resultobj;
31538 fail:
31539 {
31540 if (temp2)
31541 delete arg2;
31542 }
31543 return NULL;
31544 }
31545
31546
31547 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31548 PyObject *resultobj;
31549 wxWindow *arg1 = (wxWindow *) 0 ;
31550 wxString result;
31551 PyObject * obj0 = 0 ;
31552 char *kwnames[] = {
31553 (char *) "self", NULL
31554 };
31555
31556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31558 if (SWIG_arg_fail(1)) SWIG_fail;
31559 {
31560 PyThreadState* __tstate = wxPyBeginAllowThreads();
31561 result = ((wxWindow const *)arg1)->GetHelpText();
31562
31563 wxPyEndAllowThreads(__tstate);
31564 if (PyErr_Occurred()) SWIG_fail;
31565 }
31566 {
31567 #if wxUSE_UNICODE
31568 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31569 #else
31570 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31571 #endif
31572 }
31573 return resultobj;
31574 fail:
31575 return NULL;
31576 }
31577
31578
31579 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31580 PyObject *resultobj;
31581 wxWindow *arg1 = (wxWindow *) 0 ;
31582 wxString *arg2 = 0 ;
31583 bool temp2 = false ;
31584 PyObject * obj0 = 0 ;
31585 PyObject * obj1 = 0 ;
31586 char *kwnames[] = {
31587 (char *) "self",(char *) "tip", NULL
31588 };
31589
31590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31592 if (SWIG_arg_fail(1)) SWIG_fail;
31593 {
31594 arg2 = wxString_in_helper(obj1);
31595 if (arg2 == NULL) SWIG_fail;
31596 temp2 = true;
31597 }
31598 {
31599 PyThreadState* __tstate = wxPyBeginAllowThreads();
31600 (arg1)->SetToolTip((wxString const &)*arg2);
31601
31602 wxPyEndAllowThreads(__tstate);
31603 if (PyErr_Occurred()) SWIG_fail;
31604 }
31605 Py_INCREF(Py_None); resultobj = Py_None;
31606 {
31607 if (temp2)
31608 delete arg2;
31609 }
31610 return resultobj;
31611 fail:
31612 {
31613 if (temp2)
31614 delete arg2;
31615 }
31616 return NULL;
31617 }
31618
31619
31620 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31621 PyObject *resultobj;
31622 wxWindow *arg1 = (wxWindow *) 0 ;
31623 wxToolTip *arg2 = (wxToolTip *) 0 ;
31624 PyObject * obj0 = 0 ;
31625 PyObject * obj1 = 0 ;
31626 char *kwnames[] = {
31627 (char *) "self",(char *) "tip", NULL
31628 };
31629
31630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31632 if (SWIG_arg_fail(1)) SWIG_fail;
31633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31634 if (SWIG_arg_fail(2)) SWIG_fail;
31635 {
31636 PyThreadState* __tstate = wxPyBeginAllowThreads();
31637 (arg1)->SetToolTip(arg2);
31638
31639 wxPyEndAllowThreads(__tstate);
31640 if (PyErr_Occurred()) SWIG_fail;
31641 }
31642 Py_INCREF(Py_None); resultobj = Py_None;
31643 return resultobj;
31644 fail:
31645 return NULL;
31646 }
31647
31648
31649 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31650 PyObject *resultobj;
31651 wxWindow *arg1 = (wxWindow *) 0 ;
31652 wxToolTip *result;
31653 PyObject * obj0 = 0 ;
31654 char *kwnames[] = {
31655 (char *) "self", NULL
31656 };
31657
31658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31660 if (SWIG_arg_fail(1)) SWIG_fail;
31661 {
31662 PyThreadState* __tstate = wxPyBeginAllowThreads();
31663 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31664
31665 wxPyEndAllowThreads(__tstate);
31666 if (PyErr_Occurred()) SWIG_fail;
31667 }
31668 {
31669 resultobj = wxPyMake_wxObject(result, 0);
31670 }
31671 return resultobj;
31672 fail:
31673 return NULL;
31674 }
31675
31676
31677 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31678 PyObject *resultobj;
31679 wxWindow *arg1 = (wxWindow *) 0 ;
31680 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31681 PyObject * obj0 = 0 ;
31682 PyObject * obj1 = 0 ;
31683 char *kwnames[] = {
31684 (char *) "self",(char *) "dropTarget", NULL
31685 };
31686
31687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31689 if (SWIG_arg_fail(1)) SWIG_fail;
31690 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31691 if (SWIG_arg_fail(2)) SWIG_fail;
31692 {
31693 PyThreadState* __tstate = wxPyBeginAllowThreads();
31694 (arg1)->SetDropTarget(arg2);
31695
31696 wxPyEndAllowThreads(__tstate);
31697 if (PyErr_Occurred()) SWIG_fail;
31698 }
31699 Py_INCREF(Py_None); resultobj = Py_None;
31700 return resultobj;
31701 fail:
31702 return NULL;
31703 }
31704
31705
31706 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31707 PyObject *resultobj;
31708 wxWindow *arg1 = (wxWindow *) 0 ;
31709 wxPyDropTarget *result;
31710 PyObject * obj0 = 0 ;
31711 char *kwnames[] = {
31712 (char *) "self", NULL
31713 };
31714
31715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31717 if (SWIG_arg_fail(1)) SWIG_fail;
31718 {
31719 PyThreadState* __tstate = wxPyBeginAllowThreads();
31720 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31721
31722 wxPyEndAllowThreads(__tstate);
31723 if (PyErr_Occurred()) SWIG_fail;
31724 }
31725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31726 return resultobj;
31727 fail:
31728 return NULL;
31729 }
31730
31731
31732 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31733 PyObject *resultobj;
31734 wxWindow *arg1 = (wxWindow *) 0 ;
31735 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31736 PyObject * obj0 = 0 ;
31737 PyObject * obj1 = 0 ;
31738 char *kwnames[] = {
31739 (char *) "self",(char *) "constraints", NULL
31740 };
31741
31742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31744 if (SWIG_arg_fail(1)) SWIG_fail;
31745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31746 if (SWIG_arg_fail(2)) SWIG_fail;
31747 {
31748 PyThreadState* __tstate = wxPyBeginAllowThreads();
31749 (arg1)->SetConstraints(arg2);
31750
31751 wxPyEndAllowThreads(__tstate);
31752 if (PyErr_Occurred()) SWIG_fail;
31753 }
31754 Py_INCREF(Py_None); resultobj = Py_None;
31755 return resultobj;
31756 fail:
31757 return NULL;
31758 }
31759
31760
31761 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31762 PyObject *resultobj;
31763 wxWindow *arg1 = (wxWindow *) 0 ;
31764 wxLayoutConstraints *result;
31765 PyObject * obj0 = 0 ;
31766 char *kwnames[] = {
31767 (char *) "self", NULL
31768 };
31769
31770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31772 if (SWIG_arg_fail(1)) SWIG_fail;
31773 {
31774 PyThreadState* __tstate = wxPyBeginAllowThreads();
31775 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31776
31777 wxPyEndAllowThreads(__tstate);
31778 if (PyErr_Occurred()) SWIG_fail;
31779 }
31780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31781 return resultobj;
31782 fail:
31783 return NULL;
31784 }
31785
31786
31787 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31788 PyObject *resultobj;
31789 wxWindow *arg1 = (wxWindow *) 0 ;
31790 bool arg2 ;
31791 PyObject * obj0 = 0 ;
31792 PyObject * obj1 = 0 ;
31793 char *kwnames[] = {
31794 (char *) "self",(char *) "autoLayout", NULL
31795 };
31796
31797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31799 if (SWIG_arg_fail(1)) SWIG_fail;
31800 {
31801 arg2 = (bool)(SWIG_As_bool(obj1));
31802 if (SWIG_arg_fail(2)) SWIG_fail;
31803 }
31804 {
31805 PyThreadState* __tstate = wxPyBeginAllowThreads();
31806 (arg1)->SetAutoLayout(arg2);
31807
31808 wxPyEndAllowThreads(__tstate);
31809 if (PyErr_Occurred()) SWIG_fail;
31810 }
31811 Py_INCREF(Py_None); resultobj = Py_None;
31812 return resultobj;
31813 fail:
31814 return NULL;
31815 }
31816
31817
31818 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31819 PyObject *resultobj;
31820 wxWindow *arg1 = (wxWindow *) 0 ;
31821 bool result;
31822 PyObject * obj0 = 0 ;
31823 char *kwnames[] = {
31824 (char *) "self", NULL
31825 };
31826
31827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31829 if (SWIG_arg_fail(1)) SWIG_fail;
31830 {
31831 PyThreadState* __tstate = wxPyBeginAllowThreads();
31832 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31833
31834 wxPyEndAllowThreads(__tstate);
31835 if (PyErr_Occurred()) SWIG_fail;
31836 }
31837 {
31838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31839 }
31840 return resultobj;
31841 fail:
31842 return NULL;
31843 }
31844
31845
31846 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31847 PyObject *resultobj;
31848 wxWindow *arg1 = (wxWindow *) 0 ;
31849 bool result;
31850 PyObject * obj0 = 0 ;
31851 char *kwnames[] = {
31852 (char *) "self", NULL
31853 };
31854
31855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31857 if (SWIG_arg_fail(1)) SWIG_fail;
31858 {
31859 PyThreadState* __tstate = wxPyBeginAllowThreads();
31860 result = (bool)(arg1)->Layout();
31861
31862 wxPyEndAllowThreads(__tstate);
31863 if (PyErr_Occurred()) SWIG_fail;
31864 }
31865 {
31866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31867 }
31868 return resultobj;
31869 fail:
31870 return NULL;
31871 }
31872
31873
31874 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31875 PyObject *resultobj;
31876 wxWindow *arg1 = (wxWindow *) 0 ;
31877 wxSizer *arg2 = (wxSizer *) 0 ;
31878 bool arg3 = (bool) true ;
31879 PyObject * obj0 = 0 ;
31880 PyObject * obj1 = 0 ;
31881 PyObject * obj2 = 0 ;
31882 char *kwnames[] = {
31883 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31884 };
31885
31886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31888 if (SWIG_arg_fail(1)) SWIG_fail;
31889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31890 if (SWIG_arg_fail(2)) SWIG_fail;
31891 if (obj2) {
31892 {
31893 arg3 = (bool)(SWIG_As_bool(obj2));
31894 if (SWIG_arg_fail(3)) SWIG_fail;
31895 }
31896 }
31897 {
31898 PyThreadState* __tstate = wxPyBeginAllowThreads();
31899 (arg1)->SetSizer(arg2,arg3);
31900
31901 wxPyEndAllowThreads(__tstate);
31902 if (PyErr_Occurred()) SWIG_fail;
31903 }
31904 Py_INCREF(Py_None); resultobj = Py_None;
31905 return resultobj;
31906 fail:
31907 return NULL;
31908 }
31909
31910
31911 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31912 PyObject *resultobj;
31913 wxWindow *arg1 = (wxWindow *) 0 ;
31914 wxSizer *arg2 = (wxSizer *) 0 ;
31915 bool arg3 = (bool) true ;
31916 PyObject * obj0 = 0 ;
31917 PyObject * obj1 = 0 ;
31918 PyObject * obj2 = 0 ;
31919 char *kwnames[] = {
31920 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31921 };
31922
31923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31925 if (SWIG_arg_fail(1)) SWIG_fail;
31926 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31927 if (SWIG_arg_fail(2)) SWIG_fail;
31928 if (obj2) {
31929 {
31930 arg3 = (bool)(SWIG_As_bool(obj2));
31931 if (SWIG_arg_fail(3)) SWIG_fail;
31932 }
31933 }
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 (arg1)->SetSizerAndFit(arg2,arg3);
31937
31938 wxPyEndAllowThreads(__tstate);
31939 if (PyErr_Occurred()) SWIG_fail;
31940 }
31941 Py_INCREF(Py_None); resultobj = Py_None;
31942 return resultobj;
31943 fail:
31944 return NULL;
31945 }
31946
31947
31948 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31949 PyObject *resultobj;
31950 wxWindow *arg1 = (wxWindow *) 0 ;
31951 wxSizer *result;
31952 PyObject * obj0 = 0 ;
31953 char *kwnames[] = {
31954 (char *) "self", NULL
31955 };
31956
31957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31959 if (SWIG_arg_fail(1)) SWIG_fail;
31960 {
31961 PyThreadState* __tstate = wxPyBeginAllowThreads();
31962 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31963
31964 wxPyEndAllowThreads(__tstate);
31965 if (PyErr_Occurred()) SWIG_fail;
31966 }
31967 {
31968 resultobj = wxPyMake_wxSizer(result, 0);
31969 }
31970 return resultobj;
31971 fail:
31972 return NULL;
31973 }
31974
31975
31976 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31977 PyObject *resultobj;
31978 wxWindow *arg1 = (wxWindow *) 0 ;
31979 wxSizer *arg2 = (wxSizer *) 0 ;
31980 PyObject * obj0 = 0 ;
31981 PyObject * obj1 = 0 ;
31982 char *kwnames[] = {
31983 (char *) "self",(char *) "sizer", NULL
31984 };
31985
31986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31988 if (SWIG_arg_fail(1)) SWIG_fail;
31989 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31990 if (SWIG_arg_fail(2)) SWIG_fail;
31991 {
31992 PyThreadState* __tstate = wxPyBeginAllowThreads();
31993 (arg1)->SetContainingSizer(arg2);
31994
31995 wxPyEndAllowThreads(__tstate);
31996 if (PyErr_Occurred()) SWIG_fail;
31997 }
31998 Py_INCREF(Py_None); resultobj = Py_None;
31999 return resultobj;
32000 fail:
32001 return NULL;
32002 }
32003
32004
32005 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32006 PyObject *resultobj;
32007 wxWindow *arg1 = (wxWindow *) 0 ;
32008 wxSizer *result;
32009 PyObject * obj0 = 0 ;
32010 char *kwnames[] = {
32011 (char *) "self", NULL
32012 };
32013
32014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32016 if (SWIG_arg_fail(1)) SWIG_fail;
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32020
32021 wxPyEndAllowThreads(__tstate);
32022 if (PyErr_Occurred()) SWIG_fail;
32023 }
32024 {
32025 resultobj = wxPyMake_wxSizer(result, 0);
32026 }
32027 return resultobj;
32028 fail:
32029 return NULL;
32030 }
32031
32032
32033 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32034 PyObject *resultobj;
32035 wxWindow *arg1 = (wxWindow *) 0 ;
32036 PyObject * obj0 = 0 ;
32037 char *kwnames[] = {
32038 (char *) "self", NULL
32039 };
32040
32041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32043 if (SWIG_arg_fail(1)) SWIG_fail;
32044 {
32045 PyThreadState* __tstate = wxPyBeginAllowThreads();
32046 (arg1)->InheritAttributes();
32047
32048 wxPyEndAllowThreads(__tstate);
32049 if (PyErr_Occurred()) SWIG_fail;
32050 }
32051 Py_INCREF(Py_None); resultobj = Py_None;
32052 return resultobj;
32053 fail:
32054 return NULL;
32055 }
32056
32057
32058 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32059 PyObject *resultobj;
32060 wxWindow *arg1 = (wxWindow *) 0 ;
32061 bool result;
32062 PyObject * obj0 = 0 ;
32063 char *kwnames[] = {
32064 (char *) "self", NULL
32065 };
32066
32067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32069 if (SWIG_arg_fail(1)) SWIG_fail;
32070 {
32071 PyThreadState* __tstate = wxPyBeginAllowThreads();
32072 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32073
32074 wxPyEndAllowThreads(__tstate);
32075 if (PyErr_Occurred()) SWIG_fail;
32076 }
32077 {
32078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32079 }
32080 return resultobj;
32081 fail:
32082 return NULL;
32083 }
32084
32085
32086 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32087 PyObject *obj;
32088 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32089 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32090 Py_INCREF(obj);
32091 return Py_BuildValue((char *)"");
32092 }
32093 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32094 PyObject *resultobj;
32095 long arg1 ;
32096 wxWindow *arg2 = (wxWindow *) NULL ;
32097 wxWindow *result;
32098 PyObject * obj0 = 0 ;
32099 PyObject * obj1 = 0 ;
32100 char *kwnames[] = {
32101 (char *) "id",(char *) "parent", NULL
32102 };
32103
32104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32105 {
32106 arg1 = (long)(SWIG_As_long(obj0));
32107 if (SWIG_arg_fail(1)) SWIG_fail;
32108 }
32109 if (obj1) {
32110 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32111 if (SWIG_arg_fail(2)) SWIG_fail;
32112 }
32113 {
32114 if (!wxPyCheckForApp()) SWIG_fail;
32115 PyThreadState* __tstate = wxPyBeginAllowThreads();
32116 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32117
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 {
32122 resultobj = wxPyMake_wxObject(result, 0);
32123 }
32124 return resultobj;
32125 fail:
32126 return NULL;
32127 }
32128
32129
32130 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32131 PyObject *resultobj;
32132 wxString *arg1 = 0 ;
32133 wxWindow *arg2 = (wxWindow *) NULL ;
32134 wxWindow *result;
32135 bool temp1 = false ;
32136 PyObject * obj0 = 0 ;
32137 PyObject * obj1 = 0 ;
32138 char *kwnames[] = {
32139 (char *) "name",(char *) "parent", NULL
32140 };
32141
32142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32143 {
32144 arg1 = wxString_in_helper(obj0);
32145 if (arg1 == NULL) SWIG_fail;
32146 temp1 = true;
32147 }
32148 if (obj1) {
32149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32150 if (SWIG_arg_fail(2)) SWIG_fail;
32151 }
32152 {
32153 if (!wxPyCheckForApp()) SWIG_fail;
32154 PyThreadState* __tstate = wxPyBeginAllowThreads();
32155 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32156
32157 wxPyEndAllowThreads(__tstate);
32158 if (PyErr_Occurred()) SWIG_fail;
32159 }
32160 {
32161 resultobj = wxPyMake_wxObject(result, 0);
32162 }
32163 {
32164 if (temp1)
32165 delete arg1;
32166 }
32167 return resultobj;
32168 fail:
32169 {
32170 if (temp1)
32171 delete arg1;
32172 }
32173 return NULL;
32174 }
32175
32176
32177 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32178 PyObject *resultobj;
32179 wxString *arg1 = 0 ;
32180 wxWindow *arg2 = (wxWindow *) NULL ;
32181 wxWindow *result;
32182 bool temp1 = false ;
32183 PyObject * obj0 = 0 ;
32184 PyObject * obj1 = 0 ;
32185 char *kwnames[] = {
32186 (char *) "label",(char *) "parent", NULL
32187 };
32188
32189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32190 {
32191 arg1 = wxString_in_helper(obj0);
32192 if (arg1 == NULL) SWIG_fail;
32193 temp1 = true;
32194 }
32195 if (obj1) {
32196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32197 if (SWIG_arg_fail(2)) SWIG_fail;
32198 }
32199 {
32200 if (!wxPyCheckForApp()) SWIG_fail;
32201 PyThreadState* __tstate = wxPyBeginAllowThreads();
32202 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32203
32204 wxPyEndAllowThreads(__tstate);
32205 if (PyErr_Occurred()) SWIG_fail;
32206 }
32207 {
32208 resultobj = wxPyMake_wxObject(result, 0);
32209 }
32210 {
32211 if (temp1)
32212 delete arg1;
32213 }
32214 return resultobj;
32215 fail:
32216 {
32217 if (temp1)
32218 delete arg1;
32219 }
32220 return NULL;
32221 }
32222
32223
32224 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32225 PyObject *resultobj;
32226 wxWindow *arg1 = (wxWindow *) 0 ;
32227 unsigned long arg2 ;
32228 wxWindow *result;
32229 PyObject * obj0 = 0 ;
32230 PyObject * obj1 = 0 ;
32231 char *kwnames[] = {
32232 (char *) "parent",(char *) "_hWnd", NULL
32233 };
32234
32235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32237 if (SWIG_arg_fail(1)) SWIG_fail;
32238 {
32239 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32240 if (SWIG_arg_fail(2)) SWIG_fail;
32241 }
32242 {
32243 PyThreadState* __tstate = wxPyBeginAllowThreads();
32244 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32245
32246 wxPyEndAllowThreads(__tstate);
32247 if (PyErr_Occurred()) SWIG_fail;
32248 }
32249 {
32250 resultobj = wxPyMake_wxObject(result, 0);
32251 }
32252 return resultobj;
32253 fail:
32254 return NULL;
32255 }
32256
32257
32258 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32259 PyObject *resultobj;
32260 PyObject *result;
32261 char *kwnames[] = {
32262 NULL
32263 };
32264
32265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32266 {
32267 PyThreadState* __tstate = wxPyBeginAllowThreads();
32268 result = (PyObject *)GetTopLevelWindows();
32269
32270 wxPyEndAllowThreads(__tstate);
32271 if (PyErr_Occurred()) SWIG_fail;
32272 }
32273 resultobj = result;
32274 return resultobj;
32275 fail:
32276 return NULL;
32277 }
32278
32279
32280 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32281 PyObject *resultobj;
32282 wxValidator *result;
32283 char *kwnames[] = {
32284 NULL
32285 };
32286
32287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32288 {
32289 PyThreadState* __tstate = wxPyBeginAllowThreads();
32290 result = (wxValidator *)new wxValidator();
32291
32292 wxPyEndAllowThreads(__tstate);
32293 if (PyErr_Occurred()) SWIG_fail;
32294 }
32295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32296 return resultobj;
32297 fail:
32298 return NULL;
32299 }
32300
32301
32302 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32303 PyObject *resultobj;
32304 wxValidator *arg1 = (wxValidator *) 0 ;
32305 wxValidator *result;
32306 PyObject * obj0 = 0 ;
32307 char *kwnames[] = {
32308 (char *) "self", NULL
32309 };
32310
32311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32313 if (SWIG_arg_fail(1)) SWIG_fail;
32314 {
32315 PyThreadState* __tstate = wxPyBeginAllowThreads();
32316 result = (wxValidator *)(arg1)->Clone();
32317
32318 wxPyEndAllowThreads(__tstate);
32319 if (PyErr_Occurred()) SWIG_fail;
32320 }
32321 {
32322 resultobj = wxPyMake_wxObject(result, 0);
32323 }
32324 return resultobj;
32325 fail:
32326 return NULL;
32327 }
32328
32329
32330 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32331 PyObject *resultobj;
32332 wxValidator *arg1 = (wxValidator *) 0 ;
32333 wxWindow *arg2 = (wxWindow *) 0 ;
32334 bool result;
32335 PyObject * obj0 = 0 ;
32336 PyObject * obj1 = 0 ;
32337 char *kwnames[] = {
32338 (char *) "self",(char *) "parent", NULL
32339 };
32340
32341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32343 if (SWIG_arg_fail(1)) SWIG_fail;
32344 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32345 if (SWIG_arg_fail(2)) SWIG_fail;
32346 {
32347 PyThreadState* __tstate = wxPyBeginAllowThreads();
32348 result = (bool)(arg1)->Validate(arg2);
32349
32350 wxPyEndAllowThreads(__tstate);
32351 if (PyErr_Occurred()) SWIG_fail;
32352 }
32353 {
32354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32355 }
32356 return resultobj;
32357 fail:
32358 return NULL;
32359 }
32360
32361
32362 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32363 PyObject *resultobj;
32364 wxValidator *arg1 = (wxValidator *) 0 ;
32365 bool result;
32366 PyObject * obj0 = 0 ;
32367 char *kwnames[] = {
32368 (char *) "self", NULL
32369 };
32370
32371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32373 if (SWIG_arg_fail(1)) SWIG_fail;
32374 {
32375 PyThreadState* __tstate = wxPyBeginAllowThreads();
32376 result = (bool)(arg1)->TransferToWindow();
32377
32378 wxPyEndAllowThreads(__tstate);
32379 if (PyErr_Occurred()) SWIG_fail;
32380 }
32381 {
32382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32383 }
32384 return resultobj;
32385 fail:
32386 return NULL;
32387 }
32388
32389
32390 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32391 PyObject *resultobj;
32392 wxValidator *arg1 = (wxValidator *) 0 ;
32393 bool result;
32394 PyObject * obj0 = 0 ;
32395 char *kwnames[] = {
32396 (char *) "self", NULL
32397 };
32398
32399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32401 if (SWIG_arg_fail(1)) SWIG_fail;
32402 {
32403 PyThreadState* __tstate = wxPyBeginAllowThreads();
32404 result = (bool)(arg1)->TransferFromWindow();
32405
32406 wxPyEndAllowThreads(__tstate);
32407 if (PyErr_Occurred()) SWIG_fail;
32408 }
32409 {
32410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32411 }
32412 return resultobj;
32413 fail:
32414 return NULL;
32415 }
32416
32417
32418 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32419 PyObject *resultobj;
32420 wxValidator *arg1 = (wxValidator *) 0 ;
32421 wxWindow *result;
32422 PyObject * obj0 = 0 ;
32423 char *kwnames[] = {
32424 (char *) "self", NULL
32425 };
32426
32427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32429 if (SWIG_arg_fail(1)) SWIG_fail;
32430 {
32431 PyThreadState* __tstate = wxPyBeginAllowThreads();
32432 result = (wxWindow *)(arg1)->GetWindow();
32433
32434 wxPyEndAllowThreads(__tstate);
32435 if (PyErr_Occurred()) SWIG_fail;
32436 }
32437 {
32438 resultobj = wxPyMake_wxObject(result, 0);
32439 }
32440 return resultobj;
32441 fail:
32442 return NULL;
32443 }
32444
32445
32446 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32447 PyObject *resultobj;
32448 wxValidator *arg1 = (wxValidator *) 0 ;
32449 wxWindow *arg2 = (wxWindow *) 0 ;
32450 PyObject * obj0 = 0 ;
32451 PyObject * obj1 = 0 ;
32452 char *kwnames[] = {
32453 (char *) "self",(char *) "window", NULL
32454 };
32455
32456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32458 if (SWIG_arg_fail(1)) SWIG_fail;
32459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32460 if (SWIG_arg_fail(2)) SWIG_fail;
32461 {
32462 PyThreadState* __tstate = wxPyBeginAllowThreads();
32463 (arg1)->SetWindow(arg2);
32464
32465 wxPyEndAllowThreads(__tstate);
32466 if (PyErr_Occurred()) SWIG_fail;
32467 }
32468 Py_INCREF(Py_None); resultobj = Py_None;
32469 return resultobj;
32470 fail:
32471 return NULL;
32472 }
32473
32474
32475 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32476 PyObject *resultobj;
32477 bool result;
32478 char *kwnames[] = {
32479 NULL
32480 };
32481
32482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32483 {
32484 PyThreadState* __tstate = wxPyBeginAllowThreads();
32485 result = (bool)wxValidator::IsSilent();
32486
32487 wxPyEndAllowThreads(__tstate);
32488 if (PyErr_Occurred()) SWIG_fail;
32489 }
32490 {
32491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32492 }
32493 return resultobj;
32494 fail:
32495 return NULL;
32496 }
32497
32498
32499 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32500 PyObject *resultobj;
32501 int arg1 = (int) true ;
32502 PyObject * obj0 = 0 ;
32503 char *kwnames[] = {
32504 (char *) "doIt", NULL
32505 };
32506
32507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32508 if (obj0) {
32509 {
32510 arg1 = (int)(SWIG_As_int(obj0));
32511 if (SWIG_arg_fail(1)) SWIG_fail;
32512 }
32513 }
32514 {
32515 PyThreadState* __tstate = wxPyBeginAllowThreads();
32516 wxValidator::SetBellOnError(arg1);
32517
32518 wxPyEndAllowThreads(__tstate);
32519 if (PyErr_Occurred()) SWIG_fail;
32520 }
32521 Py_INCREF(Py_None); resultobj = Py_None;
32522 return resultobj;
32523 fail:
32524 return NULL;
32525 }
32526
32527
32528 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32529 PyObject *obj;
32530 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32531 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32532 Py_INCREF(obj);
32533 return Py_BuildValue((char *)"");
32534 }
32535 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32536 PyObject *resultobj;
32537 wxPyValidator *result;
32538 char *kwnames[] = {
32539 NULL
32540 };
32541
32542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32543 {
32544 PyThreadState* __tstate = wxPyBeginAllowThreads();
32545 result = (wxPyValidator *)new wxPyValidator();
32546
32547 wxPyEndAllowThreads(__tstate);
32548 if (PyErr_Occurred()) SWIG_fail;
32549 }
32550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32551 return resultobj;
32552 fail:
32553 return NULL;
32554 }
32555
32556
32557 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32558 PyObject *resultobj;
32559 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32560 PyObject *arg2 = (PyObject *) 0 ;
32561 PyObject *arg3 = (PyObject *) 0 ;
32562 int arg4 = (int) true ;
32563 PyObject * obj0 = 0 ;
32564 PyObject * obj1 = 0 ;
32565 PyObject * obj2 = 0 ;
32566 PyObject * obj3 = 0 ;
32567 char *kwnames[] = {
32568 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32569 };
32570
32571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32573 if (SWIG_arg_fail(1)) SWIG_fail;
32574 arg2 = obj1;
32575 arg3 = obj2;
32576 if (obj3) {
32577 {
32578 arg4 = (int)(SWIG_As_int(obj3));
32579 if (SWIG_arg_fail(4)) SWIG_fail;
32580 }
32581 }
32582 {
32583 PyThreadState* __tstate = wxPyBeginAllowThreads();
32584 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32585
32586 wxPyEndAllowThreads(__tstate);
32587 if (PyErr_Occurred()) SWIG_fail;
32588 }
32589 Py_INCREF(Py_None); resultobj = Py_None;
32590 return resultobj;
32591 fail:
32592 return NULL;
32593 }
32594
32595
32596 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32597 PyObject *obj;
32598 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32599 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32600 Py_INCREF(obj);
32601 return Py_BuildValue((char *)"");
32602 }
32603 static int _wrap_DefaultValidator_set(PyObject *) {
32604 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32605 return 1;
32606 }
32607
32608
32609 static PyObject *_wrap_DefaultValidator_get(void) {
32610 PyObject *pyobj;
32611
32612 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32613 return pyobj;
32614 }
32615
32616
32617 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32618 PyObject *resultobj;
32619 wxString const &arg1_defvalue = wxPyEmptyString ;
32620 wxString *arg1 = (wxString *) &arg1_defvalue ;
32621 long arg2 = (long) 0 ;
32622 wxMenu *result;
32623 bool temp1 = false ;
32624 PyObject * obj0 = 0 ;
32625 PyObject * obj1 = 0 ;
32626 char *kwnames[] = {
32627 (char *) "title",(char *) "style", NULL
32628 };
32629
32630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32631 if (obj0) {
32632 {
32633 arg1 = wxString_in_helper(obj0);
32634 if (arg1 == NULL) SWIG_fail;
32635 temp1 = true;
32636 }
32637 }
32638 if (obj1) {
32639 {
32640 arg2 = (long)(SWIG_As_long(obj1));
32641 if (SWIG_arg_fail(2)) SWIG_fail;
32642 }
32643 }
32644 {
32645 if (!wxPyCheckForApp()) SWIG_fail;
32646 PyThreadState* __tstate = wxPyBeginAllowThreads();
32647 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32648
32649 wxPyEndAllowThreads(__tstate);
32650 if (PyErr_Occurred()) SWIG_fail;
32651 }
32652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32653 {
32654 if (temp1)
32655 delete arg1;
32656 }
32657 return resultobj;
32658 fail:
32659 {
32660 if (temp1)
32661 delete arg1;
32662 }
32663 return NULL;
32664 }
32665
32666
32667 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32668 PyObject *resultobj;
32669 wxMenu *arg1 = (wxMenu *) 0 ;
32670 int arg2 ;
32671 wxString *arg3 = 0 ;
32672 wxString const &arg4_defvalue = wxPyEmptyString ;
32673 wxString *arg4 = (wxString *) &arg4_defvalue ;
32674 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32675 wxMenuItem *result;
32676 bool temp3 = false ;
32677 bool temp4 = false ;
32678 PyObject * obj0 = 0 ;
32679 PyObject * obj1 = 0 ;
32680 PyObject * obj2 = 0 ;
32681 PyObject * obj3 = 0 ;
32682 PyObject * obj4 = 0 ;
32683 char *kwnames[] = {
32684 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32685 };
32686
32687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32689 if (SWIG_arg_fail(1)) SWIG_fail;
32690 {
32691 arg2 = (int)(SWIG_As_int(obj1));
32692 if (SWIG_arg_fail(2)) SWIG_fail;
32693 }
32694 {
32695 arg3 = wxString_in_helper(obj2);
32696 if (arg3 == NULL) SWIG_fail;
32697 temp3 = true;
32698 }
32699 if (obj3) {
32700 {
32701 arg4 = wxString_in_helper(obj3);
32702 if (arg4 == NULL) SWIG_fail;
32703 temp4 = true;
32704 }
32705 }
32706 if (obj4) {
32707 {
32708 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32709 if (SWIG_arg_fail(5)) SWIG_fail;
32710 }
32711 }
32712 {
32713 PyThreadState* __tstate = wxPyBeginAllowThreads();
32714 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32715
32716 wxPyEndAllowThreads(__tstate);
32717 if (PyErr_Occurred()) SWIG_fail;
32718 }
32719 {
32720 resultobj = wxPyMake_wxObject(result, 0);
32721 }
32722 {
32723 if (temp3)
32724 delete arg3;
32725 }
32726 {
32727 if (temp4)
32728 delete arg4;
32729 }
32730 return resultobj;
32731 fail:
32732 {
32733 if (temp3)
32734 delete arg3;
32735 }
32736 {
32737 if (temp4)
32738 delete arg4;
32739 }
32740 return NULL;
32741 }
32742
32743
32744 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32745 PyObject *resultobj;
32746 wxMenu *arg1 = (wxMenu *) 0 ;
32747 wxMenuItem *result;
32748 PyObject * obj0 = 0 ;
32749 char *kwnames[] = {
32750 (char *) "self", NULL
32751 };
32752
32753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32755 if (SWIG_arg_fail(1)) SWIG_fail;
32756 {
32757 PyThreadState* __tstate = wxPyBeginAllowThreads();
32758 result = (wxMenuItem *)(arg1)->AppendSeparator();
32759
32760 wxPyEndAllowThreads(__tstate);
32761 if (PyErr_Occurred()) SWIG_fail;
32762 }
32763 {
32764 resultobj = wxPyMake_wxObject(result, 0);
32765 }
32766 return resultobj;
32767 fail:
32768 return NULL;
32769 }
32770
32771
32772 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32773 PyObject *resultobj;
32774 wxMenu *arg1 = (wxMenu *) 0 ;
32775 int arg2 ;
32776 wxString *arg3 = 0 ;
32777 wxString const &arg4_defvalue = wxPyEmptyString ;
32778 wxString *arg4 = (wxString *) &arg4_defvalue ;
32779 wxMenuItem *result;
32780 bool temp3 = false ;
32781 bool temp4 = false ;
32782 PyObject * obj0 = 0 ;
32783 PyObject * obj1 = 0 ;
32784 PyObject * obj2 = 0 ;
32785 PyObject * obj3 = 0 ;
32786 char *kwnames[] = {
32787 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32788 };
32789
32790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32792 if (SWIG_arg_fail(1)) SWIG_fail;
32793 {
32794 arg2 = (int)(SWIG_As_int(obj1));
32795 if (SWIG_arg_fail(2)) SWIG_fail;
32796 }
32797 {
32798 arg3 = wxString_in_helper(obj2);
32799 if (arg3 == NULL) SWIG_fail;
32800 temp3 = true;
32801 }
32802 if (obj3) {
32803 {
32804 arg4 = wxString_in_helper(obj3);
32805 if (arg4 == NULL) SWIG_fail;
32806 temp4 = true;
32807 }
32808 }
32809 {
32810 PyThreadState* __tstate = wxPyBeginAllowThreads();
32811 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32812
32813 wxPyEndAllowThreads(__tstate);
32814 if (PyErr_Occurred()) SWIG_fail;
32815 }
32816 {
32817 resultobj = wxPyMake_wxObject(result, 0);
32818 }
32819 {
32820 if (temp3)
32821 delete arg3;
32822 }
32823 {
32824 if (temp4)
32825 delete arg4;
32826 }
32827 return resultobj;
32828 fail:
32829 {
32830 if (temp3)
32831 delete arg3;
32832 }
32833 {
32834 if (temp4)
32835 delete arg4;
32836 }
32837 return NULL;
32838 }
32839
32840
32841 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32842 PyObject *resultobj;
32843 wxMenu *arg1 = (wxMenu *) 0 ;
32844 int arg2 ;
32845 wxString *arg3 = 0 ;
32846 wxString const &arg4_defvalue = wxPyEmptyString ;
32847 wxString *arg4 = (wxString *) &arg4_defvalue ;
32848 wxMenuItem *result;
32849 bool temp3 = false ;
32850 bool temp4 = false ;
32851 PyObject * obj0 = 0 ;
32852 PyObject * obj1 = 0 ;
32853 PyObject * obj2 = 0 ;
32854 PyObject * obj3 = 0 ;
32855 char *kwnames[] = {
32856 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32857 };
32858
32859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32861 if (SWIG_arg_fail(1)) SWIG_fail;
32862 {
32863 arg2 = (int)(SWIG_As_int(obj1));
32864 if (SWIG_arg_fail(2)) SWIG_fail;
32865 }
32866 {
32867 arg3 = wxString_in_helper(obj2);
32868 if (arg3 == NULL) SWIG_fail;
32869 temp3 = true;
32870 }
32871 if (obj3) {
32872 {
32873 arg4 = wxString_in_helper(obj3);
32874 if (arg4 == NULL) SWIG_fail;
32875 temp4 = true;
32876 }
32877 }
32878 {
32879 PyThreadState* __tstate = wxPyBeginAllowThreads();
32880 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32881
32882 wxPyEndAllowThreads(__tstate);
32883 if (PyErr_Occurred()) SWIG_fail;
32884 }
32885 {
32886 resultobj = wxPyMake_wxObject(result, 0);
32887 }
32888 {
32889 if (temp3)
32890 delete arg3;
32891 }
32892 {
32893 if (temp4)
32894 delete arg4;
32895 }
32896 return resultobj;
32897 fail:
32898 {
32899 if (temp3)
32900 delete arg3;
32901 }
32902 {
32903 if (temp4)
32904 delete arg4;
32905 }
32906 return NULL;
32907 }
32908
32909
32910 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32911 PyObject *resultobj;
32912 wxMenu *arg1 = (wxMenu *) 0 ;
32913 int arg2 ;
32914 wxString *arg3 = 0 ;
32915 wxMenu *arg4 = (wxMenu *) 0 ;
32916 wxString const &arg5_defvalue = wxPyEmptyString ;
32917 wxString *arg5 = (wxString *) &arg5_defvalue ;
32918 wxMenuItem *result;
32919 bool temp3 = false ;
32920 bool temp5 = false ;
32921 PyObject * obj0 = 0 ;
32922 PyObject * obj1 = 0 ;
32923 PyObject * obj2 = 0 ;
32924 PyObject * obj3 = 0 ;
32925 PyObject * obj4 = 0 ;
32926 char *kwnames[] = {
32927 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32928 };
32929
32930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32932 if (SWIG_arg_fail(1)) SWIG_fail;
32933 {
32934 arg2 = (int)(SWIG_As_int(obj1));
32935 if (SWIG_arg_fail(2)) SWIG_fail;
32936 }
32937 {
32938 arg3 = wxString_in_helper(obj2);
32939 if (arg3 == NULL) SWIG_fail;
32940 temp3 = true;
32941 }
32942 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32943 if (SWIG_arg_fail(4)) SWIG_fail;
32944 if (obj4) {
32945 {
32946 arg5 = wxString_in_helper(obj4);
32947 if (arg5 == NULL) SWIG_fail;
32948 temp5 = true;
32949 }
32950 }
32951 {
32952 PyThreadState* __tstate = wxPyBeginAllowThreads();
32953 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32954
32955 wxPyEndAllowThreads(__tstate);
32956 if (PyErr_Occurred()) SWIG_fail;
32957 }
32958 {
32959 resultobj = wxPyMake_wxObject(result, 0);
32960 }
32961 {
32962 if (temp3)
32963 delete arg3;
32964 }
32965 {
32966 if (temp5)
32967 delete arg5;
32968 }
32969 return resultobj;
32970 fail:
32971 {
32972 if (temp3)
32973 delete arg3;
32974 }
32975 {
32976 if (temp5)
32977 delete arg5;
32978 }
32979 return NULL;
32980 }
32981
32982
32983 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32984 PyObject *resultobj;
32985 wxMenu *arg1 = (wxMenu *) 0 ;
32986 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32987 wxMenuItem *result;
32988 PyObject * obj0 = 0 ;
32989 PyObject * obj1 = 0 ;
32990 char *kwnames[] = {
32991 (char *) "self",(char *) "item", NULL
32992 };
32993
32994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32996 if (SWIG_arg_fail(1)) SWIG_fail;
32997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32998 if (SWIG_arg_fail(2)) SWIG_fail;
32999 {
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 result = (wxMenuItem *)(arg1)->Append(arg2);
33002
33003 wxPyEndAllowThreads(__tstate);
33004 if (PyErr_Occurred()) SWIG_fail;
33005 }
33006 {
33007 resultobj = wxPyMake_wxObject(result, 0);
33008 }
33009 return resultobj;
33010 fail:
33011 return NULL;
33012 }
33013
33014
33015 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33016 PyObject *resultobj;
33017 wxMenu *arg1 = (wxMenu *) 0 ;
33018 PyObject * obj0 = 0 ;
33019 char *kwnames[] = {
33020 (char *) "self", NULL
33021 };
33022
33023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33025 if (SWIG_arg_fail(1)) SWIG_fail;
33026 {
33027 PyThreadState* __tstate = wxPyBeginAllowThreads();
33028 (arg1)->Break();
33029
33030 wxPyEndAllowThreads(__tstate);
33031 if (PyErr_Occurred()) SWIG_fail;
33032 }
33033 Py_INCREF(Py_None); resultobj = Py_None;
33034 return resultobj;
33035 fail:
33036 return NULL;
33037 }
33038
33039
33040 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33041 PyObject *resultobj;
33042 wxMenu *arg1 = (wxMenu *) 0 ;
33043 size_t arg2 ;
33044 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33045 wxMenuItem *result;
33046 PyObject * obj0 = 0 ;
33047 PyObject * obj1 = 0 ;
33048 PyObject * obj2 = 0 ;
33049 char *kwnames[] = {
33050 (char *) "self",(char *) "pos",(char *) "item", NULL
33051 };
33052
33053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33055 if (SWIG_arg_fail(1)) SWIG_fail;
33056 {
33057 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33058 if (SWIG_arg_fail(2)) SWIG_fail;
33059 }
33060 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33061 if (SWIG_arg_fail(3)) SWIG_fail;
33062 {
33063 PyThreadState* __tstate = wxPyBeginAllowThreads();
33064 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33065
33066 wxPyEndAllowThreads(__tstate);
33067 if (PyErr_Occurred()) SWIG_fail;
33068 }
33069 {
33070 resultobj = wxPyMake_wxObject(result, 0);
33071 }
33072 return resultobj;
33073 fail:
33074 return NULL;
33075 }
33076
33077
33078 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33079 PyObject *resultobj;
33080 wxMenu *arg1 = (wxMenu *) 0 ;
33081 size_t arg2 ;
33082 int arg3 ;
33083 wxString *arg4 = 0 ;
33084 wxString const &arg5_defvalue = wxPyEmptyString ;
33085 wxString *arg5 = (wxString *) &arg5_defvalue ;
33086 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33087 wxMenuItem *result;
33088 bool temp4 = false ;
33089 bool temp5 = false ;
33090 PyObject * obj0 = 0 ;
33091 PyObject * obj1 = 0 ;
33092 PyObject * obj2 = 0 ;
33093 PyObject * obj3 = 0 ;
33094 PyObject * obj4 = 0 ;
33095 PyObject * obj5 = 0 ;
33096 char *kwnames[] = {
33097 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33098 };
33099
33100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33102 if (SWIG_arg_fail(1)) SWIG_fail;
33103 {
33104 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33105 if (SWIG_arg_fail(2)) SWIG_fail;
33106 }
33107 {
33108 arg3 = (int)(SWIG_As_int(obj2));
33109 if (SWIG_arg_fail(3)) SWIG_fail;
33110 }
33111 {
33112 arg4 = wxString_in_helper(obj3);
33113 if (arg4 == NULL) SWIG_fail;
33114 temp4 = true;
33115 }
33116 if (obj4) {
33117 {
33118 arg5 = wxString_in_helper(obj4);
33119 if (arg5 == NULL) SWIG_fail;
33120 temp5 = true;
33121 }
33122 }
33123 if (obj5) {
33124 {
33125 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33126 if (SWIG_arg_fail(6)) SWIG_fail;
33127 }
33128 }
33129 {
33130 PyThreadState* __tstate = wxPyBeginAllowThreads();
33131 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33132
33133 wxPyEndAllowThreads(__tstate);
33134 if (PyErr_Occurred()) SWIG_fail;
33135 }
33136 {
33137 resultobj = wxPyMake_wxObject(result, 0);
33138 }
33139 {
33140 if (temp4)
33141 delete arg4;
33142 }
33143 {
33144 if (temp5)
33145 delete arg5;
33146 }
33147 return resultobj;
33148 fail:
33149 {
33150 if (temp4)
33151 delete arg4;
33152 }
33153 {
33154 if (temp5)
33155 delete arg5;
33156 }
33157 return NULL;
33158 }
33159
33160
33161 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33162 PyObject *resultobj;
33163 wxMenu *arg1 = (wxMenu *) 0 ;
33164 size_t arg2 ;
33165 wxMenuItem *result;
33166 PyObject * obj0 = 0 ;
33167 PyObject * obj1 = 0 ;
33168 char *kwnames[] = {
33169 (char *) "self",(char *) "pos", NULL
33170 };
33171
33172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33174 if (SWIG_arg_fail(1)) SWIG_fail;
33175 {
33176 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33177 if (SWIG_arg_fail(2)) SWIG_fail;
33178 }
33179 {
33180 PyThreadState* __tstate = wxPyBeginAllowThreads();
33181 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33182
33183 wxPyEndAllowThreads(__tstate);
33184 if (PyErr_Occurred()) SWIG_fail;
33185 }
33186 {
33187 resultobj = wxPyMake_wxObject(result, 0);
33188 }
33189 return resultobj;
33190 fail:
33191 return NULL;
33192 }
33193
33194
33195 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33196 PyObject *resultobj;
33197 wxMenu *arg1 = (wxMenu *) 0 ;
33198 size_t arg2 ;
33199 int arg3 ;
33200 wxString *arg4 = 0 ;
33201 wxString const &arg5_defvalue = wxPyEmptyString ;
33202 wxString *arg5 = (wxString *) &arg5_defvalue ;
33203 wxMenuItem *result;
33204 bool temp4 = false ;
33205 bool temp5 = false ;
33206 PyObject * obj0 = 0 ;
33207 PyObject * obj1 = 0 ;
33208 PyObject * obj2 = 0 ;
33209 PyObject * obj3 = 0 ;
33210 PyObject * obj4 = 0 ;
33211 char *kwnames[] = {
33212 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33213 };
33214
33215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33217 if (SWIG_arg_fail(1)) SWIG_fail;
33218 {
33219 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33220 if (SWIG_arg_fail(2)) SWIG_fail;
33221 }
33222 {
33223 arg3 = (int)(SWIG_As_int(obj2));
33224 if (SWIG_arg_fail(3)) SWIG_fail;
33225 }
33226 {
33227 arg4 = wxString_in_helper(obj3);
33228 if (arg4 == NULL) SWIG_fail;
33229 temp4 = true;
33230 }
33231 if (obj4) {
33232 {
33233 arg5 = wxString_in_helper(obj4);
33234 if (arg5 == NULL) SWIG_fail;
33235 temp5 = true;
33236 }
33237 }
33238 {
33239 PyThreadState* __tstate = wxPyBeginAllowThreads();
33240 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33241
33242 wxPyEndAllowThreads(__tstate);
33243 if (PyErr_Occurred()) SWIG_fail;
33244 }
33245 {
33246 resultobj = wxPyMake_wxObject(result, 0);
33247 }
33248 {
33249 if (temp4)
33250 delete arg4;
33251 }
33252 {
33253 if (temp5)
33254 delete arg5;
33255 }
33256 return resultobj;
33257 fail:
33258 {
33259 if (temp4)
33260 delete arg4;
33261 }
33262 {
33263 if (temp5)
33264 delete arg5;
33265 }
33266 return NULL;
33267 }
33268
33269
33270 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33271 PyObject *resultobj;
33272 wxMenu *arg1 = (wxMenu *) 0 ;
33273 size_t arg2 ;
33274 int arg3 ;
33275 wxString *arg4 = 0 ;
33276 wxString const &arg5_defvalue = wxPyEmptyString ;
33277 wxString *arg5 = (wxString *) &arg5_defvalue ;
33278 wxMenuItem *result;
33279 bool temp4 = false ;
33280 bool temp5 = false ;
33281 PyObject * obj0 = 0 ;
33282 PyObject * obj1 = 0 ;
33283 PyObject * obj2 = 0 ;
33284 PyObject * obj3 = 0 ;
33285 PyObject * obj4 = 0 ;
33286 char *kwnames[] = {
33287 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33288 };
33289
33290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33292 if (SWIG_arg_fail(1)) SWIG_fail;
33293 {
33294 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33295 if (SWIG_arg_fail(2)) SWIG_fail;
33296 }
33297 {
33298 arg3 = (int)(SWIG_As_int(obj2));
33299 if (SWIG_arg_fail(3)) SWIG_fail;
33300 }
33301 {
33302 arg4 = wxString_in_helper(obj3);
33303 if (arg4 == NULL) SWIG_fail;
33304 temp4 = true;
33305 }
33306 if (obj4) {
33307 {
33308 arg5 = wxString_in_helper(obj4);
33309 if (arg5 == NULL) SWIG_fail;
33310 temp5 = true;
33311 }
33312 }
33313 {
33314 PyThreadState* __tstate = wxPyBeginAllowThreads();
33315 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33316
33317 wxPyEndAllowThreads(__tstate);
33318 if (PyErr_Occurred()) SWIG_fail;
33319 }
33320 {
33321 resultobj = wxPyMake_wxObject(result, 0);
33322 }
33323 {
33324 if (temp4)
33325 delete arg4;
33326 }
33327 {
33328 if (temp5)
33329 delete arg5;
33330 }
33331 return resultobj;
33332 fail:
33333 {
33334 if (temp4)
33335 delete arg4;
33336 }
33337 {
33338 if (temp5)
33339 delete arg5;
33340 }
33341 return NULL;
33342 }
33343
33344
33345 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33346 PyObject *resultobj;
33347 wxMenu *arg1 = (wxMenu *) 0 ;
33348 size_t arg2 ;
33349 int arg3 ;
33350 wxString *arg4 = 0 ;
33351 wxMenu *arg5 = (wxMenu *) 0 ;
33352 wxString const &arg6_defvalue = wxPyEmptyString ;
33353 wxString *arg6 = (wxString *) &arg6_defvalue ;
33354 wxMenuItem *result;
33355 bool temp4 = false ;
33356 bool temp6 = false ;
33357 PyObject * obj0 = 0 ;
33358 PyObject * obj1 = 0 ;
33359 PyObject * obj2 = 0 ;
33360 PyObject * obj3 = 0 ;
33361 PyObject * obj4 = 0 ;
33362 PyObject * obj5 = 0 ;
33363 char *kwnames[] = {
33364 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33365 };
33366
33367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33369 if (SWIG_arg_fail(1)) SWIG_fail;
33370 {
33371 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33372 if (SWIG_arg_fail(2)) SWIG_fail;
33373 }
33374 {
33375 arg3 = (int)(SWIG_As_int(obj2));
33376 if (SWIG_arg_fail(3)) SWIG_fail;
33377 }
33378 {
33379 arg4 = wxString_in_helper(obj3);
33380 if (arg4 == NULL) SWIG_fail;
33381 temp4 = true;
33382 }
33383 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33384 if (SWIG_arg_fail(5)) SWIG_fail;
33385 if (obj5) {
33386 {
33387 arg6 = wxString_in_helper(obj5);
33388 if (arg6 == NULL) SWIG_fail;
33389 temp6 = true;
33390 }
33391 }
33392 {
33393 PyThreadState* __tstate = wxPyBeginAllowThreads();
33394 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33395
33396 wxPyEndAllowThreads(__tstate);
33397 if (PyErr_Occurred()) SWIG_fail;
33398 }
33399 {
33400 resultobj = wxPyMake_wxObject(result, 0);
33401 }
33402 {
33403 if (temp4)
33404 delete arg4;
33405 }
33406 {
33407 if (temp6)
33408 delete arg6;
33409 }
33410 return resultobj;
33411 fail:
33412 {
33413 if (temp4)
33414 delete arg4;
33415 }
33416 {
33417 if (temp6)
33418 delete arg6;
33419 }
33420 return NULL;
33421 }
33422
33423
33424 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33425 PyObject *resultobj;
33426 wxMenu *arg1 = (wxMenu *) 0 ;
33427 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33428 wxMenuItem *result;
33429 PyObject * obj0 = 0 ;
33430 PyObject * obj1 = 0 ;
33431 char *kwnames[] = {
33432 (char *) "self",(char *) "item", NULL
33433 };
33434
33435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33437 if (SWIG_arg_fail(1)) SWIG_fail;
33438 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33439 if (SWIG_arg_fail(2)) SWIG_fail;
33440 {
33441 PyThreadState* __tstate = wxPyBeginAllowThreads();
33442 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33443
33444 wxPyEndAllowThreads(__tstate);
33445 if (PyErr_Occurred()) SWIG_fail;
33446 }
33447 {
33448 resultobj = wxPyMake_wxObject(result, 0);
33449 }
33450 return resultobj;
33451 fail:
33452 return NULL;
33453 }
33454
33455
33456 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33457 PyObject *resultobj;
33458 wxMenu *arg1 = (wxMenu *) 0 ;
33459 int arg2 ;
33460 wxString *arg3 = 0 ;
33461 wxString const &arg4_defvalue = wxPyEmptyString ;
33462 wxString *arg4 = (wxString *) &arg4_defvalue ;
33463 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33464 wxMenuItem *result;
33465 bool temp3 = false ;
33466 bool temp4 = false ;
33467 PyObject * obj0 = 0 ;
33468 PyObject * obj1 = 0 ;
33469 PyObject * obj2 = 0 ;
33470 PyObject * obj3 = 0 ;
33471 PyObject * obj4 = 0 ;
33472 char *kwnames[] = {
33473 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33474 };
33475
33476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33478 if (SWIG_arg_fail(1)) SWIG_fail;
33479 {
33480 arg2 = (int)(SWIG_As_int(obj1));
33481 if (SWIG_arg_fail(2)) SWIG_fail;
33482 }
33483 {
33484 arg3 = wxString_in_helper(obj2);
33485 if (arg3 == NULL) SWIG_fail;
33486 temp3 = true;
33487 }
33488 if (obj3) {
33489 {
33490 arg4 = wxString_in_helper(obj3);
33491 if (arg4 == NULL) SWIG_fail;
33492 temp4 = true;
33493 }
33494 }
33495 if (obj4) {
33496 {
33497 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33498 if (SWIG_arg_fail(5)) SWIG_fail;
33499 }
33500 }
33501 {
33502 PyThreadState* __tstate = wxPyBeginAllowThreads();
33503 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33504
33505 wxPyEndAllowThreads(__tstate);
33506 if (PyErr_Occurred()) SWIG_fail;
33507 }
33508 {
33509 resultobj = wxPyMake_wxObject(result, 0);
33510 }
33511 {
33512 if (temp3)
33513 delete arg3;
33514 }
33515 {
33516 if (temp4)
33517 delete arg4;
33518 }
33519 return resultobj;
33520 fail:
33521 {
33522 if (temp3)
33523 delete arg3;
33524 }
33525 {
33526 if (temp4)
33527 delete arg4;
33528 }
33529 return NULL;
33530 }
33531
33532
33533 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33534 PyObject *resultobj;
33535 wxMenu *arg1 = (wxMenu *) 0 ;
33536 wxMenuItem *result;
33537 PyObject * obj0 = 0 ;
33538 char *kwnames[] = {
33539 (char *) "self", NULL
33540 };
33541
33542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33544 if (SWIG_arg_fail(1)) SWIG_fail;
33545 {
33546 PyThreadState* __tstate = wxPyBeginAllowThreads();
33547 result = (wxMenuItem *)(arg1)->PrependSeparator();
33548
33549 wxPyEndAllowThreads(__tstate);
33550 if (PyErr_Occurred()) SWIG_fail;
33551 }
33552 {
33553 resultobj = wxPyMake_wxObject(result, 0);
33554 }
33555 return resultobj;
33556 fail:
33557 return NULL;
33558 }
33559
33560
33561 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33562 PyObject *resultobj;
33563 wxMenu *arg1 = (wxMenu *) 0 ;
33564 int arg2 ;
33565 wxString *arg3 = 0 ;
33566 wxString const &arg4_defvalue = wxPyEmptyString ;
33567 wxString *arg4 = (wxString *) &arg4_defvalue ;
33568 wxMenuItem *result;
33569 bool temp3 = false ;
33570 bool temp4 = false ;
33571 PyObject * obj0 = 0 ;
33572 PyObject * obj1 = 0 ;
33573 PyObject * obj2 = 0 ;
33574 PyObject * obj3 = 0 ;
33575 char *kwnames[] = {
33576 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33577 };
33578
33579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33581 if (SWIG_arg_fail(1)) SWIG_fail;
33582 {
33583 arg2 = (int)(SWIG_As_int(obj1));
33584 if (SWIG_arg_fail(2)) SWIG_fail;
33585 }
33586 {
33587 arg3 = wxString_in_helper(obj2);
33588 if (arg3 == NULL) SWIG_fail;
33589 temp3 = true;
33590 }
33591 if (obj3) {
33592 {
33593 arg4 = wxString_in_helper(obj3);
33594 if (arg4 == NULL) SWIG_fail;
33595 temp4 = true;
33596 }
33597 }
33598 {
33599 PyThreadState* __tstate = wxPyBeginAllowThreads();
33600 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33601
33602 wxPyEndAllowThreads(__tstate);
33603 if (PyErr_Occurred()) SWIG_fail;
33604 }
33605 {
33606 resultobj = wxPyMake_wxObject(result, 0);
33607 }
33608 {
33609 if (temp3)
33610 delete arg3;
33611 }
33612 {
33613 if (temp4)
33614 delete arg4;
33615 }
33616 return resultobj;
33617 fail:
33618 {
33619 if (temp3)
33620 delete arg3;
33621 }
33622 {
33623 if (temp4)
33624 delete arg4;
33625 }
33626 return NULL;
33627 }
33628
33629
33630 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33631 PyObject *resultobj;
33632 wxMenu *arg1 = (wxMenu *) 0 ;
33633 int arg2 ;
33634 wxString *arg3 = 0 ;
33635 wxString const &arg4_defvalue = wxPyEmptyString ;
33636 wxString *arg4 = (wxString *) &arg4_defvalue ;
33637 wxMenuItem *result;
33638 bool temp3 = false ;
33639 bool temp4 = false ;
33640 PyObject * obj0 = 0 ;
33641 PyObject * obj1 = 0 ;
33642 PyObject * obj2 = 0 ;
33643 PyObject * obj3 = 0 ;
33644 char *kwnames[] = {
33645 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33646 };
33647
33648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33650 if (SWIG_arg_fail(1)) SWIG_fail;
33651 {
33652 arg2 = (int)(SWIG_As_int(obj1));
33653 if (SWIG_arg_fail(2)) SWIG_fail;
33654 }
33655 {
33656 arg3 = wxString_in_helper(obj2);
33657 if (arg3 == NULL) SWIG_fail;
33658 temp3 = true;
33659 }
33660 if (obj3) {
33661 {
33662 arg4 = wxString_in_helper(obj3);
33663 if (arg4 == NULL) SWIG_fail;
33664 temp4 = true;
33665 }
33666 }
33667 {
33668 PyThreadState* __tstate = wxPyBeginAllowThreads();
33669 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33670
33671 wxPyEndAllowThreads(__tstate);
33672 if (PyErr_Occurred()) SWIG_fail;
33673 }
33674 {
33675 resultobj = wxPyMake_wxObject(result, 0);
33676 }
33677 {
33678 if (temp3)
33679 delete arg3;
33680 }
33681 {
33682 if (temp4)
33683 delete arg4;
33684 }
33685 return resultobj;
33686 fail:
33687 {
33688 if (temp3)
33689 delete arg3;
33690 }
33691 {
33692 if (temp4)
33693 delete arg4;
33694 }
33695 return NULL;
33696 }
33697
33698
33699 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33700 PyObject *resultobj;
33701 wxMenu *arg1 = (wxMenu *) 0 ;
33702 int arg2 ;
33703 wxString *arg3 = 0 ;
33704 wxMenu *arg4 = (wxMenu *) 0 ;
33705 wxString const &arg5_defvalue = wxPyEmptyString ;
33706 wxString *arg5 = (wxString *) &arg5_defvalue ;
33707 wxMenuItem *result;
33708 bool temp3 = false ;
33709 bool temp5 = false ;
33710 PyObject * obj0 = 0 ;
33711 PyObject * obj1 = 0 ;
33712 PyObject * obj2 = 0 ;
33713 PyObject * obj3 = 0 ;
33714 PyObject * obj4 = 0 ;
33715 char *kwnames[] = {
33716 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33717 };
33718
33719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33721 if (SWIG_arg_fail(1)) SWIG_fail;
33722 {
33723 arg2 = (int)(SWIG_As_int(obj1));
33724 if (SWIG_arg_fail(2)) SWIG_fail;
33725 }
33726 {
33727 arg3 = wxString_in_helper(obj2);
33728 if (arg3 == NULL) SWIG_fail;
33729 temp3 = true;
33730 }
33731 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33732 if (SWIG_arg_fail(4)) SWIG_fail;
33733 if (obj4) {
33734 {
33735 arg5 = wxString_in_helper(obj4);
33736 if (arg5 == NULL) SWIG_fail;
33737 temp5 = true;
33738 }
33739 }
33740 {
33741 PyThreadState* __tstate = wxPyBeginAllowThreads();
33742 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33743
33744 wxPyEndAllowThreads(__tstate);
33745 if (PyErr_Occurred()) SWIG_fail;
33746 }
33747 {
33748 resultobj = wxPyMake_wxObject(result, 0);
33749 }
33750 {
33751 if (temp3)
33752 delete arg3;
33753 }
33754 {
33755 if (temp5)
33756 delete arg5;
33757 }
33758 return resultobj;
33759 fail:
33760 {
33761 if (temp3)
33762 delete arg3;
33763 }
33764 {
33765 if (temp5)
33766 delete arg5;
33767 }
33768 return NULL;
33769 }
33770
33771
33772 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33773 PyObject *resultobj;
33774 wxMenu *arg1 = (wxMenu *) 0 ;
33775 int arg2 ;
33776 wxMenuItem *result;
33777 PyObject * obj0 = 0 ;
33778 PyObject * obj1 = 0 ;
33779 char *kwnames[] = {
33780 (char *) "self",(char *) "id", NULL
33781 };
33782
33783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33785 if (SWIG_arg_fail(1)) SWIG_fail;
33786 {
33787 arg2 = (int)(SWIG_As_int(obj1));
33788 if (SWIG_arg_fail(2)) SWIG_fail;
33789 }
33790 {
33791 PyThreadState* __tstate = wxPyBeginAllowThreads();
33792 result = (wxMenuItem *)(arg1)->Remove(arg2);
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_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33807 PyObject *resultobj;
33808 wxMenu *arg1 = (wxMenu *) 0 ;
33809 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33810 wxMenuItem *result;
33811 PyObject * obj0 = 0 ;
33812 PyObject * obj1 = 0 ;
33813 char *kwnames[] = {
33814 (char *) "self",(char *) "item", NULL
33815 };
33816
33817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33819 if (SWIG_arg_fail(1)) SWIG_fail;
33820 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33821 if (SWIG_arg_fail(2)) SWIG_fail;
33822 {
33823 PyThreadState* __tstate = wxPyBeginAllowThreads();
33824 result = (wxMenuItem *)(arg1)->Remove(arg2);
33825
33826 wxPyEndAllowThreads(__tstate);
33827 if (PyErr_Occurred()) SWIG_fail;
33828 }
33829 {
33830 resultobj = wxPyMake_wxObject(result, 0);
33831 }
33832 return resultobj;
33833 fail:
33834 return NULL;
33835 }
33836
33837
33838 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33839 PyObject *resultobj;
33840 wxMenu *arg1 = (wxMenu *) 0 ;
33841 int arg2 ;
33842 bool result;
33843 PyObject * obj0 = 0 ;
33844 PyObject * obj1 = 0 ;
33845 char *kwnames[] = {
33846 (char *) "self",(char *) "id", NULL
33847 };
33848
33849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33851 if (SWIG_arg_fail(1)) SWIG_fail;
33852 {
33853 arg2 = (int)(SWIG_As_int(obj1));
33854 if (SWIG_arg_fail(2)) SWIG_fail;
33855 }
33856 {
33857 PyThreadState* __tstate = wxPyBeginAllowThreads();
33858 result = (bool)(arg1)->Delete(arg2);
33859
33860 wxPyEndAllowThreads(__tstate);
33861 if (PyErr_Occurred()) SWIG_fail;
33862 }
33863 {
33864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33865 }
33866 return resultobj;
33867 fail:
33868 return NULL;
33869 }
33870
33871
33872 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33873 PyObject *resultobj;
33874 wxMenu *arg1 = (wxMenu *) 0 ;
33875 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33876 bool result;
33877 PyObject * obj0 = 0 ;
33878 PyObject * obj1 = 0 ;
33879 char *kwnames[] = {
33880 (char *) "self",(char *) "item", NULL
33881 };
33882
33883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33885 if (SWIG_arg_fail(1)) SWIG_fail;
33886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33887 if (SWIG_arg_fail(2)) SWIG_fail;
33888 {
33889 PyThreadState* __tstate = wxPyBeginAllowThreads();
33890 result = (bool)(arg1)->Delete(arg2);
33891
33892 wxPyEndAllowThreads(__tstate);
33893 if (PyErr_Occurred()) SWIG_fail;
33894 }
33895 {
33896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33897 }
33898 return resultobj;
33899 fail:
33900 return NULL;
33901 }
33902
33903
33904 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33905 PyObject *resultobj;
33906 wxMenu *arg1 = (wxMenu *) 0 ;
33907 PyObject * obj0 = 0 ;
33908 char *kwnames[] = {
33909 (char *) "self", NULL
33910 };
33911
33912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33914 if (SWIG_arg_fail(1)) SWIG_fail;
33915 {
33916 PyThreadState* __tstate = wxPyBeginAllowThreads();
33917 wxMenu_Destroy(arg1);
33918
33919 wxPyEndAllowThreads(__tstate);
33920 if (PyErr_Occurred()) SWIG_fail;
33921 }
33922 Py_INCREF(Py_None); resultobj = Py_None;
33923 return resultobj;
33924 fail:
33925 return NULL;
33926 }
33927
33928
33929 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33930 PyObject *resultobj;
33931 wxMenu *arg1 = (wxMenu *) 0 ;
33932 int arg2 ;
33933 bool result;
33934 PyObject * obj0 = 0 ;
33935 PyObject * obj1 = 0 ;
33936 char *kwnames[] = {
33937 (char *) "self",(char *) "id", NULL
33938 };
33939
33940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33942 if (SWIG_arg_fail(1)) SWIG_fail;
33943 {
33944 arg2 = (int)(SWIG_As_int(obj1));
33945 if (SWIG_arg_fail(2)) SWIG_fail;
33946 }
33947 {
33948 PyThreadState* __tstate = wxPyBeginAllowThreads();
33949 result = (bool)(arg1)->Destroy(arg2);
33950
33951 wxPyEndAllowThreads(__tstate);
33952 if (PyErr_Occurred()) SWIG_fail;
33953 }
33954 {
33955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33956 }
33957 return resultobj;
33958 fail:
33959 return NULL;
33960 }
33961
33962
33963 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33964 PyObject *resultobj;
33965 wxMenu *arg1 = (wxMenu *) 0 ;
33966 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33967 bool result;
33968 PyObject * obj0 = 0 ;
33969 PyObject * obj1 = 0 ;
33970 char *kwnames[] = {
33971 (char *) "self",(char *) "item", NULL
33972 };
33973
33974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33976 if (SWIG_arg_fail(1)) SWIG_fail;
33977 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33978 if (SWIG_arg_fail(2)) SWIG_fail;
33979 {
33980 PyThreadState* __tstate = wxPyBeginAllowThreads();
33981 result = (bool)(arg1)->Destroy(arg2);
33982
33983 wxPyEndAllowThreads(__tstate);
33984 if (PyErr_Occurred()) SWIG_fail;
33985 }
33986 {
33987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33988 }
33989 return resultobj;
33990 fail:
33991 return NULL;
33992 }
33993
33994
33995 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33996 PyObject *resultobj;
33997 wxMenu *arg1 = (wxMenu *) 0 ;
33998 size_t result;
33999 PyObject * obj0 = 0 ;
34000 char *kwnames[] = {
34001 (char *) "self", NULL
34002 };
34003
34004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34006 if (SWIG_arg_fail(1)) SWIG_fail;
34007 {
34008 PyThreadState* __tstate = wxPyBeginAllowThreads();
34009 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34010
34011 wxPyEndAllowThreads(__tstate);
34012 if (PyErr_Occurred()) SWIG_fail;
34013 }
34014 {
34015 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34016 }
34017 return resultobj;
34018 fail:
34019 return NULL;
34020 }
34021
34022
34023 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34024 PyObject *resultobj;
34025 wxMenu *arg1 = (wxMenu *) 0 ;
34026 PyObject *result;
34027 PyObject * obj0 = 0 ;
34028 char *kwnames[] = {
34029 (char *) "self", NULL
34030 };
34031
34032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34034 if (SWIG_arg_fail(1)) SWIG_fail;
34035 {
34036 PyThreadState* __tstate = wxPyBeginAllowThreads();
34037 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34038
34039 wxPyEndAllowThreads(__tstate);
34040 if (PyErr_Occurred()) SWIG_fail;
34041 }
34042 resultobj = result;
34043 return resultobj;
34044 fail:
34045 return NULL;
34046 }
34047
34048
34049 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34050 PyObject *resultobj;
34051 wxMenu *arg1 = (wxMenu *) 0 ;
34052 wxString *arg2 = 0 ;
34053 int result;
34054 bool temp2 = false ;
34055 PyObject * obj0 = 0 ;
34056 PyObject * obj1 = 0 ;
34057 char *kwnames[] = {
34058 (char *) "self",(char *) "item", NULL
34059 };
34060
34061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34063 if (SWIG_arg_fail(1)) SWIG_fail;
34064 {
34065 arg2 = wxString_in_helper(obj1);
34066 if (arg2 == NULL) SWIG_fail;
34067 temp2 = true;
34068 }
34069 {
34070 PyThreadState* __tstate = wxPyBeginAllowThreads();
34071 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34072
34073 wxPyEndAllowThreads(__tstate);
34074 if (PyErr_Occurred()) SWIG_fail;
34075 }
34076 {
34077 resultobj = SWIG_From_int((int)(result));
34078 }
34079 {
34080 if (temp2)
34081 delete arg2;
34082 }
34083 return resultobj;
34084 fail:
34085 {
34086 if (temp2)
34087 delete arg2;
34088 }
34089 return NULL;
34090 }
34091
34092
34093 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34094 PyObject *resultobj;
34095 wxMenu *arg1 = (wxMenu *) 0 ;
34096 int arg2 ;
34097 wxMenuItem *result;
34098 PyObject * obj0 = 0 ;
34099 PyObject * obj1 = 0 ;
34100 char *kwnames[] = {
34101 (char *) "self",(char *) "id", NULL
34102 };
34103
34104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34106 if (SWIG_arg_fail(1)) SWIG_fail;
34107 {
34108 arg2 = (int)(SWIG_As_int(obj1));
34109 if (SWIG_arg_fail(2)) SWIG_fail;
34110 }
34111 {
34112 PyThreadState* __tstate = wxPyBeginAllowThreads();
34113 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34114
34115 wxPyEndAllowThreads(__tstate);
34116 if (PyErr_Occurred()) SWIG_fail;
34117 }
34118 {
34119 resultobj = wxPyMake_wxObject(result, 0);
34120 }
34121 return resultobj;
34122 fail:
34123 return NULL;
34124 }
34125
34126
34127 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34128 PyObject *resultobj;
34129 wxMenu *arg1 = (wxMenu *) 0 ;
34130 size_t arg2 ;
34131 wxMenuItem *result;
34132 PyObject * obj0 = 0 ;
34133 PyObject * obj1 = 0 ;
34134 char *kwnames[] = {
34135 (char *) "self",(char *) "position", NULL
34136 };
34137
34138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34140 if (SWIG_arg_fail(1)) SWIG_fail;
34141 {
34142 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34143 if (SWIG_arg_fail(2)) SWIG_fail;
34144 }
34145 {
34146 PyThreadState* __tstate = wxPyBeginAllowThreads();
34147 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34148
34149 wxPyEndAllowThreads(__tstate);
34150 if (PyErr_Occurred()) SWIG_fail;
34151 }
34152 {
34153 resultobj = wxPyMake_wxObject(result, 0);
34154 }
34155 return resultobj;
34156 fail:
34157 return NULL;
34158 }
34159
34160
34161 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34162 PyObject *resultobj;
34163 wxMenu *arg1 = (wxMenu *) 0 ;
34164 int arg2 ;
34165 bool arg3 ;
34166 PyObject * obj0 = 0 ;
34167 PyObject * obj1 = 0 ;
34168 PyObject * obj2 = 0 ;
34169 char *kwnames[] = {
34170 (char *) "self",(char *) "id",(char *) "enable", NULL
34171 };
34172
34173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34175 if (SWIG_arg_fail(1)) SWIG_fail;
34176 {
34177 arg2 = (int)(SWIG_As_int(obj1));
34178 if (SWIG_arg_fail(2)) SWIG_fail;
34179 }
34180 {
34181 arg3 = (bool)(SWIG_As_bool(obj2));
34182 if (SWIG_arg_fail(3)) SWIG_fail;
34183 }
34184 {
34185 PyThreadState* __tstate = wxPyBeginAllowThreads();
34186 (arg1)->Enable(arg2,arg3);
34187
34188 wxPyEndAllowThreads(__tstate);
34189 if (PyErr_Occurred()) SWIG_fail;
34190 }
34191 Py_INCREF(Py_None); resultobj = Py_None;
34192 return resultobj;
34193 fail:
34194 return NULL;
34195 }
34196
34197
34198 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34199 PyObject *resultobj;
34200 wxMenu *arg1 = (wxMenu *) 0 ;
34201 int arg2 ;
34202 bool result;
34203 PyObject * obj0 = 0 ;
34204 PyObject * obj1 = 0 ;
34205 char *kwnames[] = {
34206 (char *) "self",(char *) "id", NULL
34207 };
34208
34209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34211 if (SWIG_arg_fail(1)) SWIG_fail;
34212 {
34213 arg2 = (int)(SWIG_As_int(obj1));
34214 if (SWIG_arg_fail(2)) SWIG_fail;
34215 }
34216 {
34217 PyThreadState* __tstate = wxPyBeginAllowThreads();
34218 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34219
34220 wxPyEndAllowThreads(__tstate);
34221 if (PyErr_Occurred()) SWIG_fail;
34222 }
34223 {
34224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34225 }
34226 return resultobj;
34227 fail:
34228 return NULL;
34229 }
34230
34231
34232 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34233 PyObject *resultobj;
34234 wxMenu *arg1 = (wxMenu *) 0 ;
34235 int arg2 ;
34236 bool arg3 ;
34237 PyObject * obj0 = 0 ;
34238 PyObject * obj1 = 0 ;
34239 PyObject * obj2 = 0 ;
34240 char *kwnames[] = {
34241 (char *) "self",(char *) "id",(char *) "check", NULL
34242 };
34243
34244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34246 if (SWIG_arg_fail(1)) SWIG_fail;
34247 {
34248 arg2 = (int)(SWIG_As_int(obj1));
34249 if (SWIG_arg_fail(2)) SWIG_fail;
34250 }
34251 {
34252 arg3 = (bool)(SWIG_As_bool(obj2));
34253 if (SWIG_arg_fail(3)) SWIG_fail;
34254 }
34255 {
34256 PyThreadState* __tstate = wxPyBeginAllowThreads();
34257 (arg1)->Check(arg2,arg3);
34258
34259 wxPyEndAllowThreads(__tstate);
34260 if (PyErr_Occurred()) SWIG_fail;
34261 }
34262 Py_INCREF(Py_None); resultobj = Py_None;
34263 return resultobj;
34264 fail:
34265 return NULL;
34266 }
34267
34268
34269 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34270 PyObject *resultobj;
34271 wxMenu *arg1 = (wxMenu *) 0 ;
34272 int arg2 ;
34273 bool result;
34274 PyObject * obj0 = 0 ;
34275 PyObject * obj1 = 0 ;
34276 char *kwnames[] = {
34277 (char *) "self",(char *) "id", NULL
34278 };
34279
34280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34282 if (SWIG_arg_fail(1)) SWIG_fail;
34283 {
34284 arg2 = (int)(SWIG_As_int(obj1));
34285 if (SWIG_arg_fail(2)) SWIG_fail;
34286 }
34287 {
34288 PyThreadState* __tstate = wxPyBeginAllowThreads();
34289 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34290
34291 wxPyEndAllowThreads(__tstate);
34292 if (PyErr_Occurred()) SWIG_fail;
34293 }
34294 {
34295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34296 }
34297 return resultobj;
34298 fail:
34299 return NULL;
34300 }
34301
34302
34303 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34304 PyObject *resultobj;
34305 wxMenu *arg1 = (wxMenu *) 0 ;
34306 int arg2 ;
34307 wxString *arg3 = 0 ;
34308 bool temp3 = false ;
34309 PyObject * obj0 = 0 ;
34310 PyObject * obj1 = 0 ;
34311 PyObject * obj2 = 0 ;
34312 char *kwnames[] = {
34313 (char *) "self",(char *) "id",(char *) "label", NULL
34314 };
34315
34316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34318 if (SWIG_arg_fail(1)) SWIG_fail;
34319 {
34320 arg2 = (int)(SWIG_As_int(obj1));
34321 if (SWIG_arg_fail(2)) SWIG_fail;
34322 }
34323 {
34324 arg3 = wxString_in_helper(obj2);
34325 if (arg3 == NULL) SWIG_fail;
34326 temp3 = true;
34327 }
34328 {
34329 PyThreadState* __tstate = wxPyBeginAllowThreads();
34330 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34331
34332 wxPyEndAllowThreads(__tstate);
34333 if (PyErr_Occurred()) SWIG_fail;
34334 }
34335 Py_INCREF(Py_None); resultobj = Py_None;
34336 {
34337 if (temp3)
34338 delete arg3;
34339 }
34340 return resultobj;
34341 fail:
34342 {
34343 if (temp3)
34344 delete arg3;
34345 }
34346 return NULL;
34347 }
34348
34349
34350 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34351 PyObject *resultobj;
34352 wxMenu *arg1 = (wxMenu *) 0 ;
34353 int arg2 ;
34354 wxString result;
34355 PyObject * obj0 = 0 ;
34356 PyObject * obj1 = 0 ;
34357 char *kwnames[] = {
34358 (char *) "self",(char *) "id", NULL
34359 };
34360
34361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34363 if (SWIG_arg_fail(1)) SWIG_fail;
34364 {
34365 arg2 = (int)(SWIG_As_int(obj1));
34366 if (SWIG_arg_fail(2)) SWIG_fail;
34367 }
34368 {
34369 PyThreadState* __tstate = wxPyBeginAllowThreads();
34370 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34371
34372 wxPyEndAllowThreads(__tstate);
34373 if (PyErr_Occurred()) SWIG_fail;
34374 }
34375 {
34376 #if wxUSE_UNICODE
34377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34378 #else
34379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34380 #endif
34381 }
34382 return resultobj;
34383 fail:
34384 return NULL;
34385 }
34386
34387
34388 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34389 PyObject *resultobj;
34390 wxMenu *arg1 = (wxMenu *) 0 ;
34391 int arg2 ;
34392 wxString *arg3 = 0 ;
34393 bool temp3 = false ;
34394 PyObject * obj0 = 0 ;
34395 PyObject * obj1 = 0 ;
34396 PyObject * obj2 = 0 ;
34397 char *kwnames[] = {
34398 (char *) "self",(char *) "id",(char *) "helpString", NULL
34399 };
34400
34401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34403 if (SWIG_arg_fail(1)) SWIG_fail;
34404 {
34405 arg2 = (int)(SWIG_As_int(obj1));
34406 if (SWIG_arg_fail(2)) SWIG_fail;
34407 }
34408 {
34409 arg3 = wxString_in_helper(obj2);
34410 if (arg3 == NULL) SWIG_fail;
34411 temp3 = true;
34412 }
34413 {
34414 PyThreadState* __tstate = wxPyBeginAllowThreads();
34415 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34416
34417 wxPyEndAllowThreads(__tstate);
34418 if (PyErr_Occurred()) SWIG_fail;
34419 }
34420 Py_INCREF(Py_None); resultobj = Py_None;
34421 {
34422 if (temp3)
34423 delete arg3;
34424 }
34425 return resultobj;
34426 fail:
34427 {
34428 if (temp3)
34429 delete arg3;
34430 }
34431 return NULL;
34432 }
34433
34434
34435 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34436 PyObject *resultobj;
34437 wxMenu *arg1 = (wxMenu *) 0 ;
34438 int arg2 ;
34439 wxString result;
34440 PyObject * obj0 = 0 ;
34441 PyObject * obj1 = 0 ;
34442 char *kwnames[] = {
34443 (char *) "self",(char *) "id", NULL
34444 };
34445
34446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34448 if (SWIG_arg_fail(1)) SWIG_fail;
34449 {
34450 arg2 = (int)(SWIG_As_int(obj1));
34451 if (SWIG_arg_fail(2)) SWIG_fail;
34452 }
34453 {
34454 PyThreadState* __tstate = wxPyBeginAllowThreads();
34455 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34456
34457 wxPyEndAllowThreads(__tstate);
34458 if (PyErr_Occurred()) SWIG_fail;
34459 }
34460 {
34461 #if wxUSE_UNICODE
34462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34463 #else
34464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34465 #endif
34466 }
34467 return resultobj;
34468 fail:
34469 return NULL;
34470 }
34471
34472
34473 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34474 PyObject *resultobj;
34475 wxMenu *arg1 = (wxMenu *) 0 ;
34476 wxString *arg2 = 0 ;
34477 bool temp2 = false ;
34478 PyObject * obj0 = 0 ;
34479 PyObject * obj1 = 0 ;
34480 char *kwnames[] = {
34481 (char *) "self",(char *) "title", NULL
34482 };
34483
34484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34486 if (SWIG_arg_fail(1)) SWIG_fail;
34487 {
34488 arg2 = wxString_in_helper(obj1);
34489 if (arg2 == NULL) SWIG_fail;
34490 temp2 = true;
34491 }
34492 {
34493 PyThreadState* __tstate = wxPyBeginAllowThreads();
34494 (arg1)->SetTitle((wxString const &)*arg2);
34495
34496 wxPyEndAllowThreads(__tstate);
34497 if (PyErr_Occurred()) SWIG_fail;
34498 }
34499 Py_INCREF(Py_None); resultobj = Py_None;
34500 {
34501 if (temp2)
34502 delete arg2;
34503 }
34504 return resultobj;
34505 fail:
34506 {
34507 if (temp2)
34508 delete arg2;
34509 }
34510 return NULL;
34511 }
34512
34513
34514 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34515 PyObject *resultobj;
34516 wxMenu *arg1 = (wxMenu *) 0 ;
34517 wxString result;
34518 PyObject * obj0 = 0 ;
34519 char *kwnames[] = {
34520 (char *) "self", NULL
34521 };
34522
34523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34525 if (SWIG_arg_fail(1)) SWIG_fail;
34526 {
34527 PyThreadState* __tstate = wxPyBeginAllowThreads();
34528 result = ((wxMenu const *)arg1)->GetTitle();
34529
34530 wxPyEndAllowThreads(__tstate);
34531 if (PyErr_Occurred()) SWIG_fail;
34532 }
34533 {
34534 #if wxUSE_UNICODE
34535 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34536 #else
34537 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34538 #endif
34539 }
34540 return resultobj;
34541 fail:
34542 return NULL;
34543 }
34544
34545
34546 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34547 PyObject *resultobj;
34548 wxMenu *arg1 = (wxMenu *) 0 ;
34549 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34550 PyObject * obj0 = 0 ;
34551 PyObject * obj1 = 0 ;
34552 char *kwnames[] = {
34553 (char *) "self",(char *) "handler", NULL
34554 };
34555
34556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34558 if (SWIG_arg_fail(1)) SWIG_fail;
34559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34560 if (SWIG_arg_fail(2)) SWIG_fail;
34561 {
34562 PyThreadState* __tstate = wxPyBeginAllowThreads();
34563 (arg1)->SetEventHandler(arg2);
34564
34565 wxPyEndAllowThreads(__tstate);
34566 if (PyErr_Occurred()) SWIG_fail;
34567 }
34568 Py_INCREF(Py_None); resultobj = Py_None;
34569 return resultobj;
34570 fail:
34571 return NULL;
34572 }
34573
34574
34575 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34576 PyObject *resultobj;
34577 wxMenu *arg1 = (wxMenu *) 0 ;
34578 wxEvtHandler *result;
34579 PyObject * obj0 = 0 ;
34580 char *kwnames[] = {
34581 (char *) "self", NULL
34582 };
34583
34584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34586 if (SWIG_arg_fail(1)) SWIG_fail;
34587 {
34588 PyThreadState* __tstate = wxPyBeginAllowThreads();
34589 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34590
34591 wxPyEndAllowThreads(__tstate);
34592 if (PyErr_Occurred()) SWIG_fail;
34593 }
34594 {
34595 resultobj = wxPyMake_wxObject(result, 0);
34596 }
34597 return resultobj;
34598 fail:
34599 return NULL;
34600 }
34601
34602
34603 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34604 PyObject *resultobj;
34605 wxMenu *arg1 = (wxMenu *) 0 ;
34606 wxWindow *arg2 = (wxWindow *) 0 ;
34607 PyObject * obj0 = 0 ;
34608 PyObject * obj1 = 0 ;
34609 char *kwnames[] = {
34610 (char *) "self",(char *) "win", NULL
34611 };
34612
34613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34615 if (SWIG_arg_fail(1)) SWIG_fail;
34616 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34617 if (SWIG_arg_fail(2)) SWIG_fail;
34618 {
34619 PyThreadState* __tstate = wxPyBeginAllowThreads();
34620 (arg1)->SetInvokingWindow(arg2);
34621
34622 wxPyEndAllowThreads(__tstate);
34623 if (PyErr_Occurred()) SWIG_fail;
34624 }
34625 Py_INCREF(Py_None); resultobj = Py_None;
34626 return resultobj;
34627 fail:
34628 return NULL;
34629 }
34630
34631
34632 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34633 PyObject *resultobj;
34634 wxMenu *arg1 = (wxMenu *) 0 ;
34635 wxWindow *result;
34636 PyObject * obj0 = 0 ;
34637 char *kwnames[] = {
34638 (char *) "self", NULL
34639 };
34640
34641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34643 if (SWIG_arg_fail(1)) SWIG_fail;
34644 {
34645 PyThreadState* __tstate = wxPyBeginAllowThreads();
34646 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34647
34648 wxPyEndAllowThreads(__tstate);
34649 if (PyErr_Occurred()) SWIG_fail;
34650 }
34651 {
34652 resultobj = wxPyMake_wxObject(result, 0);
34653 }
34654 return resultobj;
34655 fail:
34656 return NULL;
34657 }
34658
34659
34660 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34661 PyObject *resultobj;
34662 wxMenu *arg1 = (wxMenu *) 0 ;
34663 long result;
34664 PyObject * obj0 = 0 ;
34665 char *kwnames[] = {
34666 (char *) "self", NULL
34667 };
34668
34669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34671 if (SWIG_arg_fail(1)) SWIG_fail;
34672 {
34673 PyThreadState* __tstate = wxPyBeginAllowThreads();
34674 result = (long)((wxMenu const *)arg1)->GetStyle();
34675
34676 wxPyEndAllowThreads(__tstate);
34677 if (PyErr_Occurred()) SWIG_fail;
34678 }
34679 {
34680 resultobj = SWIG_From_long((long)(result));
34681 }
34682 return resultobj;
34683 fail:
34684 return NULL;
34685 }
34686
34687
34688 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34689 PyObject *resultobj;
34690 wxMenu *arg1 = (wxMenu *) 0 ;
34691 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34692 PyObject * obj0 = 0 ;
34693 PyObject * obj1 = 0 ;
34694 char *kwnames[] = {
34695 (char *) "self",(char *) "source", NULL
34696 };
34697
34698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34700 if (SWIG_arg_fail(1)) SWIG_fail;
34701 if (obj1) {
34702 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34703 if (SWIG_arg_fail(2)) SWIG_fail;
34704 }
34705 {
34706 PyThreadState* __tstate = wxPyBeginAllowThreads();
34707 (arg1)->UpdateUI(arg2);
34708
34709 wxPyEndAllowThreads(__tstate);
34710 if (PyErr_Occurred()) SWIG_fail;
34711 }
34712 Py_INCREF(Py_None); resultobj = Py_None;
34713 return resultobj;
34714 fail:
34715 return NULL;
34716 }
34717
34718
34719 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34720 PyObject *resultobj;
34721 wxMenu *arg1 = (wxMenu *) 0 ;
34722 wxMenuBar *result;
34723 PyObject * obj0 = 0 ;
34724 char *kwnames[] = {
34725 (char *) "self", NULL
34726 };
34727
34728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34730 if (SWIG_arg_fail(1)) SWIG_fail;
34731 {
34732 PyThreadState* __tstate = wxPyBeginAllowThreads();
34733 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34734
34735 wxPyEndAllowThreads(__tstate);
34736 if (PyErr_Occurred()) SWIG_fail;
34737 }
34738 {
34739 resultobj = wxPyMake_wxObject(result, 0);
34740 }
34741 return resultobj;
34742 fail:
34743 return NULL;
34744 }
34745
34746
34747 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34748 PyObject *resultobj;
34749 wxMenu *arg1 = (wxMenu *) 0 ;
34750 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34751 PyObject * obj0 = 0 ;
34752 PyObject * obj1 = 0 ;
34753 char *kwnames[] = {
34754 (char *) "self",(char *) "menubar", NULL
34755 };
34756
34757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34759 if (SWIG_arg_fail(1)) SWIG_fail;
34760 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34761 if (SWIG_arg_fail(2)) SWIG_fail;
34762 {
34763 PyThreadState* __tstate = wxPyBeginAllowThreads();
34764 (arg1)->Attach(arg2);
34765
34766 wxPyEndAllowThreads(__tstate);
34767 if (PyErr_Occurred()) SWIG_fail;
34768 }
34769 Py_INCREF(Py_None); resultobj = Py_None;
34770 return resultobj;
34771 fail:
34772 return NULL;
34773 }
34774
34775
34776 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34777 PyObject *resultobj;
34778 wxMenu *arg1 = (wxMenu *) 0 ;
34779 PyObject * obj0 = 0 ;
34780 char *kwnames[] = {
34781 (char *) "self", NULL
34782 };
34783
34784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34786 if (SWIG_arg_fail(1)) SWIG_fail;
34787 {
34788 PyThreadState* __tstate = wxPyBeginAllowThreads();
34789 (arg1)->Detach();
34790
34791 wxPyEndAllowThreads(__tstate);
34792 if (PyErr_Occurred()) SWIG_fail;
34793 }
34794 Py_INCREF(Py_None); resultobj = Py_None;
34795 return resultobj;
34796 fail:
34797 return NULL;
34798 }
34799
34800
34801 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34802 PyObject *resultobj;
34803 wxMenu *arg1 = (wxMenu *) 0 ;
34804 bool result;
34805 PyObject * obj0 = 0 ;
34806 char *kwnames[] = {
34807 (char *) "self", NULL
34808 };
34809
34810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34812 if (SWIG_arg_fail(1)) SWIG_fail;
34813 {
34814 PyThreadState* __tstate = wxPyBeginAllowThreads();
34815 result = (bool)((wxMenu const *)arg1)->IsAttached();
34816
34817 wxPyEndAllowThreads(__tstate);
34818 if (PyErr_Occurred()) SWIG_fail;
34819 }
34820 {
34821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34822 }
34823 return resultobj;
34824 fail:
34825 return NULL;
34826 }
34827
34828
34829 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34830 PyObject *resultobj;
34831 wxMenu *arg1 = (wxMenu *) 0 ;
34832 wxMenu *arg2 = (wxMenu *) 0 ;
34833 PyObject * obj0 = 0 ;
34834 PyObject * obj1 = 0 ;
34835 char *kwnames[] = {
34836 (char *) "self",(char *) "parent", NULL
34837 };
34838
34839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34841 if (SWIG_arg_fail(1)) SWIG_fail;
34842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34843 if (SWIG_arg_fail(2)) SWIG_fail;
34844 {
34845 PyThreadState* __tstate = wxPyBeginAllowThreads();
34846 (arg1)->SetParent(arg2);
34847
34848 wxPyEndAllowThreads(__tstate);
34849 if (PyErr_Occurred()) SWIG_fail;
34850 }
34851 Py_INCREF(Py_None); resultobj = Py_None;
34852 return resultobj;
34853 fail:
34854 return NULL;
34855 }
34856
34857
34858 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34859 PyObject *resultobj;
34860 wxMenu *arg1 = (wxMenu *) 0 ;
34861 wxMenu *result;
34862 PyObject * obj0 = 0 ;
34863 char *kwnames[] = {
34864 (char *) "self", NULL
34865 };
34866
34867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34869 if (SWIG_arg_fail(1)) SWIG_fail;
34870 {
34871 PyThreadState* __tstate = wxPyBeginAllowThreads();
34872 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34873
34874 wxPyEndAllowThreads(__tstate);
34875 if (PyErr_Occurred()) SWIG_fail;
34876 }
34877 {
34878 resultobj = wxPyMake_wxObject(result, 0);
34879 }
34880 return resultobj;
34881 fail:
34882 return NULL;
34883 }
34884
34885
34886 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34887 PyObject *obj;
34888 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34889 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34890 Py_INCREF(obj);
34891 return Py_BuildValue((char *)"");
34892 }
34893 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34894 PyObject *resultobj;
34895 long arg1 = (long) 0 ;
34896 wxMenuBar *result;
34897 PyObject * obj0 = 0 ;
34898 char *kwnames[] = {
34899 (char *) "style", NULL
34900 };
34901
34902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34903 if (obj0) {
34904 {
34905 arg1 = (long)(SWIG_As_long(obj0));
34906 if (SWIG_arg_fail(1)) SWIG_fail;
34907 }
34908 }
34909 {
34910 if (!wxPyCheckForApp()) SWIG_fail;
34911 PyThreadState* __tstate = wxPyBeginAllowThreads();
34912 result = (wxMenuBar *)new wxMenuBar(arg1);
34913
34914 wxPyEndAllowThreads(__tstate);
34915 if (PyErr_Occurred()) SWIG_fail;
34916 }
34917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34918 return resultobj;
34919 fail:
34920 return NULL;
34921 }
34922
34923
34924 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34925 PyObject *resultobj;
34926 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34927 wxMenu *arg2 = (wxMenu *) 0 ;
34928 wxString *arg3 = 0 ;
34929 bool result;
34930 bool temp3 = false ;
34931 PyObject * obj0 = 0 ;
34932 PyObject * obj1 = 0 ;
34933 PyObject * obj2 = 0 ;
34934 char *kwnames[] = {
34935 (char *) "self",(char *) "menu",(char *) "title", NULL
34936 };
34937
34938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34940 if (SWIG_arg_fail(1)) SWIG_fail;
34941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34942 if (SWIG_arg_fail(2)) SWIG_fail;
34943 {
34944 arg3 = wxString_in_helper(obj2);
34945 if (arg3 == NULL) SWIG_fail;
34946 temp3 = true;
34947 }
34948 {
34949 PyThreadState* __tstate = wxPyBeginAllowThreads();
34950 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34951
34952 wxPyEndAllowThreads(__tstate);
34953 if (PyErr_Occurred()) SWIG_fail;
34954 }
34955 {
34956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34957 }
34958 {
34959 if (temp3)
34960 delete arg3;
34961 }
34962 return resultobj;
34963 fail:
34964 {
34965 if (temp3)
34966 delete arg3;
34967 }
34968 return NULL;
34969 }
34970
34971
34972 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34973 PyObject *resultobj;
34974 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34975 size_t arg2 ;
34976 wxMenu *arg3 = (wxMenu *) 0 ;
34977 wxString *arg4 = 0 ;
34978 bool result;
34979 bool temp4 = false ;
34980 PyObject * obj0 = 0 ;
34981 PyObject * obj1 = 0 ;
34982 PyObject * obj2 = 0 ;
34983 PyObject * obj3 = 0 ;
34984 char *kwnames[] = {
34985 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34986 };
34987
34988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34990 if (SWIG_arg_fail(1)) SWIG_fail;
34991 {
34992 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34993 if (SWIG_arg_fail(2)) SWIG_fail;
34994 }
34995 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34996 if (SWIG_arg_fail(3)) SWIG_fail;
34997 {
34998 arg4 = wxString_in_helper(obj3);
34999 if (arg4 == NULL) SWIG_fail;
35000 temp4 = true;
35001 }
35002 {
35003 PyThreadState* __tstate = wxPyBeginAllowThreads();
35004 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35005
35006 wxPyEndAllowThreads(__tstate);
35007 if (PyErr_Occurred()) SWIG_fail;
35008 }
35009 {
35010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35011 }
35012 {
35013 if (temp4)
35014 delete arg4;
35015 }
35016 return resultobj;
35017 fail:
35018 {
35019 if (temp4)
35020 delete arg4;
35021 }
35022 return NULL;
35023 }
35024
35025
35026 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35027 PyObject *resultobj;
35028 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35029 size_t result;
35030 PyObject * obj0 = 0 ;
35031 char *kwnames[] = {
35032 (char *) "self", NULL
35033 };
35034
35035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35037 if (SWIG_arg_fail(1)) SWIG_fail;
35038 {
35039 PyThreadState* __tstate = wxPyBeginAllowThreads();
35040 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35041
35042 wxPyEndAllowThreads(__tstate);
35043 if (PyErr_Occurred()) SWIG_fail;
35044 }
35045 {
35046 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35047 }
35048 return resultobj;
35049 fail:
35050 return NULL;
35051 }
35052
35053
35054 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35055 PyObject *resultobj;
35056 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35057 size_t arg2 ;
35058 wxMenu *result;
35059 PyObject * obj0 = 0 ;
35060 PyObject * obj1 = 0 ;
35061 char *kwnames[] = {
35062 (char *) "self",(char *) "pos", NULL
35063 };
35064
35065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35067 if (SWIG_arg_fail(1)) SWIG_fail;
35068 {
35069 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35070 if (SWIG_arg_fail(2)) SWIG_fail;
35071 }
35072 {
35073 PyThreadState* __tstate = wxPyBeginAllowThreads();
35074 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35075
35076 wxPyEndAllowThreads(__tstate);
35077 if (PyErr_Occurred()) SWIG_fail;
35078 }
35079 {
35080 resultobj = wxPyMake_wxObject(result, 0);
35081 }
35082 return resultobj;
35083 fail:
35084 return NULL;
35085 }
35086
35087
35088 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35089 PyObject *resultobj;
35090 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35091 size_t arg2 ;
35092 wxMenu *arg3 = (wxMenu *) 0 ;
35093 wxString *arg4 = 0 ;
35094 wxMenu *result;
35095 bool temp4 = false ;
35096 PyObject * obj0 = 0 ;
35097 PyObject * obj1 = 0 ;
35098 PyObject * obj2 = 0 ;
35099 PyObject * obj3 = 0 ;
35100 char *kwnames[] = {
35101 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35102 };
35103
35104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35106 if (SWIG_arg_fail(1)) SWIG_fail;
35107 {
35108 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35109 if (SWIG_arg_fail(2)) SWIG_fail;
35110 }
35111 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35112 if (SWIG_arg_fail(3)) SWIG_fail;
35113 {
35114 arg4 = wxString_in_helper(obj3);
35115 if (arg4 == NULL) SWIG_fail;
35116 temp4 = true;
35117 }
35118 {
35119 PyThreadState* __tstate = wxPyBeginAllowThreads();
35120 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35121
35122 wxPyEndAllowThreads(__tstate);
35123 if (PyErr_Occurred()) SWIG_fail;
35124 }
35125 {
35126 resultobj = wxPyMake_wxObject(result, 0);
35127 }
35128 {
35129 if (temp4)
35130 delete arg4;
35131 }
35132 return resultobj;
35133 fail:
35134 {
35135 if (temp4)
35136 delete arg4;
35137 }
35138 return NULL;
35139 }
35140
35141
35142 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35143 PyObject *resultobj;
35144 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35145 size_t arg2 ;
35146 wxMenu *result;
35147 PyObject * obj0 = 0 ;
35148 PyObject * obj1 = 0 ;
35149 char *kwnames[] = {
35150 (char *) "self",(char *) "pos", NULL
35151 };
35152
35153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35155 if (SWIG_arg_fail(1)) SWIG_fail;
35156 {
35157 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35158 if (SWIG_arg_fail(2)) SWIG_fail;
35159 }
35160 {
35161 PyThreadState* __tstate = wxPyBeginAllowThreads();
35162 result = (wxMenu *)(arg1)->Remove(arg2);
35163
35164 wxPyEndAllowThreads(__tstate);
35165 if (PyErr_Occurred()) SWIG_fail;
35166 }
35167 {
35168 resultobj = wxPyMake_wxObject(result, 0);
35169 }
35170 return resultobj;
35171 fail:
35172 return NULL;
35173 }
35174
35175
35176 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35177 PyObject *resultobj;
35178 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35179 size_t arg2 ;
35180 bool arg3 ;
35181 PyObject * obj0 = 0 ;
35182 PyObject * obj1 = 0 ;
35183 PyObject * obj2 = 0 ;
35184 char *kwnames[] = {
35185 (char *) "self",(char *) "pos",(char *) "enable", NULL
35186 };
35187
35188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35190 if (SWIG_arg_fail(1)) SWIG_fail;
35191 {
35192 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35193 if (SWIG_arg_fail(2)) SWIG_fail;
35194 }
35195 {
35196 arg3 = (bool)(SWIG_As_bool(obj2));
35197 if (SWIG_arg_fail(3)) SWIG_fail;
35198 }
35199 {
35200 PyThreadState* __tstate = wxPyBeginAllowThreads();
35201 (arg1)->EnableTop(arg2,arg3);
35202
35203 wxPyEndAllowThreads(__tstate);
35204 if (PyErr_Occurred()) SWIG_fail;
35205 }
35206 Py_INCREF(Py_None); resultobj = Py_None;
35207 return resultobj;
35208 fail:
35209 return NULL;
35210 }
35211
35212
35213 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35214 PyObject *resultobj;
35215 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35216 size_t arg2 ;
35217 bool result;
35218 PyObject * obj0 = 0 ;
35219 PyObject * obj1 = 0 ;
35220 char *kwnames[] = {
35221 (char *) "self",(char *) "pos", NULL
35222 };
35223
35224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35226 if (SWIG_arg_fail(1)) SWIG_fail;
35227 {
35228 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35229 if (SWIG_arg_fail(2)) SWIG_fail;
35230 }
35231 {
35232 PyThreadState* __tstate = wxPyBeginAllowThreads();
35233 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35234
35235 wxPyEndAllowThreads(__tstate);
35236 if (PyErr_Occurred()) SWIG_fail;
35237 }
35238 {
35239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35240 }
35241 return resultobj;
35242 fail:
35243 return NULL;
35244 }
35245
35246
35247 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35248 PyObject *resultobj;
35249 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35250 size_t arg2 ;
35251 wxString *arg3 = 0 ;
35252 bool temp3 = false ;
35253 PyObject * obj0 = 0 ;
35254 PyObject * obj1 = 0 ;
35255 PyObject * obj2 = 0 ;
35256 char *kwnames[] = {
35257 (char *) "self",(char *) "pos",(char *) "label", NULL
35258 };
35259
35260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35262 if (SWIG_arg_fail(1)) SWIG_fail;
35263 {
35264 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35265 if (SWIG_arg_fail(2)) SWIG_fail;
35266 }
35267 {
35268 arg3 = wxString_in_helper(obj2);
35269 if (arg3 == NULL) SWIG_fail;
35270 temp3 = true;
35271 }
35272 {
35273 PyThreadState* __tstate = wxPyBeginAllowThreads();
35274 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35275
35276 wxPyEndAllowThreads(__tstate);
35277 if (PyErr_Occurred()) SWIG_fail;
35278 }
35279 Py_INCREF(Py_None); resultobj = Py_None;
35280 {
35281 if (temp3)
35282 delete arg3;
35283 }
35284 return resultobj;
35285 fail:
35286 {
35287 if (temp3)
35288 delete arg3;
35289 }
35290 return NULL;
35291 }
35292
35293
35294 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35295 PyObject *resultobj;
35296 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35297 size_t arg2 ;
35298 wxString result;
35299 PyObject * obj0 = 0 ;
35300 PyObject * obj1 = 0 ;
35301 char *kwnames[] = {
35302 (char *) "self",(char *) "pos", NULL
35303 };
35304
35305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35307 if (SWIG_arg_fail(1)) SWIG_fail;
35308 {
35309 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35310 if (SWIG_arg_fail(2)) SWIG_fail;
35311 }
35312 {
35313 PyThreadState* __tstate = wxPyBeginAllowThreads();
35314 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35315
35316 wxPyEndAllowThreads(__tstate);
35317 if (PyErr_Occurred()) SWIG_fail;
35318 }
35319 {
35320 #if wxUSE_UNICODE
35321 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35322 #else
35323 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35324 #endif
35325 }
35326 return resultobj;
35327 fail:
35328 return NULL;
35329 }
35330
35331
35332 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35333 PyObject *resultobj;
35334 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35335 wxString *arg2 = 0 ;
35336 wxString *arg3 = 0 ;
35337 int result;
35338 bool temp2 = false ;
35339 bool temp3 = false ;
35340 PyObject * obj0 = 0 ;
35341 PyObject * obj1 = 0 ;
35342 PyObject * obj2 = 0 ;
35343 char *kwnames[] = {
35344 (char *) "self",(char *) "menu",(char *) "item", NULL
35345 };
35346
35347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35349 if (SWIG_arg_fail(1)) SWIG_fail;
35350 {
35351 arg2 = wxString_in_helper(obj1);
35352 if (arg2 == NULL) SWIG_fail;
35353 temp2 = true;
35354 }
35355 {
35356 arg3 = wxString_in_helper(obj2);
35357 if (arg3 == NULL) SWIG_fail;
35358 temp3 = true;
35359 }
35360 {
35361 PyThreadState* __tstate = wxPyBeginAllowThreads();
35362 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35363
35364 wxPyEndAllowThreads(__tstate);
35365 if (PyErr_Occurred()) SWIG_fail;
35366 }
35367 {
35368 resultobj = SWIG_From_int((int)(result));
35369 }
35370 {
35371 if (temp2)
35372 delete arg2;
35373 }
35374 {
35375 if (temp3)
35376 delete arg3;
35377 }
35378 return resultobj;
35379 fail:
35380 {
35381 if (temp2)
35382 delete arg2;
35383 }
35384 {
35385 if (temp3)
35386 delete arg3;
35387 }
35388 return NULL;
35389 }
35390
35391
35392 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35393 PyObject *resultobj;
35394 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35395 int arg2 ;
35396 wxMenuItem *result;
35397 PyObject * obj0 = 0 ;
35398 PyObject * obj1 = 0 ;
35399 char *kwnames[] = {
35400 (char *) "self",(char *) "id", NULL
35401 };
35402
35403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35405 if (SWIG_arg_fail(1)) SWIG_fail;
35406 {
35407 arg2 = (int)(SWIG_As_int(obj1));
35408 if (SWIG_arg_fail(2)) SWIG_fail;
35409 }
35410 {
35411 PyThreadState* __tstate = wxPyBeginAllowThreads();
35412 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35413
35414 wxPyEndAllowThreads(__tstate);
35415 if (PyErr_Occurred()) SWIG_fail;
35416 }
35417 {
35418 resultobj = wxPyMake_wxObject(result, 0);
35419 }
35420 return resultobj;
35421 fail:
35422 return NULL;
35423 }
35424
35425
35426 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35427 PyObject *resultobj;
35428 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35429 wxString *arg2 = 0 ;
35430 int result;
35431 bool temp2 = false ;
35432 PyObject * obj0 = 0 ;
35433 PyObject * obj1 = 0 ;
35434 char *kwnames[] = {
35435 (char *) "self",(char *) "title", NULL
35436 };
35437
35438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35440 if (SWIG_arg_fail(1)) SWIG_fail;
35441 {
35442 arg2 = wxString_in_helper(obj1);
35443 if (arg2 == NULL) SWIG_fail;
35444 temp2 = true;
35445 }
35446 {
35447 PyThreadState* __tstate = wxPyBeginAllowThreads();
35448 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35449
35450 wxPyEndAllowThreads(__tstate);
35451 if (PyErr_Occurred()) SWIG_fail;
35452 }
35453 {
35454 resultobj = SWIG_From_int((int)(result));
35455 }
35456 {
35457 if (temp2)
35458 delete arg2;
35459 }
35460 return resultobj;
35461 fail:
35462 {
35463 if (temp2)
35464 delete arg2;
35465 }
35466 return NULL;
35467 }
35468
35469
35470 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35471 PyObject *resultobj;
35472 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35473 int arg2 ;
35474 bool arg3 ;
35475 PyObject * obj0 = 0 ;
35476 PyObject * obj1 = 0 ;
35477 PyObject * obj2 = 0 ;
35478 char *kwnames[] = {
35479 (char *) "self",(char *) "id",(char *) "enable", NULL
35480 };
35481
35482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35484 if (SWIG_arg_fail(1)) SWIG_fail;
35485 {
35486 arg2 = (int)(SWIG_As_int(obj1));
35487 if (SWIG_arg_fail(2)) SWIG_fail;
35488 }
35489 {
35490 arg3 = (bool)(SWIG_As_bool(obj2));
35491 if (SWIG_arg_fail(3)) SWIG_fail;
35492 }
35493 {
35494 PyThreadState* __tstate = wxPyBeginAllowThreads();
35495 (arg1)->Enable(arg2,arg3);
35496
35497 wxPyEndAllowThreads(__tstate);
35498 if (PyErr_Occurred()) SWIG_fail;
35499 }
35500 Py_INCREF(Py_None); resultobj = Py_None;
35501 return resultobj;
35502 fail:
35503 return NULL;
35504 }
35505
35506
35507 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35508 PyObject *resultobj;
35509 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35510 int arg2 ;
35511 bool arg3 ;
35512 PyObject * obj0 = 0 ;
35513 PyObject * obj1 = 0 ;
35514 PyObject * obj2 = 0 ;
35515 char *kwnames[] = {
35516 (char *) "self",(char *) "id",(char *) "check", NULL
35517 };
35518
35519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35521 if (SWIG_arg_fail(1)) SWIG_fail;
35522 {
35523 arg2 = (int)(SWIG_As_int(obj1));
35524 if (SWIG_arg_fail(2)) SWIG_fail;
35525 }
35526 {
35527 arg3 = (bool)(SWIG_As_bool(obj2));
35528 if (SWIG_arg_fail(3)) SWIG_fail;
35529 }
35530 {
35531 PyThreadState* __tstate = wxPyBeginAllowThreads();
35532 (arg1)->Check(arg2,arg3);
35533
35534 wxPyEndAllowThreads(__tstate);
35535 if (PyErr_Occurred()) SWIG_fail;
35536 }
35537 Py_INCREF(Py_None); resultobj = Py_None;
35538 return resultobj;
35539 fail:
35540 return NULL;
35541 }
35542
35543
35544 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35545 PyObject *resultobj;
35546 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35547 int arg2 ;
35548 bool result;
35549 PyObject * obj0 = 0 ;
35550 PyObject * obj1 = 0 ;
35551 char *kwnames[] = {
35552 (char *) "self",(char *) "id", NULL
35553 };
35554
35555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35557 if (SWIG_arg_fail(1)) SWIG_fail;
35558 {
35559 arg2 = (int)(SWIG_As_int(obj1));
35560 if (SWIG_arg_fail(2)) SWIG_fail;
35561 }
35562 {
35563 PyThreadState* __tstate = wxPyBeginAllowThreads();
35564 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35565
35566 wxPyEndAllowThreads(__tstate);
35567 if (PyErr_Occurred()) SWIG_fail;
35568 }
35569 {
35570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35571 }
35572 return resultobj;
35573 fail:
35574 return NULL;
35575 }
35576
35577
35578 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35579 PyObject *resultobj;
35580 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35581 int arg2 ;
35582 bool result;
35583 PyObject * obj0 = 0 ;
35584 PyObject * obj1 = 0 ;
35585 char *kwnames[] = {
35586 (char *) "self",(char *) "id", NULL
35587 };
35588
35589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35591 if (SWIG_arg_fail(1)) SWIG_fail;
35592 {
35593 arg2 = (int)(SWIG_As_int(obj1));
35594 if (SWIG_arg_fail(2)) SWIG_fail;
35595 }
35596 {
35597 PyThreadState* __tstate = wxPyBeginAllowThreads();
35598 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35599
35600 wxPyEndAllowThreads(__tstate);
35601 if (PyErr_Occurred()) SWIG_fail;
35602 }
35603 {
35604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35605 }
35606 return resultobj;
35607 fail:
35608 return NULL;
35609 }
35610
35611
35612 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35613 PyObject *resultobj;
35614 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35615 int arg2 ;
35616 wxString *arg3 = 0 ;
35617 bool temp3 = false ;
35618 PyObject * obj0 = 0 ;
35619 PyObject * obj1 = 0 ;
35620 PyObject * obj2 = 0 ;
35621 char *kwnames[] = {
35622 (char *) "self",(char *) "id",(char *) "label", NULL
35623 };
35624
35625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35627 if (SWIG_arg_fail(1)) SWIG_fail;
35628 {
35629 arg2 = (int)(SWIG_As_int(obj1));
35630 if (SWIG_arg_fail(2)) SWIG_fail;
35631 }
35632 {
35633 arg3 = wxString_in_helper(obj2);
35634 if (arg3 == NULL) SWIG_fail;
35635 temp3 = true;
35636 }
35637 {
35638 PyThreadState* __tstate = wxPyBeginAllowThreads();
35639 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35640
35641 wxPyEndAllowThreads(__tstate);
35642 if (PyErr_Occurred()) SWIG_fail;
35643 }
35644 Py_INCREF(Py_None); resultobj = Py_None;
35645 {
35646 if (temp3)
35647 delete arg3;
35648 }
35649 return resultobj;
35650 fail:
35651 {
35652 if (temp3)
35653 delete arg3;
35654 }
35655 return NULL;
35656 }
35657
35658
35659 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35660 PyObject *resultobj;
35661 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35662 int arg2 ;
35663 wxString result;
35664 PyObject * obj0 = 0 ;
35665 PyObject * obj1 = 0 ;
35666 char *kwnames[] = {
35667 (char *) "self",(char *) "id", NULL
35668 };
35669
35670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35672 if (SWIG_arg_fail(1)) SWIG_fail;
35673 {
35674 arg2 = (int)(SWIG_As_int(obj1));
35675 if (SWIG_arg_fail(2)) SWIG_fail;
35676 }
35677 {
35678 PyThreadState* __tstate = wxPyBeginAllowThreads();
35679 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35680
35681 wxPyEndAllowThreads(__tstate);
35682 if (PyErr_Occurred()) SWIG_fail;
35683 }
35684 {
35685 #if wxUSE_UNICODE
35686 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35687 #else
35688 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35689 #endif
35690 }
35691 return resultobj;
35692 fail:
35693 return NULL;
35694 }
35695
35696
35697 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35698 PyObject *resultobj;
35699 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35700 int arg2 ;
35701 wxString *arg3 = 0 ;
35702 bool temp3 = false ;
35703 PyObject * obj0 = 0 ;
35704 PyObject * obj1 = 0 ;
35705 PyObject * obj2 = 0 ;
35706 char *kwnames[] = {
35707 (char *) "self",(char *) "id",(char *) "helpString", NULL
35708 };
35709
35710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35712 if (SWIG_arg_fail(1)) SWIG_fail;
35713 {
35714 arg2 = (int)(SWIG_As_int(obj1));
35715 if (SWIG_arg_fail(2)) SWIG_fail;
35716 }
35717 {
35718 arg3 = wxString_in_helper(obj2);
35719 if (arg3 == NULL) SWIG_fail;
35720 temp3 = true;
35721 }
35722 {
35723 PyThreadState* __tstate = wxPyBeginAllowThreads();
35724 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35725
35726 wxPyEndAllowThreads(__tstate);
35727 if (PyErr_Occurred()) SWIG_fail;
35728 }
35729 Py_INCREF(Py_None); resultobj = Py_None;
35730 {
35731 if (temp3)
35732 delete arg3;
35733 }
35734 return resultobj;
35735 fail:
35736 {
35737 if (temp3)
35738 delete arg3;
35739 }
35740 return NULL;
35741 }
35742
35743
35744 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35745 PyObject *resultobj;
35746 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35747 int arg2 ;
35748 wxString result;
35749 PyObject * obj0 = 0 ;
35750 PyObject * obj1 = 0 ;
35751 char *kwnames[] = {
35752 (char *) "self",(char *) "id", NULL
35753 };
35754
35755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35757 if (SWIG_arg_fail(1)) SWIG_fail;
35758 {
35759 arg2 = (int)(SWIG_As_int(obj1));
35760 if (SWIG_arg_fail(2)) SWIG_fail;
35761 }
35762 {
35763 PyThreadState* __tstate = wxPyBeginAllowThreads();
35764 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35765
35766 wxPyEndAllowThreads(__tstate);
35767 if (PyErr_Occurred()) SWIG_fail;
35768 }
35769 {
35770 #if wxUSE_UNICODE
35771 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35772 #else
35773 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35774 #endif
35775 }
35776 return resultobj;
35777 fail:
35778 return NULL;
35779 }
35780
35781
35782 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35783 PyObject *resultobj;
35784 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35785 wxFrame *result;
35786 PyObject * obj0 = 0 ;
35787 char *kwnames[] = {
35788 (char *) "self", NULL
35789 };
35790
35791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35793 if (SWIG_arg_fail(1)) SWIG_fail;
35794 {
35795 PyThreadState* __tstate = wxPyBeginAllowThreads();
35796 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35797
35798 wxPyEndAllowThreads(__tstate);
35799 if (PyErr_Occurred()) SWIG_fail;
35800 }
35801 {
35802 resultobj = wxPyMake_wxObject(result, 0);
35803 }
35804 return resultobj;
35805 fail:
35806 return NULL;
35807 }
35808
35809
35810 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35811 PyObject *resultobj;
35812 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35813 bool result;
35814 PyObject * obj0 = 0 ;
35815 char *kwnames[] = {
35816 (char *) "self", NULL
35817 };
35818
35819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35821 if (SWIG_arg_fail(1)) SWIG_fail;
35822 {
35823 PyThreadState* __tstate = wxPyBeginAllowThreads();
35824 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35825
35826 wxPyEndAllowThreads(__tstate);
35827 if (PyErr_Occurred()) SWIG_fail;
35828 }
35829 {
35830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35831 }
35832 return resultobj;
35833 fail:
35834 return NULL;
35835 }
35836
35837
35838 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35839 PyObject *resultobj;
35840 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35841 wxFrame *arg2 = (wxFrame *) 0 ;
35842 PyObject * obj0 = 0 ;
35843 PyObject * obj1 = 0 ;
35844 char *kwnames[] = {
35845 (char *) "self",(char *) "frame", NULL
35846 };
35847
35848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35850 if (SWIG_arg_fail(1)) SWIG_fail;
35851 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35852 if (SWIG_arg_fail(2)) SWIG_fail;
35853 {
35854 PyThreadState* __tstate = wxPyBeginAllowThreads();
35855 (arg1)->Attach(arg2);
35856
35857 wxPyEndAllowThreads(__tstate);
35858 if (PyErr_Occurred()) SWIG_fail;
35859 }
35860 Py_INCREF(Py_None); resultobj = Py_None;
35861 return resultobj;
35862 fail:
35863 return NULL;
35864 }
35865
35866
35867 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35868 PyObject *resultobj;
35869 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35870 PyObject * obj0 = 0 ;
35871 char *kwnames[] = {
35872 (char *) "self", NULL
35873 };
35874
35875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35877 if (SWIG_arg_fail(1)) SWIG_fail;
35878 {
35879 PyThreadState* __tstate = wxPyBeginAllowThreads();
35880 (arg1)->Detach();
35881
35882 wxPyEndAllowThreads(__tstate);
35883 if (PyErr_Occurred()) SWIG_fail;
35884 }
35885 Py_INCREF(Py_None); resultobj = Py_None;
35886 return resultobj;
35887 fail:
35888 return NULL;
35889 }
35890
35891
35892 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35893 PyObject *obj;
35894 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35895 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35896 Py_INCREF(obj);
35897 return Py_BuildValue((char *)"");
35898 }
35899 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35900 PyObject *resultobj;
35901 wxMenu *arg1 = (wxMenu *) NULL ;
35902 int arg2 = (int) wxID_ANY ;
35903 wxString const &arg3_defvalue = wxPyEmptyString ;
35904 wxString *arg3 = (wxString *) &arg3_defvalue ;
35905 wxString const &arg4_defvalue = wxPyEmptyString ;
35906 wxString *arg4 = (wxString *) &arg4_defvalue ;
35907 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35908 wxMenu *arg6 = (wxMenu *) NULL ;
35909 wxMenuItem *result;
35910 bool temp3 = false ;
35911 bool temp4 = false ;
35912 PyObject * obj0 = 0 ;
35913 PyObject * obj1 = 0 ;
35914 PyObject * obj2 = 0 ;
35915 PyObject * obj3 = 0 ;
35916 PyObject * obj4 = 0 ;
35917 PyObject * obj5 = 0 ;
35918 char *kwnames[] = {
35919 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35920 };
35921
35922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35923 if (obj0) {
35924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35925 if (SWIG_arg_fail(1)) SWIG_fail;
35926 }
35927 if (obj1) {
35928 {
35929 arg2 = (int)(SWIG_As_int(obj1));
35930 if (SWIG_arg_fail(2)) SWIG_fail;
35931 }
35932 }
35933 if (obj2) {
35934 {
35935 arg3 = wxString_in_helper(obj2);
35936 if (arg3 == NULL) SWIG_fail;
35937 temp3 = true;
35938 }
35939 }
35940 if (obj3) {
35941 {
35942 arg4 = wxString_in_helper(obj3);
35943 if (arg4 == NULL) SWIG_fail;
35944 temp4 = true;
35945 }
35946 }
35947 if (obj4) {
35948 {
35949 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35950 if (SWIG_arg_fail(5)) SWIG_fail;
35951 }
35952 }
35953 if (obj5) {
35954 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35955 if (SWIG_arg_fail(6)) SWIG_fail;
35956 }
35957 {
35958 PyThreadState* __tstate = wxPyBeginAllowThreads();
35959 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35960
35961 wxPyEndAllowThreads(__tstate);
35962 if (PyErr_Occurred()) SWIG_fail;
35963 }
35964 {
35965 resultobj = wxPyMake_wxObject(result, 1);
35966 }
35967 {
35968 if (temp3)
35969 delete arg3;
35970 }
35971 {
35972 if (temp4)
35973 delete arg4;
35974 }
35975 return resultobj;
35976 fail:
35977 {
35978 if (temp3)
35979 delete arg3;
35980 }
35981 {
35982 if (temp4)
35983 delete arg4;
35984 }
35985 return NULL;
35986 }
35987
35988
35989 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35990 PyObject *resultobj;
35991 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35992 wxMenu *result;
35993 PyObject * obj0 = 0 ;
35994 char *kwnames[] = {
35995 (char *) "self", NULL
35996 };
35997
35998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36000 if (SWIG_arg_fail(1)) SWIG_fail;
36001 {
36002 PyThreadState* __tstate = wxPyBeginAllowThreads();
36003 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36004
36005 wxPyEndAllowThreads(__tstate);
36006 if (PyErr_Occurred()) SWIG_fail;
36007 }
36008 {
36009 resultobj = wxPyMake_wxObject(result, 0);
36010 }
36011 return resultobj;
36012 fail:
36013 return NULL;
36014 }
36015
36016
36017 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36018 PyObject *resultobj;
36019 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36020 wxMenu *arg2 = (wxMenu *) 0 ;
36021 PyObject * obj0 = 0 ;
36022 PyObject * obj1 = 0 ;
36023 char *kwnames[] = {
36024 (char *) "self",(char *) "menu", NULL
36025 };
36026
36027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36029 if (SWIG_arg_fail(1)) SWIG_fail;
36030 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36031 if (SWIG_arg_fail(2)) SWIG_fail;
36032 {
36033 PyThreadState* __tstate = wxPyBeginAllowThreads();
36034 (arg1)->SetMenu(arg2);
36035
36036 wxPyEndAllowThreads(__tstate);
36037 if (PyErr_Occurred()) SWIG_fail;
36038 }
36039 Py_INCREF(Py_None); resultobj = Py_None;
36040 return resultobj;
36041 fail:
36042 return NULL;
36043 }
36044
36045
36046 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36047 PyObject *resultobj;
36048 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36049 int arg2 ;
36050 PyObject * obj0 = 0 ;
36051 PyObject * obj1 = 0 ;
36052 char *kwnames[] = {
36053 (char *) "self",(char *) "id", NULL
36054 };
36055
36056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36058 if (SWIG_arg_fail(1)) SWIG_fail;
36059 {
36060 arg2 = (int)(SWIG_As_int(obj1));
36061 if (SWIG_arg_fail(2)) SWIG_fail;
36062 }
36063 {
36064 PyThreadState* __tstate = wxPyBeginAllowThreads();
36065 (arg1)->SetId(arg2);
36066
36067 wxPyEndAllowThreads(__tstate);
36068 if (PyErr_Occurred()) SWIG_fail;
36069 }
36070 Py_INCREF(Py_None); resultobj = Py_None;
36071 return resultobj;
36072 fail:
36073 return NULL;
36074 }
36075
36076
36077 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36078 PyObject *resultobj;
36079 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36080 int result;
36081 PyObject * obj0 = 0 ;
36082 char *kwnames[] = {
36083 (char *) "self", NULL
36084 };
36085
36086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36088 if (SWIG_arg_fail(1)) SWIG_fail;
36089 {
36090 PyThreadState* __tstate = wxPyBeginAllowThreads();
36091 result = (int)((wxMenuItem const *)arg1)->GetId();
36092
36093 wxPyEndAllowThreads(__tstate);
36094 if (PyErr_Occurred()) SWIG_fail;
36095 }
36096 {
36097 resultobj = SWIG_From_int((int)(result));
36098 }
36099 return resultobj;
36100 fail:
36101 return NULL;
36102 }
36103
36104
36105 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36106 PyObject *resultobj;
36107 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36108 bool result;
36109 PyObject * obj0 = 0 ;
36110 char *kwnames[] = {
36111 (char *) "self", NULL
36112 };
36113
36114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36116 if (SWIG_arg_fail(1)) SWIG_fail;
36117 {
36118 PyThreadState* __tstate = wxPyBeginAllowThreads();
36119 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36120
36121 wxPyEndAllowThreads(__tstate);
36122 if (PyErr_Occurred()) SWIG_fail;
36123 }
36124 {
36125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36126 }
36127 return resultobj;
36128 fail:
36129 return NULL;
36130 }
36131
36132
36133 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36134 PyObject *resultobj;
36135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36136 wxString *arg2 = 0 ;
36137 bool temp2 = false ;
36138 PyObject * obj0 = 0 ;
36139 PyObject * obj1 = 0 ;
36140 char *kwnames[] = {
36141 (char *) "self",(char *) "str", NULL
36142 };
36143
36144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36146 if (SWIG_arg_fail(1)) SWIG_fail;
36147 {
36148 arg2 = wxString_in_helper(obj1);
36149 if (arg2 == NULL) SWIG_fail;
36150 temp2 = true;
36151 }
36152 {
36153 PyThreadState* __tstate = wxPyBeginAllowThreads();
36154 (arg1)->SetText((wxString const &)*arg2);
36155
36156 wxPyEndAllowThreads(__tstate);
36157 if (PyErr_Occurred()) SWIG_fail;
36158 }
36159 Py_INCREF(Py_None); resultobj = Py_None;
36160 {
36161 if (temp2)
36162 delete arg2;
36163 }
36164 return resultobj;
36165 fail:
36166 {
36167 if (temp2)
36168 delete arg2;
36169 }
36170 return NULL;
36171 }
36172
36173
36174 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36175 PyObject *resultobj;
36176 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36177 wxString result;
36178 PyObject * obj0 = 0 ;
36179 char *kwnames[] = {
36180 (char *) "self", NULL
36181 };
36182
36183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36185 if (SWIG_arg_fail(1)) SWIG_fail;
36186 {
36187 PyThreadState* __tstate = wxPyBeginAllowThreads();
36188 result = ((wxMenuItem const *)arg1)->GetLabel();
36189
36190 wxPyEndAllowThreads(__tstate);
36191 if (PyErr_Occurred()) SWIG_fail;
36192 }
36193 {
36194 #if wxUSE_UNICODE
36195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36196 #else
36197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36198 #endif
36199 }
36200 return resultobj;
36201 fail:
36202 return NULL;
36203 }
36204
36205
36206 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36207 PyObject *resultobj;
36208 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36209 wxString *result;
36210 PyObject * obj0 = 0 ;
36211 char *kwnames[] = {
36212 (char *) "self", NULL
36213 };
36214
36215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36217 if (SWIG_arg_fail(1)) SWIG_fail;
36218 {
36219 PyThreadState* __tstate = wxPyBeginAllowThreads();
36220 {
36221 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36222 result = (wxString *) &_result_ref;
36223 }
36224
36225 wxPyEndAllowThreads(__tstate);
36226 if (PyErr_Occurred()) SWIG_fail;
36227 }
36228 {
36229 #if wxUSE_UNICODE
36230 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36231 #else
36232 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36233 #endif
36234 }
36235 return resultobj;
36236 fail:
36237 return NULL;
36238 }
36239
36240
36241 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36242 PyObject *resultobj;
36243 wxString *arg1 = 0 ;
36244 wxString result;
36245 bool temp1 = false ;
36246 PyObject * obj0 = 0 ;
36247 char *kwnames[] = {
36248 (char *) "text", NULL
36249 };
36250
36251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36252 {
36253 arg1 = wxString_in_helper(obj0);
36254 if (arg1 == NULL) SWIG_fail;
36255 temp1 = true;
36256 }
36257 {
36258 PyThreadState* __tstate = wxPyBeginAllowThreads();
36259 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36260
36261 wxPyEndAllowThreads(__tstate);
36262 if (PyErr_Occurred()) SWIG_fail;
36263 }
36264 {
36265 #if wxUSE_UNICODE
36266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36267 #else
36268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36269 #endif
36270 }
36271 {
36272 if (temp1)
36273 delete arg1;
36274 }
36275 return resultobj;
36276 fail:
36277 {
36278 if (temp1)
36279 delete arg1;
36280 }
36281 return NULL;
36282 }
36283
36284
36285 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36286 PyObject *resultobj;
36287 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36288 wxItemKind result;
36289 PyObject * obj0 = 0 ;
36290 char *kwnames[] = {
36291 (char *) "self", NULL
36292 };
36293
36294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36296 if (SWIG_arg_fail(1)) SWIG_fail;
36297 {
36298 PyThreadState* __tstate = wxPyBeginAllowThreads();
36299 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36300
36301 wxPyEndAllowThreads(__tstate);
36302 if (PyErr_Occurred()) SWIG_fail;
36303 }
36304 resultobj = SWIG_From_int((result));
36305 return resultobj;
36306 fail:
36307 return NULL;
36308 }
36309
36310
36311 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36312 PyObject *resultobj;
36313 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36314 wxItemKind arg2 ;
36315 PyObject * obj0 = 0 ;
36316 PyObject * obj1 = 0 ;
36317 char *kwnames[] = {
36318 (char *) "self",(char *) "kind", NULL
36319 };
36320
36321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36323 if (SWIG_arg_fail(1)) SWIG_fail;
36324 {
36325 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36326 if (SWIG_arg_fail(2)) SWIG_fail;
36327 }
36328 {
36329 PyThreadState* __tstate = wxPyBeginAllowThreads();
36330 (arg1)->SetKind((wxItemKind )arg2);
36331
36332 wxPyEndAllowThreads(__tstate);
36333 if (PyErr_Occurred()) SWIG_fail;
36334 }
36335 Py_INCREF(Py_None); resultobj = Py_None;
36336 return resultobj;
36337 fail:
36338 return NULL;
36339 }
36340
36341
36342 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36343 PyObject *resultobj;
36344 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36345 bool arg2 ;
36346 PyObject * obj0 = 0 ;
36347 PyObject * obj1 = 0 ;
36348 char *kwnames[] = {
36349 (char *) "self",(char *) "checkable", NULL
36350 };
36351
36352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36354 if (SWIG_arg_fail(1)) SWIG_fail;
36355 {
36356 arg2 = (bool)(SWIG_As_bool(obj1));
36357 if (SWIG_arg_fail(2)) SWIG_fail;
36358 }
36359 {
36360 PyThreadState* __tstate = wxPyBeginAllowThreads();
36361 (arg1)->SetCheckable(arg2);
36362
36363 wxPyEndAllowThreads(__tstate);
36364 if (PyErr_Occurred()) SWIG_fail;
36365 }
36366 Py_INCREF(Py_None); resultobj = Py_None;
36367 return resultobj;
36368 fail:
36369 return NULL;
36370 }
36371
36372
36373 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36374 PyObject *resultobj;
36375 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36376 bool result;
36377 PyObject * obj0 = 0 ;
36378 char *kwnames[] = {
36379 (char *) "self", NULL
36380 };
36381
36382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36384 if (SWIG_arg_fail(1)) SWIG_fail;
36385 {
36386 PyThreadState* __tstate = wxPyBeginAllowThreads();
36387 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36388
36389 wxPyEndAllowThreads(__tstate);
36390 if (PyErr_Occurred()) SWIG_fail;
36391 }
36392 {
36393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36394 }
36395 return resultobj;
36396 fail:
36397 return NULL;
36398 }
36399
36400
36401 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36402 PyObject *resultobj;
36403 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36404 bool result;
36405 PyObject * obj0 = 0 ;
36406 char *kwnames[] = {
36407 (char *) "self", NULL
36408 };
36409
36410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36412 if (SWIG_arg_fail(1)) SWIG_fail;
36413 {
36414 PyThreadState* __tstate = wxPyBeginAllowThreads();
36415 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36416
36417 wxPyEndAllowThreads(__tstate);
36418 if (PyErr_Occurred()) SWIG_fail;
36419 }
36420 {
36421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36422 }
36423 return resultobj;
36424 fail:
36425 return NULL;
36426 }
36427
36428
36429 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36430 PyObject *resultobj;
36431 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36432 wxMenu *arg2 = (wxMenu *) 0 ;
36433 PyObject * obj0 = 0 ;
36434 PyObject * obj1 = 0 ;
36435 char *kwnames[] = {
36436 (char *) "self",(char *) "menu", NULL
36437 };
36438
36439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36441 if (SWIG_arg_fail(1)) SWIG_fail;
36442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36443 if (SWIG_arg_fail(2)) SWIG_fail;
36444 {
36445 PyThreadState* __tstate = wxPyBeginAllowThreads();
36446 (arg1)->SetSubMenu(arg2);
36447
36448 wxPyEndAllowThreads(__tstate);
36449 if (PyErr_Occurred()) SWIG_fail;
36450 }
36451 Py_INCREF(Py_None); resultobj = Py_None;
36452 return resultobj;
36453 fail:
36454 return NULL;
36455 }
36456
36457
36458 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36459 PyObject *resultobj;
36460 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36461 wxMenu *result;
36462 PyObject * obj0 = 0 ;
36463 char *kwnames[] = {
36464 (char *) "self", NULL
36465 };
36466
36467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36469 if (SWIG_arg_fail(1)) SWIG_fail;
36470 {
36471 PyThreadState* __tstate = wxPyBeginAllowThreads();
36472 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36473
36474 wxPyEndAllowThreads(__tstate);
36475 if (PyErr_Occurred()) SWIG_fail;
36476 }
36477 {
36478 resultobj = wxPyMake_wxObject(result, 0);
36479 }
36480 return resultobj;
36481 fail:
36482 return NULL;
36483 }
36484
36485
36486 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36487 PyObject *resultobj;
36488 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36489 bool arg2 = (bool) true ;
36490 PyObject * obj0 = 0 ;
36491 PyObject * obj1 = 0 ;
36492 char *kwnames[] = {
36493 (char *) "self",(char *) "enable", NULL
36494 };
36495
36496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36498 if (SWIG_arg_fail(1)) SWIG_fail;
36499 if (obj1) {
36500 {
36501 arg2 = (bool)(SWIG_As_bool(obj1));
36502 if (SWIG_arg_fail(2)) SWIG_fail;
36503 }
36504 }
36505 {
36506 PyThreadState* __tstate = wxPyBeginAllowThreads();
36507 (arg1)->Enable(arg2);
36508
36509 wxPyEndAllowThreads(__tstate);
36510 if (PyErr_Occurred()) SWIG_fail;
36511 }
36512 Py_INCREF(Py_None); resultobj = Py_None;
36513 return resultobj;
36514 fail:
36515 return NULL;
36516 }
36517
36518
36519 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36520 PyObject *resultobj;
36521 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36522 bool result;
36523 PyObject * obj0 = 0 ;
36524 char *kwnames[] = {
36525 (char *) "self", NULL
36526 };
36527
36528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36530 if (SWIG_arg_fail(1)) SWIG_fail;
36531 {
36532 PyThreadState* __tstate = wxPyBeginAllowThreads();
36533 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36534
36535 wxPyEndAllowThreads(__tstate);
36536 if (PyErr_Occurred()) SWIG_fail;
36537 }
36538 {
36539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36540 }
36541 return resultobj;
36542 fail:
36543 return NULL;
36544 }
36545
36546
36547 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36548 PyObject *resultobj;
36549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36550 bool arg2 = (bool) true ;
36551 PyObject * obj0 = 0 ;
36552 PyObject * obj1 = 0 ;
36553 char *kwnames[] = {
36554 (char *) "self",(char *) "check", NULL
36555 };
36556
36557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36559 if (SWIG_arg_fail(1)) SWIG_fail;
36560 if (obj1) {
36561 {
36562 arg2 = (bool)(SWIG_As_bool(obj1));
36563 if (SWIG_arg_fail(2)) SWIG_fail;
36564 }
36565 }
36566 {
36567 PyThreadState* __tstate = wxPyBeginAllowThreads();
36568 (arg1)->Check(arg2);
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_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36581 PyObject *resultobj;
36582 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36583 bool result;
36584 PyObject * obj0 = 0 ;
36585 char *kwnames[] = {
36586 (char *) "self", NULL
36587 };
36588
36589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36591 if (SWIG_arg_fail(1)) SWIG_fail;
36592 {
36593 PyThreadState* __tstate = wxPyBeginAllowThreads();
36594 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36595
36596 wxPyEndAllowThreads(__tstate);
36597 if (PyErr_Occurred()) SWIG_fail;
36598 }
36599 {
36600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36601 }
36602 return resultobj;
36603 fail:
36604 return NULL;
36605 }
36606
36607
36608 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36609 PyObject *resultobj;
36610 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36611 PyObject * obj0 = 0 ;
36612 char *kwnames[] = {
36613 (char *) "self", NULL
36614 };
36615
36616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36618 if (SWIG_arg_fail(1)) SWIG_fail;
36619 {
36620 PyThreadState* __tstate = wxPyBeginAllowThreads();
36621 (arg1)->Toggle();
36622
36623 wxPyEndAllowThreads(__tstate);
36624 if (PyErr_Occurred()) SWIG_fail;
36625 }
36626 Py_INCREF(Py_None); resultobj = Py_None;
36627 return resultobj;
36628 fail:
36629 return NULL;
36630 }
36631
36632
36633 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36634 PyObject *resultobj;
36635 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36636 wxString *arg2 = 0 ;
36637 bool temp2 = false ;
36638 PyObject * obj0 = 0 ;
36639 PyObject * obj1 = 0 ;
36640 char *kwnames[] = {
36641 (char *) "self",(char *) "str", NULL
36642 };
36643
36644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36646 if (SWIG_arg_fail(1)) SWIG_fail;
36647 {
36648 arg2 = wxString_in_helper(obj1);
36649 if (arg2 == NULL) SWIG_fail;
36650 temp2 = true;
36651 }
36652 {
36653 PyThreadState* __tstate = wxPyBeginAllowThreads();
36654 (arg1)->SetHelp((wxString const &)*arg2);
36655
36656 wxPyEndAllowThreads(__tstate);
36657 if (PyErr_Occurred()) SWIG_fail;
36658 }
36659 Py_INCREF(Py_None); resultobj = Py_None;
36660 {
36661 if (temp2)
36662 delete arg2;
36663 }
36664 return resultobj;
36665 fail:
36666 {
36667 if (temp2)
36668 delete arg2;
36669 }
36670 return NULL;
36671 }
36672
36673
36674 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36675 PyObject *resultobj;
36676 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36677 wxString *result;
36678 PyObject * obj0 = 0 ;
36679 char *kwnames[] = {
36680 (char *) "self", NULL
36681 };
36682
36683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36685 if (SWIG_arg_fail(1)) SWIG_fail;
36686 {
36687 PyThreadState* __tstate = wxPyBeginAllowThreads();
36688 {
36689 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36690 result = (wxString *) &_result_ref;
36691 }
36692
36693 wxPyEndAllowThreads(__tstate);
36694 if (PyErr_Occurred()) SWIG_fail;
36695 }
36696 {
36697 #if wxUSE_UNICODE
36698 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36699 #else
36700 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36701 #endif
36702 }
36703 return resultobj;
36704 fail:
36705 return NULL;
36706 }
36707
36708
36709 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36710 PyObject *resultobj;
36711 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36712 wxAcceleratorEntry *result;
36713 PyObject * obj0 = 0 ;
36714 char *kwnames[] = {
36715 (char *) "self", NULL
36716 };
36717
36718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36720 if (SWIG_arg_fail(1)) SWIG_fail;
36721 {
36722 PyThreadState* __tstate = wxPyBeginAllowThreads();
36723 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36724
36725 wxPyEndAllowThreads(__tstate);
36726 if (PyErr_Occurred()) SWIG_fail;
36727 }
36728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36729 return resultobj;
36730 fail:
36731 return NULL;
36732 }
36733
36734
36735 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36736 PyObject *resultobj;
36737 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36738 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36739 PyObject * obj0 = 0 ;
36740 PyObject * obj1 = 0 ;
36741 char *kwnames[] = {
36742 (char *) "self",(char *) "accel", NULL
36743 };
36744
36745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36747 if (SWIG_arg_fail(1)) SWIG_fail;
36748 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36749 if (SWIG_arg_fail(2)) SWIG_fail;
36750 {
36751 PyThreadState* __tstate = wxPyBeginAllowThreads();
36752 (arg1)->SetAccel(arg2);
36753
36754 wxPyEndAllowThreads(__tstate);
36755 if (PyErr_Occurred()) SWIG_fail;
36756 }
36757 Py_INCREF(Py_None); resultobj = Py_None;
36758 return resultobj;
36759 fail:
36760 return NULL;
36761 }
36762
36763
36764 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36765 PyObject *resultobj;
36766 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36767 wxFont *arg2 = 0 ;
36768 PyObject * obj0 = 0 ;
36769 PyObject * obj1 = 0 ;
36770 char *kwnames[] = {
36771 (char *) "self",(char *) "font", NULL
36772 };
36773
36774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36776 if (SWIG_arg_fail(1)) SWIG_fail;
36777 {
36778 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36779 if (SWIG_arg_fail(2)) SWIG_fail;
36780 if (arg2 == NULL) {
36781 SWIG_null_ref("wxFont");
36782 }
36783 if (SWIG_arg_fail(2)) SWIG_fail;
36784 }
36785 {
36786 PyThreadState* __tstate = wxPyBeginAllowThreads();
36787 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36788
36789 wxPyEndAllowThreads(__tstate);
36790 if (PyErr_Occurred()) SWIG_fail;
36791 }
36792 Py_INCREF(Py_None); resultobj = Py_None;
36793 return resultobj;
36794 fail:
36795 return NULL;
36796 }
36797
36798
36799 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36800 PyObject *resultobj;
36801 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36802 wxFont result;
36803 PyObject * obj0 = 0 ;
36804 char *kwnames[] = {
36805 (char *) "self", NULL
36806 };
36807
36808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36810 if (SWIG_arg_fail(1)) SWIG_fail;
36811 {
36812 PyThreadState* __tstate = wxPyBeginAllowThreads();
36813 result = wxMenuItem_GetFont(arg1);
36814
36815 wxPyEndAllowThreads(__tstate);
36816 if (PyErr_Occurred()) SWIG_fail;
36817 }
36818 {
36819 wxFont * resultptr;
36820 resultptr = new wxFont((wxFont &)(result));
36821 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36822 }
36823 return resultobj;
36824 fail:
36825 return NULL;
36826 }
36827
36828
36829 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36830 PyObject *resultobj;
36831 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36832 wxColour *arg2 = 0 ;
36833 wxColour temp2 ;
36834 PyObject * obj0 = 0 ;
36835 PyObject * obj1 = 0 ;
36836 char *kwnames[] = {
36837 (char *) "self",(char *) "colText", NULL
36838 };
36839
36840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36842 if (SWIG_arg_fail(1)) SWIG_fail;
36843 {
36844 arg2 = &temp2;
36845 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36846 }
36847 {
36848 PyThreadState* __tstate = wxPyBeginAllowThreads();
36849 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36850
36851 wxPyEndAllowThreads(__tstate);
36852 if (PyErr_Occurred()) SWIG_fail;
36853 }
36854 Py_INCREF(Py_None); resultobj = Py_None;
36855 return resultobj;
36856 fail:
36857 return NULL;
36858 }
36859
36860
36861 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36862 PyObject *resultobj;
36863 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36864 wxColour result;
36865 PyObject * obj0 = 0 ;
36866 char *kwnames[] = {
36867 (char *) "self", NULL
36868 };
36869
36870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36872 if (SWIG_arg_fail(1)) SWIG_fail;
36873 {
36874 PyThreadState* __tstate = wxPyBeginAllowThreads();
36875 result = wxMenuItem_GetTextColour(arg1);
36876
36877 wxPyEndAllowThreads(__tstate);
36878 if (PyErr_Occurred()) SWIG_fail;
36879 }
36880 {
36881 wxColour * resultptr;
36882 resultptr = new wxColour((wxColour &)(result));
36883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36884 }
36885 return resultobj;
36886 fail:
36887 return NULL;
36888 }
36889
36890
36891 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36892 PyObject *resultobj;
36893 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36894 wxColour *arg2 = 0 ;
36895 wxColour temp2 ;
36896 PyObject * obj0 = 0 ;
36897 PyObject * obj1 = 0 ;
36898 char *kwnames[] = {
36899 (char *) "self",(char *) "colBack", NULL
36900 };
36901
36902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36904 if (SWIG_arg_fail(1)) SWIG_fail;
36905 {
36906 arg2 = &temp2;
36907 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36908 }
36909 {
36910 PyThreadState* __tstate = wxPyBeginAllowThreads();
36911 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36912
36913 wxPyEndAllowThreads(__tstate);
36914 if (PyErr_Occurred()) SWIG_fail;
36915 }
36916 Py_INCREF(Py_None); resultobj = Py_None;
36917 return resultobj;
36918 fail:
36919 return NULL;
36920 }
36921
36922
36923 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36924 PyObject *resultobj;
36925 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36926 wxColour result;
36927 PyObject * obj0 = 0 ;
36928 char *kwnames[] = {
36929 (char *) "self", NULL
36930 };
36931
36932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36934 if (SWIG_arg_fail(1)) SWIG_fail;
36935 {
36936 PyThreadState* __tstate = wxPyBeginAllowThreads();
36937 result = wxMenuItem_GetBackgroundColour(arg1);
36938
36939 wxPyEndAllowThreads(__tstate);
36940 if (PyErr_Occurred()) SWIG_fail;
36941 }
36942 {
36943 wxColour * resultptr;
36944 resultptr = new wxColour((wxColour &)(result));
36945 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36946 }
36947 return resultobj;
36948 fail:
36949 return NULL;
36950 }
36951
36952
36953 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36954 PyObject *resultobj;
36955 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36956 wxBitmap *arg2 = 0 ;
36957 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36958 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36959 PyObject * obj0 = 0 ;
36960 PyObject * obj1 = 0 ;
36961 PyObject * obj2 = 0 ;
36962 char *kwnames[] = {
36963 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36964 };
36965
36966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36968 if (SWIG_arg_fail(1)) SWIG_fail;
36969 {
36970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36971 if (SWIG_arg_fail(2)) SWIG_fail;
36972 if (arg2 == NULL) {
36973 SWIG_null_ref("wxBitmap");
36974 }
36975 if (SWIG_arg_fail(2)) SWIG_fail;
36976 }
36977 if (obj2) {
36978 {
36979 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36980 if (SWIG_arg_fail(3)) SWIG_fail;
36981 if (arg3 == NULL) {
36982 SWIG_null_ref("wxBitmap");
36983 }
36984 if (SWIG_arg_fail(3)) SWIG_fail;
36985 }
36986 }
36987 {
36988 PyThreadState* __tstate = wxPyBeginAllowThreads();
36989 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36990
36991 wxPyEndAllowThreads(__tstate);
36992 if (PyErr_Occurred()) SWIG_fail;
36993 }
36994 Py_INCREF(Py_None); resultobj = Py_None;
36995 return resultobj;
36996 fail:
36997 return NULL;
36998 }
36999
37000
37001 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37002 PyObject *resultobj;
37003 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37004 wxBitmap *arg2 = 0 ;
37005 PyObject * obj0 = 0 ;
37006 PyObject * obj1 = 0 ;
37007 char *kwnames[] = {
37008 (char *) "self",(char *) "bmpDisabled", NULL
37009 };
37010
37011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37013 if (SWIG_arg_fail(1)) SWIG_fail;
37014 {
37015 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37016 if (SWIG_arg_fail(2)) SWIG_fail;
37017 if (arg2 == NULL) {
37018 SWIG_null_ref("wxBitmap");
37019 }
37020 if (SWIG_arg_fail(2)) SWIG_fail;
37021 }
37022 {
37023 PyThreadState* __tstate = wxPyBeginAllowThreads();
37024 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37025
37026 wxPyEndAllowThreads(__tstate);
37027 if (PyErr_Occurred()) SWIG_fail;
37028 }
37029 Py_INCREF(Py_None); resultobj = Py_None;
37030 return resultobj;
37031 fail:
37032 return NULL;
37033 }
37034
37035
37036 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37037 PyObject *resultobj;
37038 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37039 wxBitmap *result;
37040 PyObject * obj0 = 0 ;
37041 char *kwnames[] = {
37042 (char *) "self", NULL
37043 };
37044
37045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37047 if (SWIG_arg_fail(1)) SWIG_fail;
37048 {
37049 PyThreadState* __tstate = wxPyBeginAllowThreads();
37050 {
37051 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37052 result = (wxBitmap *) &_result_ref;
37053 }
37054
37055 wxPyEndAllowThreads(__tstate);
37056 if (PyErr_Occurred()) SWIG_fail;
37057 }
37058 {
37059 wxBitmap* resultptr = new wxBitmap(*result);
37060 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37061 }
37062 return resultobj;
37063 fail:
37064 return NULL;
37065 }
37066
37067
37068 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37069 PyObject *resultobj;
37070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37071 int arg2 ;
37072 PyObject * obj0 = 0 ;
37073 PyObject * obj1 = 0 ;
37074 char *kwnames[] = {
37075 (char *) "self",(char *) "nWidth", NULL
37076 };
37077
37078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37080 if (SWIG_arg_fail(1)) SWIG_fail;
37081 {
37082 arg2 = (int)(SWIG_As_int(obj1));
37083 if (SWIG_arg_fail(2)) SWIG_fail;
37084 }
37085 {
37086 PyThreadState* __tstate = wxPyBeginAllowThreads();
37087 wxMenuItem_SetMarginWidth(arg1,arg2);
37088
37089 wxPyEndAllowThreads(__tstate);
37090 if (PyErr_Occurred()) SWIG_fail;
37091 }
37092 Py_INCREF(Py_None); resultobj = Py_None;
37093 return resultobj;
37094 fail:
37095 return NULL;
37096 }
37097
37098
37099 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37100 PyObject *resultobj;
37101 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37102 int result;
37103 PyObject * obj0 = 0 ;
37104 char *kwnames[] = {
37105 (char *) "self", NULL
37106 };
37107
37108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37110 if (SWIG_arg_fail(1)) SWIG_fail;
37111 {
37112 PyThreadState* __tstate = wxPyBeginAllowThreads();
37113 result = (int)wxMenuItem_GetMarginWidth(arg1);
37114
37115 wxPyEndAllowThreads(__tstate);
37116 if (PyErr_Occurred()) SWIG_fail;
37117 }
37118 {
37119 resultobj = SWIG_From_int((int)(result));
37120 }
37121 return resultobj;
37122 fail:
37123 return NULL;
37124 }
37125
37126
37127 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37128 PyObject *resultobj;
37129 int result;
37130 char *kwnames[] = {
37131 NULL
37132 };
37133
37134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37135 {
37136 PyThreadState* __tstate = wxPyBeginAllowThreads();
37137 result = (int)MenuItem_GetDefaultMarginWidth();
37138
37139 wxPyEndAllowThreads(__tstate);
37140 if (PyErr_Occurred()) SWIG_fail;
37141 }
37142 {
37143 resultobj = SWIG_From_int((int)(result));
37144 }
37145 return resultobj;
37146 fail:
37147 return NULL;
37148 }
37149
37150
37151 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37152 PyObject *resultobj;
37153 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37154 bool result;
37155 PyObject * obj0 = 0 ;
37156 char *kwnames[] = {
37157 (char *) "self", NULL
37158 };
37159
37160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37162 if (SWIG_arg_fail(1)) SWIG_fail;
37163 {
37164 PyThreadState* __tstate = wxPyBeginAllowThreads();
37165 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37166
37167 wxPyEndAllowThreads(__tstate);
37168 if (PyErr_Occurred()) SWIG_fail;
37169 }
37170 {
37171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37172 }
37173 return resultobj;
37174 fail:
37175 return NULL;
37176 }
37177
37178
37179 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37180 PyObject *resultobj;
37181 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37182 bool arg2 = (bool) true ;
37183 PyObject * obj0 = 0 ;
37184 PyObject * obj1 = 0 ;
37185 char *kwnames[] = {
37186 (char *) "self",(char *) "ownerDrawn", NULL
37187 };
37188
37189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37191 if (SWIG_arg_fail(1)) SWIG_fail;
37192 if (obj1) {
37193 {
37194 arg2 = (bool)(SWIG_As_bool(obj1));
37195 if (SWIG_arg_fail(2)) SWIG_fail;
37196 }
37197 }
37198 {
37199 PyThreadState* __tstate = wxPyBeginAllowThreads();
37200 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37201
37202 wxPyEndAllowThreads(__tstate);
37203 if (PyErr_Occurred()) SWIG_fail;
37204 }
37205 Py_INCREF(Py_None); resultobj = Py_None;
37206 return resultobj;
37207 fail:
37208 return NULL;
37209 }
37210
37211
37212 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37213 PyObject *resultobj;
37214 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37215 PyObject * obj0 = 0 ;
37216 char *kwnames[] = {
37217 (char *) "self", NULL
37218 };
37219
37220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37222 if (SWIG_arg_fail(1)) SWIG_fail;
37223 {
37224 PyThreadState* __tstate = wxPyBeginAllowThreads();
37225 wxMenuItem_ResetOwnerDrawn(arg1);
37226
37227 wxPyEndAllowThreads(__tstate);
37228 if (PyErr_Occurred()) SWIG_fail;
37229 }
37230 Py_INCREF(Py_None); resultobj = Py_None;
37231 return resultobj;
37232 fail:
37233 return NULL;
37234 }
37235
37236
37237 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37238 PyObject *resultobj;
37239 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37240 wxBitmap *arg2 = 0 ;
37241 PyObject * obj0 = 0 ;
37242 PyObject * obj1 = 0 ;
37243 char *kwnames[] = {
37244 (char *) "self",(char *) "bitmap", NULL
37245 };
37246
37247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37249 if (SWIG_arg_fail(1)) SWIG_fail;
37250 {
37251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37252 if (SWIG_arg_fail(2)) SWIG_fail;
37253 if (arg2 == NULL) {
37254 SWIG_null_ref("wxBitmap");
37255 }
37256 if (SWIG_arg_fail(2)) SWIG_fail;
37257 }
37258 {
37259 PyThreadState* __tstate = wxPyBeginAllowThreads();
37260 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37261
37262 wxPyEndAllowThreads(__tstate);
37263 if (PyErr_Occurred()) SWIG_fail;
37264 }
37265 Py_INCREF(Py_None); resultobj = Py_None;
37266 return resultobj;
37267 fail:
37268 return NULL;
37269 }
37270
37271
37272 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37273 PyObject *resultobj;
37274 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37275 wxBitmap *result;
37276 PyObject * obj0 = 0 ;
37277 char *kwnames[] = {
37278 (char *) "self", NULL
37279 };
37280
37281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37283 if (SWIG_arg_fail(1)) SWIG_fail;
37284 {
37285 PyThreadState* __tstate = wxPyBeginAllowThreads();
37286 {
37287 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37288 result = (wxBitmap *) &_result_ref;
37289 }
37290
37291 wxPyEndAllowThreads(__tstate);
37292 if (PyErr_Occurred()) SWIG_fail;
37293 }
37294 {
37295 wxBitmap* resultptr = new wxBitmap(*result);
37296 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37297 }
37298 return resultobj;
37299 fail:
37300 return NULL;
37301 }
37302
37303
37304 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37305 PyObject *obj;
37306 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37307 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37308 Py_INCREF(obj);
37309 return Py_BuildValue((char *)"");
37310 }
37311 static int _wrap_ControlNameStr_set(PyObject *) {
37312 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37313 return 1;
37314 }
37315
37316
37317 static PyObject *_wrap_ControlNameStr_get(void) {
37318 PyObject *pyobj;
37319
37320 {
37321 #if wxUSE_UNICODE
37322 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37323 #else
37324 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37325 #endif
37326 }
37327 return pyobj;
37328 }
37329
37330
37331 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37332 PyObject *resultobj;
37333 wxWindow *arg1 = (wxWindow *) 0 ;
37334 int arg2 = (int) -1 ;
37335 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37336 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37337 wxSize const &arg4_defvalue = wxDefaultSize ;
37338 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37339 long arg5 = (long) 0 ;
37340 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37341 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37342 wxString const &arg7_defvalue = wxPyControlNameStr ;
37343 wxString *arg7 = (wxString *) &arg7_defvalue ;
37344 wxControl *result;
37345 wxPoint temp3 ;
37346 wxSize temp4 ;
37347 bool temp7 = false ;
37348 PyObject * obj0 = 0 ;
37349 PyObject * obj1 = 0 ;
37350 PyObject * obj2 = 0 ;
37351 PyObject * obj3 = 0 ;
37352 PyObject * obj4 = 0 ;
37353 PyObject * obj5 = 0 ;
37354 PyObject * obj6 = 0 ;
37355 char *kwnames[] = {
37356 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37357 };
37358
37359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37361 if (SWIG_arg_fail(1)) SWIG_fail;
37362 if (obj1) {
37363 {
37364 arg2 = (int)(SWIG_As_int(obj1));
37365 if (SWIG_arg_fail(2)) SWIG_fail;
37366 }
37367 }
37368 if (obj2) {
37369 {
37370 arg3 = &temp3;
37371 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37372 }
37373 }
37374 if (obj3) {
37375 {
37376 arg4 = &temp4;
37377 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37378 }
37379 }
37380 if (obj4) {
37381 {
37382 arg5 = (long)(SWIG_As_long(obj4));
37383 if (SWIG_arg_fail(5)) SWIG_fail;
37384 }
37385 }
37386 if (obj5) {
37387 {
37388 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37389 if (SWIG_arg_fail(6)) SWIG_fail;
37390 if (arg6 == NULL) {
37391 SWIG_null_ref("wxValidator");
37392 }
37393 if (SWIG_arg_fail(6)) SWIG_fail;
37394 }
37395 }
37396 if (obj6) {
37397 {
37398 arg7 = wxString_in_helper(obj6);
37399 if (arg7 == NULL) SWIG_fail;
37400 temp7 = true;
37401 }
37402 }
37403 {
37404 if (!wxPyCheckForApp()) SWIG_fail;
37405 PyThreadState* __tstate = wxPyBeginAllowThreads();
37406 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37407
37408 wxPyEndAllowThreads(__tstate);
37409 if (PyErr_Occurred()) SWIG_fail;
37410 }
37411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37412 {
37413 if (temp7)
37414 delete arg7;
37415 }
37416 return resultobj;
37417 fail:
37418 {
37419 if (temp7)
37420 delete arg7;
37421 }
37422 return NULL;
37423 }
37424
37425
37426 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37427 PyObject *resultobj;
37428 wxControl *result;
37429 char *kwnames[] = {
37430 NULL
37431 };
37432
37433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37434 {
37435 if (!wxPyCheckForApp()) SWIG_fail;
37436 PyThreadState* __tstate = wxPyBeginAllowThreads();
37437 result = (wxControl *)new wxControl();
37438
37439 wxPyEndAllowThreads(__tstate);
37440 if (PyErr_Occurred()) SWIG_fail;
37441 }
37442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37443 return resultobj;
37444 fail:
37445 return NULL;
37446 }
37447
37448
37449 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37450 PyObject *resultobj;
37451 wxControl *arg1 = (wxControl *) 0 ;
37452 wxWindow *arg2 = (wxWindow *) 0 ;
37453 int arg3 = (int) -1 ;
37454 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37455 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37456 wxSize const &arg5_defvalue = wxDefaultSize ;
37457 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37458 long arg6 = (long) 0 ;
37459 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37460 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37461 wxString const &arg8_defvalue = wxPyControlNameStr ;
37462 wxString *arg8 = (wxString *) &arg8_defvalue ;
37463 bool result;
37464 wxPoint temp4 ;
37465 wxSize temp5 ;
37466 bool temp8 = false ;
37467 PyObject * obj0 = 0 ;
37468 PyObject * obj1 = 0 ;
37469 PyObject * obj2 = 0 ;
37470 PyObject * obj3 = 0 ;
37471 PyObject * obj4 = 0 ;
37472 PyObject * obj5 = 0 ;
37473 PyObject * obj6 = 0 ;
37474 PyObject * obj7 = 0 ;
37475 char *kwnames[] = {
37476 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37477 };
37478
37479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37481 if (SWIG_arg_fail(1)) SWIG_fail;
37482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37483 if (SWIG_arg_fail(2)) SWIG_fail;
37484 if (obj2) {
37485 {
37486 arg3 = (int)(SWIG_As_int(obj2));
37487 if (SWIG_arg_fail(3)) SWIG_fail;
37488 }
37489 }
37490 if (obj3) {
37491 {
37492 arg4 = &temp4;
37493 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37494 }
37495 }
37496 if (obj4) {
37497 {
37498 arg5 = &temp5;
37499 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37500 }
37501 }
37502 if (obj5) {
37503 {
37504 arg6 = (long)(SWIG_As_long(obj5));
37505 if (SWIG_arg_fail(6)) SWIG_fail;
37506 }
37507 }
37508 if (obj6) {
37509 {
37510 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37511 if (SWIG_arg_fail(7)) SWIG_fail;
37512 if (arg7 == NULL) {
37513 SWIG_null_ref("wxValidator");
37514 }
37515 if (SWIG_arg_fail(7)) SWIG_fail;
37516 }
37517 }
37518 if (obj7) {
37519 {
37520 arg8 = wxString_in_helper(obj7);
37521 if (arg8 == NULL) SWIG_fail;
37522 temp8 = true;
37523 }
37524 }
37525 {
37526 PyThreadState* __tstate = wxPyBeginAllowThreads();
37527 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37528
37529 wxPyEndAllowThreads(__tstate);
37530 if (PyErr_Occurred()) SWIG_fail;
37531 }
37532 {
37533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37534 }
37535 {
37536 if (temp8)
37537 delete arg8;
37538 }
37539 return resultobj;
37540 fail:
37541 {
37542 if (temp8)
37543 delete arg8;
37544 }
37545 return NULL;
37546 }
37547
37548
37549 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37550 PyObject *resultobj;
37551 wxControl *arg1 = (wxControl *) 0 ;
37552 wxCommandEvent *arg2 = 0 ;
37553 PyObject * obj0 = 0 ;
37554 PyObject * obj1 = 0 ;
37555 char *kwnames[] = {
37556 (char *) "self",(char *) "event", NULL
37557 };
37558
37559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37561 if (SWIG_arg_fail(1)) SWIG_fail;
37562 {
37563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37564 if (SWIG_arg_fail(2)) SWIG_fail;
37565 if (arg2 == NULL) {
37566 SWIG_null_ref("wxCommandEvent");
37567 }
37568 if (SWIG_arg_fail(2)) SWIG_fail;
37569 }
37570 {
37571 PyThreadState* __tstate = wxPyBeginAllowThreads();
37572 (arg1)->Command(*arg2);
37573
37574 wxPyEndAllowThreads(__tstate);
37575 if (PyErr_Occurred()) SWIG_fail;
37576 }
37577 Py_INCREF(Py_None); resultobj = Py_None;
37578 return resultobj;
37579 fail:
37580 return NULL;
37581 }
37582
37583
37584 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37585 PyObject *resultobj;
37586 wxControl *arg1 = (wxControl *) 0 ;
37587 wxString result;
37588 PyObject * obj0 = 0 ;
37589 char *kwnames[] = {
37590 (char *) "self", NULL
37591 };
37592
37593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37595 if (SWIG_arg_fail(1)) SWIG_fail;
37596 {
37597 PyThreadState* __tstate = wxPyBeginAllowThreads();
37598 result = (arg1)->GetLabel();
37599
37600 wxPyEndAllowThreads(__tstate);
37601 if (PyErr_Occurred()) SWIG_fail;
37602 }
37603 {
37604 #if wxUSE_UNICODE
37605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37606 #else
37607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37608 #endif
37609 }
37610 return resultobj;
37611 fail:
37612 return NULL;
37613 }
37614
37615
37616 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37617 PyObject *resultobj;
37618 wxControl *arg1 = (wxControl *) 0 ;
37619 wxString *arg2 = 0 ;
37620 bool temp2 = false ;
37621 PyObject * obj0 = 0 ;
37622 PyObject * obj1 = 0 ;
37623 char *kwnames[] = {
37624 (char *) "self",(char *) "label", NULL
37625 };
37626
37627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37629 if (SWIG_arg_fail(1)) SWIG_fail;
37630 {
37631 arg2 = wxString_in_helper(obj1);
37632 if (arg2 == NULL) SWIG_fail;
37633 temp2 = true;
37634 }
37635 {
37636 PyThreadState* __tstate = wxPyBeginAllowThreads();
37637 (arg1)->SetLabel((wxString const &)*arg2);
37638
37639 wxPyEndAllowThreads(__tstate);
37640 if (PyErr_Occurred()) SWIG_fail;
37641 }
37642 Py_INCREF(Py_None); resultobj = Py_None;
37643 {
37644 if (temp2)
37645 delete arg2;
37646 }
37647 return resultobj;
37648 fail:
37649 {
37650 if (temp2)
37651 delete arg2;
37652 }
37653 return NULL;
37654 }
37655
37656
37657 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37658 PyObject *resultobj;
37659 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37660 wxVisualAttributes result;
37661 PyObject * obj0 = 0 ;
37662 char *kwnames[] = {
37663 (char *) "variant", NULL
37664 };
37665
37666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37667 if (obj0) {
37668 {
37669 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37670 if (SWIG_arg_fail(1)) SWIG_fail;
37671 }
37672 }
37673 {
37674 if (!wxPyCheckForApp()) SWIG_fail;
37675 PyThreadState* __tstate = wxPyBeginAllowThreads();
37676 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37677
37678 wxPyEndAllowThreads(__tstate);
37679 if (PyErr_Occurred()) SWIG_fail;
37680 }
37681 {
37682 wxVisualAttributes * resultptr;
37683 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37684 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37685 }
37686 return resultobj;
37687 fail:
37688 return NULL;
37689 }
37690
37691
37692 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37693 PyObject *obj;
37694 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37695 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37696 Py_INCREF(obj);
37697 return Py_BuildValue((char *)"");
37698 }
37699 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37700 PyObject *resultobj;
37701 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37702 wxString *arg2 = 0 ;
37703 PyObject *arg3 = (PyObject *) NULL ;
37704 int result;
37705 bool temp2 = false ;
37706 PyObject * obj0 = 0 ;
37707 PyObject * obj1 = 0 ;
37708 PyObject * obj2 = 0 ;
37709 char *kwnames[] = {
37710 (char *) "self",(char *) "item",(char *) "clientData", NULL
37711 };
37712
37713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37715 if (SWIG_arg_fail(1)) SWIG_fail;
37716 {
37717 arg2 = wxString_in_helper(obj1);
37718 if (arg2 == NULL) SWIG_fail;
37719 temp2 = true;
37720 }
37721 if (obj2) {
37722 arg3 = obj2;
37723 }
37724 {
37725 PyThreadState* __tstate = wxPyBeginAllowThreads();
37726 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37727
37728 wxPyEndAllowThreads(__tstate);
37729 if (PyErr_Occurred()) SWIG_fail;
37730 }
37731 {
37732 resultobj = SWIG_From_int((int)(result));
37733 }
37734 {
37735 if (temp2)
37736 delete arg2;
37737 }
37738 return resultobj;
37739 fail:
37740 {
37741 if (temp2)
37742 delete arg2;
37743 }
37744 return NULL;
37745 }
37746
37747
37748 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37749 PyObject *resultobj;
37750 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37751 wxArrayString *arg2 = 0 ;
37752 bool temp2 = false ;
37753 PyObject * obj0 = 0 ;
37754 PyObject * obj1 = 0 ;
37755 char *kwnames[] = {
37756 (char *) "self",(char *) "strings", NULL
37757 };
37758
37759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37761 if (SWIG_arg_fail(1)) SWIG_fail;
37762 {
37763 if (! PySequence_Check(obj1)) {
37764 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37765 SWIG_fail;
37766 }
37767 arg2 = new wxArrayString;
37768 temp2 = true;
37769 int i, len=PySequence_Length(obj1);
37770 for (i=0; i<len; i++) {
37771 PyObject* item = PySequence_GetItem(obj1, i);
37772 #if wxUSE_UNICODE
37773 PyObject* str = PyObject_Unicode(item);
37774 #else
37775 PyObject* str = PyObject_Str(item);
37776 #endif
37777 if (PyErr_Occurred()) SWIG_fail;
37778 arg2->Add(Py2wxString(str));
37779 Py_DECREF(item);
37780 Py_DECREF(str);
37781 }
37782 }
37783 {
37784 PyThreadState* __tstate = wxPyBeginAllowThreads();
37785 (arg1)->Append((wxArrayString const &)*arg2);
37786
37787 wxPyEndAllowThreads(__tstate);
37788 if (PyErr_Occurred()) SWIG_fail;
37789 }
37790 Py_INCREF(Py_None); resultobj = Py_None;
37791 {
37792 if (temp2) delete arg2;
37793 }
37794 return resultobj;
37795 fail:
37796 {
37797 if (temp2) delete arg2;
37798 }
37799 return NULL;
37800 }
37801
37802
37803 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37804 PyObject *resultobj;
37805 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37806 wxString *arg2 = 0 ;
37807 int arg3 ;
37808 PyObject *arg4 = (PyObject *) NULL ;
37809 int result;
37810 bool temp2 = false ;
37811 PyObject * obj0 = 0 ;
37812 PyObject * obj1 = 0 ;
37813 PyObject * obj2 = 0 ;
37814 PyObject * obj3 = 0 ;
37815 char *kwnames[] = {
37816 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37817 };
37818
37819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37821 if (SWIG_arg_fail(1)) SWIG_fail;
37822 {
37823 arg2 = wxString_in_helper(obj1);
37824 if (arg2 == NULL) SWIG_fail;
37825 temp2 = true;
37826 }
37827 {
37828 arg3 = (int)(SWIG_As_int(obj2));
37829 if (SWIG_arg_fail(3)) SWIG_fail;
37830 }
37831 if (obj3) {
37832 arg4 = obj3;
37833 }
37834 {
37835 PyThreadState* __tstate = wxPyBeginAllowThreads();
37836 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37837
37838 wxPyEndAllowThreads(__tstate);
37839 if (PyErr_Occurred()) SWIG_fail;
37840 }
37841 {
37842 resultobj = SWIG_From_int((int)(result));
37843 }
37844 {
37845 if (temp2)
37846 delete arg2;
37847 }
37848 return resultobj;
37849 fail:
37850 {
37851 if (temp2)
37852 delete arg2;
37853 }
37854 return NULL;
37855 }
37856
37857
37858 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37859 PyObject *resultobj;
37860 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37861 PyObject * obj0 = 0 ;
37862 char *kwnames[] = {
37863 (char *) "self", NULL
37864 };
37865
37866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37868 if (SWIG_arg_fail(1)) SWIG_fail;
37869 {
37870 PyThreadState* __tstate = wxPyBeginAllowThreads();
37871 (arg1)->Clear();
37872
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 Py_INCREF(Py_None); resultobj = Py_None;
37877 return resultobj;
37878 fail:
37879 return NULL;
37880 }
37881
37882
37883 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37884 PyObject *resultobj;
37885 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37886 int arg2 ;
37887 PyObject * obj0 = 0 ;
37888 PyObject * obj1 = 0 ;
37889 char *kwnames[] = {
37890 (char *) "self",(char *) "n", NULL
37891 };
37892
37893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37895 if (SWIG_arg_fail(1)) SWIG_fail;
37896 {
37897 arg2 = (int)(SWIG_As_int(obj1));
37898 if (SWIG_arg_fail(2)) SWIG_fail;
37899 }
37900 {
37901 PyThreadState* __tstate = wxPyBeginAllowThreads();
37902 (arg1)->Delete(arg2);
37903
37904 wxPyEndAllowThreads(__tstate);
37905 if (PyErr_Occurred()) SWIG_fail;
37906 }
37907 Py_INCREF(Py_None); resultobj = Py_None;
37908 return resultobj;
37909 fail:
37910 return NULL;
37911 }
37912
37913
37914 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37915 PyObject *resultobj;
37916 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37917 int arg2 ;
37918 PyObject *result;
37919 PyObject * obj0 = 0 ;
37920 PyObject * obj1 = 0 ;
37921 char *kwnames[] = {
37922 (char *) "self",(char *) "n", NULL
37923 };
37924
37925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37927 if (SWIG_arg_fail(1)) SWIG_fail;
37928 {
37929 arg2 = (int)(SWIG_As_int(obj1));
37930 if (SWIG_arg_fail(2)) SWIG_fail;
37931 }
37932 {
37933 PyThreadState* __tstate = wxPyBeginAllowThreads();
37934 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37935
37936 wxPyEndAllowThreads(__tstate);
37937 if (PyErr_Occurred()) SWIG_fail;
37938 }
37939 resultobj = result;
37940 return resultobj;
37941 fail:
37942 return NULL;
37943 }
37944
37945
37946 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37947 PyObject *resultobj;
37948 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37949 int arg2 ;
37950 PyObject *arg3 = (PyObject *) 0 ;
37951 PyObject * obj0 = 0 ;
37952 PyObject * obj1 = 0 ;
37953 PyObject * obj2 = 0 ;
37954 char *kwnames[] = {
37955 (char *) "self",(char *) "n",(char *) "clientData", NULL
37956 };
37957
37958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37960 if (SWIG_arg_fail(1)) SWIG_fail;
37961 {
37962 arg2 = (int)(SWIG_As_int(obj1));
37963 if (SWIG_arg_fail(2)) SWIG_fail;
37964 }
37965 arg3 = obj2;
37966 {
37967 PyThreadState* __tstate = wxPyBeginAllowThreads();
37968 wxItemContainer_SetClientData(arg1,arg2,arg3);
37969
37970 wxPyEndAllowThreads(__tstate);
37971 if (PyErr_Occurred()) SWIG_fail;
37972 }
37973 Py_INCREF(Py_None); resultobj = Py_None;
37974 return resultobj;
37975 fail:
37976 return NULL;
37977 }
37978
37979
37980 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37981 PyObject *resultobj;
37982 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37983 int result;
37984 PyObject * obj0 = 0 ;
37985 char *kwnames[] = {
37986 (char *) "self", NULL
37987 };
37988
37989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37991 if (SWIG_arg_fail(1)) SWIG_fail;
37992 {
37993 PyThreadState* __tstate = wxPyBeginAllowThreads();
37994 result = (int)((wxItemContainer const *)arg1)->GetCount();
37995
37996 wxPyEndAllowThreads(__tstate);
37997 if (PyErr_Occurred()) SWIG_fail;
37998 }
37999 {
38000 resultobj = SWIG_From_int((int)(result));
38001 }
38002 return resultobj;
38003 fail:
38004 return NULL;
38005 }
38006
38007
38008 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38009 PyObject *resultobj;
38010 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38011 bool result;
38012 PyObject * obj0 = 0 ;
38013 char *kwnames[] = {
38014 (char *) "self", NULL
38015 };
38016
38017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38019 if (SWIG_arg_fail(1)) SWIG_fail;
38020 {
38021 PyThreadState* __tstate = wxPyBeginAllowThreads();
38022 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38023
38024 wxPyEndAllowThreads(__tstate);
38025 if (PyErr_Occurred()) SWIG_fail;
38026 }
38027 {
38028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38029 }
38030 return resultobj;
38031 fail:
38032 return NULL;
38033 }
38034
38035
38036 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38037 PyObject *resultobj;
38038 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38039 int arg2 ;
38040 wxString result;
38041 PyObject * obj0 = 0 ;
38042 PyObject * obj1 = 0 ;
38043 char *kwnames[] = {
38044 (char *) "self",(char *) "n", NULL
38045 };
38046
38047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38049 if (SWIG_arg_fail(1)) SWIG_fail;
38050 {
38051 arg2 = (int)(SWIG_As_int(obj1));
38052 if (SWIG_arg_fail(2)) SWIG_fail;
38053 }
38054 {
38055 PyThreadState* __tstate = wxPyBeginAllowThreads();
38056 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38057
38058 wxPyEndAllowThreads(__tstate);
38059 if (PyErr_Occurred()) SWIG_fail;
38060 }
38061 {
38062 #if wxUSE_UNICODE
38063 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38064 #else
38065 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38066 #endif
38067 }
38068 return resultobj;
38069 fail:
38070 return NULL;
38071 }
38072
38073
38074 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38075 PyObject *resultobj;
38076 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38077 wxArrayString result;
38078 PyObject * obj0 = 0 ;
38079 char *kwnames[] = {
38080 (char *) "self", NULL
38081 };
38082
38083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38085 if (SWIG_arg_fail(1)) SWIG_fail;
38086 {
38087 PyThreadState* __tstate = wxPyBeginAllowThreads();
38088 result = ((wxItemContainer const *)arg1)->GetStrings();
38089
38090 wxPyEndAllowThreads(__tstate);
38091 if (PyErr_Occurred()) SWIG_fail;
38092 }
38093 {
38094 resultobj = wxArrayString2PyList_helper(result);
38095 }
38096 return resultobj;
38097 fail:
38098 return NULL;
38099 }
38100
38101
38102 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38103 PyObject *resultobj;
38104 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38105 int arg2 ;
38106 wxString *arg3 = 0 ;
38107 bool temp3 = false ;
38108 PyObject * obj0 = 0 ;
38109 PyObject * obj1 = 0 ;
38110 PyObject * obj2 = 0 ;
38111 char *kwnames[] = {
38112 (char *) "self",(char *) "n",(char *) "s", NULL
38113 };
38114
38115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38117 if (SWIG_arg_fail(1)) SWIG_fail;
38118 {
38119 arg2 = (int)(SWIG_As_int(obj1));
38120 if (SWIG_arg_fail(2)) SWIG_fail;
38121 }
38122 {
38123 arg3 = wxString_in_helper(obj2);
38124 if (arg3 == NULL) SWIG_fail;
38125 temp3 = true;
38126 }
38127 {
38128 PyThreadState* __tstate = wxPyBeginAllowThreads();
38129 (arg1)->SetString(arg2,(wxString const &)*arg3);
38130
38131 wxPyEndAllowThreads(__tstate);
38132 if (PyErr_Occurred()) SWIG_fail;
38133 }
38134 Py_INCREF(Py_None); resultobj = Py_None;
38135 {
38136 if (temp3)
38137 delete arg3;
38138 }
38139 return resultobj;
38140 fail:
38141 {
38142 if (temp3)
38143 delete arg3;
38144 }
38145 return NULL;
38146 }
38147
38148
38149 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38150 PyObject *resultobj;
38151 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38152 wxString *arg2 = 0 ;
38153 int result;
38154 bool temp2 = false ;
38155 PyObject * obj0 = 0 ;
38156 PyObject * obj1 = 0 ;
38157 char *kwnames[] = {
38158 (char *) "self",(char *) "s", NULL
38159 };
38160
38161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38163 if (SWIG_arg_fail(1)) SWIG_fail;
38164 {
38165 arg2 = wxString_in_helper(obj1);
38166 if (arg2 == NULL) SWIG_fail;
38167 temp2 = true;
38168 }
38169 {
38170 PyThreadState* __tstate = wxPyBeginAllowThreads();
38171 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38172
38173 wxPyEndAllowThreads(__tstate);
38174 if (PyErr_Occurred()) SWIG_fail;
38175 }
38176 {
38177 resultobj = SWIG_From_int((int)(result));
38178 }
38179 {
38180 if (temp2)
38181 delete arg2;
38182 }
38183 return resultobj;
38184 fail:
38185 {
38186 if (temp2)
38187 delete arg2;
38188 }
38189 return NULL;
38190 }
38191
38192
38193 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38194 PyObject *resultobj;
38195 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38196 int arg2 ;
38197 PyObject * obj0 = 0 ;
38198 PyObject * obj1 = 0 ;
38199 char *kwnames[] = {
38200 (char *) "self",(char *) "n", NULL
38201 };
38202
38203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38205 if (SWIG_arg_fail(1)) SWIG_fail;
38206 {
38207 arg2 = (int)(SWIG_As_int(obj1));
38208 if (SWIG_arg_fail(2)) SWIG_fail;
38209 }
38210 {
38211 PyThreadState* __tstate = wxPyBeginAllowThreads();
38212 (arg1)->SetSelection(arg2);
38213
38214 wxPyEndAllowThreads(__tstate);
38215 if (PyErr_Occurred()) SWIG_fail;
38216 }
38217 Py_INCREF(Py_None); resultobj = Py_None;
38218 return resultobj;
38219 fail:
38220 return NULL;
38221 }
38222
38223
38224 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38225 PyObject *resultobj;
38226 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38227 int result;
38228 PyObject * obj0 = 0 ;
38229 char *kwnames[] = {
38230 (char *) "self", NULL
38231 };
38232
38233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38235 if (SWIG_arg_fail(1)) SWIG_fail;
38236 {
38237 PyThreadState* __tstate = wxPyBeginAllowThreads();
38238 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38239
38240 wxPyEndAllowThreads(__tstate);
38241 if (PyErr_Occurred()) SWIG_fail;
38242 }
38243 {
38244 resultobj = SWIG_From_int((int)(result));
38245 }
38246 return resultobj;
38247 fail:
38248 return NULL;
38249 }
38250
38251
38252 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38253 PyObject *resultobj;
38254 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38255 wxString *arg2 = 0 ;
38256 bool result;
38257 bool temp2 = false ;
38258 PyObject * obj0 = 0 ;
38259 PyObject * obj1 = 0 ;
38260 char *kwnames[] = {
38261 (char *) "self",(char *) "s", NULL
38262 };
38263
38264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38266 if (SWIG_arg_fail(1)) SWIG_fail;
38267 {
38268 arg2 = wxString_in_helper(obj1);
38269 if (arg2 == NULL) SWIG_fail;
38270 temp2 = true;
38271 }
38272 {
38273 PyThreadState* __tstate = wxPyBeginAllowThreads();
38274 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38275
38276 wxPyEndAllowThreads(__tstate);
38277 if (PyErr_Occurred()) SWIG_fail;
38278 }
38279 {
38280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38281 }
38282 {
38283 if (temp2)
38284 delete arg2;
38285 }
38286 return resultobj;
38287 fail:
38288 {
38289 if (temp2)
38290 delete arg2;
38291 }
38292 return NULL;
38293 }
38294
38295
38296 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38297 PyObject *resultobj;
38298 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38299 wxString result;
38300 PyObject * obj0 = 0 ;
38301 char *kwnames[] = {
38302 (char *) "self", NULL
38303 };
38304
38305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38307 if (SWIG_arg_fail(1)) SWIG_fail;
38308 {
38309 PyThreadState* __tstate = wxPyBeginAllowThreads();
38310 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38311
38312 wxPyEndAllowThreads(__tstate);
38313 if (PyErr_Occurred()) SWIG_fail;
38314 }
38315 {
38316 #if wxUSE_UNICODE
38317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38318 #else
38319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38320 #endif
38321 }
38322 return resultobj;
38323 fail:
38324 return NULL;
38325 }
38326
38327
38328 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38329 PyObject *resultobj;
38330 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38331 int arg2 ;
38332 PyObject * obj0 = 0 ;
38333 PyObject * obj1 = 0 ;
38334 char *kwnames[] = {
38335 (char *) "self",(char *) "n", NULL
38336 };
38337
38338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38340 if (SWIG_arg_fail(1)) SWIG_fail;
38341 {
38342 arg2 = (int)(SWIG_As_int(obj1));
38343 if (SWIG_arg_fail(2)) SWIG_fail;
38344 }
38345 {
38346 PyThreadState* __tstate = wxPyBeginAllowThreads();
38347 (arg1)->Select(arg2);
38348
38349 wxPyEndAllowThreads(__tstate);
38350 if (PyErr_Occurred()) SWIG_fail;
38351 }
38352 Py_INCREF(Py_None); resultobj = Py_None;
38353 return resultobj;
38354 fail:
38355 return NULL;
38356 }
38357
38358
38359 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38360 PyObject *obj;
38361 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38362 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38363 Py_INCREF(obj);
38364 return Py_BuildValue((char *)"");
38365 }
38366 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38367 PyObject *obj;
38368 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38369 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38370 Py_INCREF(obj);
38371 return Py_BuildValue((char *)"");
38372 }
38373 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38374 PyObject *resultobj;
38375 wxSizerItem *result;
38376 char *kwnames[] = {
38377 NULL
38378 };
38379
38380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38381 {
38382 PyThreadState* __tstate = wxPyBeginAllowThreads();
38383 result = (wxSizerItem *)new wxSizerItem();
38384
38385 wxPyEndAllowThreads(__tstate);
38386 if (PyErr_Occurred()) SWIG_fail;
38387 }
38388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38389 return resultobj;
38390 fail:
38391 return NULL;
38392 }
38393
38394
38395 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38396 PyObject *resultobj;
38397 wxWindow *arg1 = (wxWindow *) 0 ;
38398 int arg2 ;
38399 int arg3 ;
38400 int arg4 ;
38401 PyObject *arg5 = (PyObject *) NULL ;
38402 wxSizerItem *result;
38403 PyObject * obj0 = 0 ;
38404 PyObject * obj1 = 0 ;
38405 PyObject * obj2 = 0 ;
38406 PyObject * obj3 = 0 ;
38407 PyObject * obj4 = 0 ;
38408 char *kwnames[] = {
38409 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38410 };
38411
38412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38414 if (SWIG_arg_fail(1)) SWIG_fail;
38415 {
38416 arg2 = (int)(SWIG_As_int(obj1));
38417 if (SWIG_arg_fail(2)) SWIG_fail;
38418 }
38419 {
38420 arg3 = (int)(SWIG_As_int(obj2));
38421 if (SWIG_arg_fail(3)) SWIG_fail;
38422 }
38423 {
38424 arg4 = (int)(SWIG_As_int(obj3));
38425 if (SWIG_arg_fail(4)) SWIG_fail;
38426 }
38427 if (obj4) {
38428 arg5 = obj4;
38429 }
38430 {
38431 PyThreadState* __tstate = wxPyBeginAllowThreads();
38432 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38433
38434 wxPyEndAllowThreads(__tstate);
38435 if (PyErr_Occurred()) SWIG_fail;
38436 }
38437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38438 return resultobj;
38439 fail:
38440 return NULL;
38441 }
38442
38443
38444 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38445 PyObject *resultobj;
38446 int arg1 ;
38447 int arg2 ;
38448 int arg3 ;
38449 int arg4 ;
38450 int arg5 ;
38451 PyObject *arg6 = (PyObject *) NULL ;
38452 wxSizerItem *result;
38453 PyObject * obj0 = 0 ;
38454 PyObject * obj1 = 0 ;
38455 PyObject * obj2 = 0 ;
38456 PyObject * obj3 = 0 ;
38457 PyObject * obj4 = 0 ;
38458 PyObject * obj5 = 0 ;
38459 char *kwnames[] = {
38460 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38461 };
38462
38463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38464 {
38465 arg1 = (int)(SWIG_As_int(obj0));
38466 if (SWIG_arg_fail(1)) SWIG_fail;
38467 }
38468 {
38469 arg2 = (int)(SWIG_As_int(obj1));
38470 if (SWIG_arg_fail(2)) SWIG_fail;
38471 }
38472 {
38473 arg3 = (int)(SWIG_As_int(obj2));
38474 if (SWIG_arg_fail(3)) SWIG_fail;
38475 }
38476 {
38477 arg4 = (int)(SWIG_As_int(obj3));
38478 if (SWIG_arg_fail(4)) SWIG_fail;
38479 }
38480 {
38481 arg5 = (int)(SWIG_As_int(obj4));
38482 if (SWIG_arg_fail(5)) SWIG_fail;
38483 }
38484 if (obj5) {
38485 arg6 = obj5;
38486 }
38487 {
38488 PyThreadState* __tstate = wxPyBeginAllowThreads();
38489 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38490
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38495 return resultobj;
38496 fail:
38497 return NULL;
38498 }
38499
38500
38501 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38502 PyObject *resultobj;
38503 wxSizer *arg1 = (wxSizer *) 0 ;
38504 int arg2 ;
38505 int arg3 ;
38506 int arg4 ;
38507 PyObject *arg5 = (PyObject *) NULL ;
38508 wxSizerItem *result;
38509 PyObject * obj0 = 0 ;
38510 PyObject * obj1 = 0 ;
38511 PyObject * obj2 = 0 ;
38512 PyObject * obj3 = 0 ;
38513 PyObject * obj4 = 0 ;
38514 char *kwnames[] = {
38515 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38516 };
38517
38518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38520 if (SWIG_arg_fail(1)) SWIG_fail;
38521 {
38522 arg2 = (int)(SWIG_As_int(obj1));
38523 if (SWIG_arg_fail(2)) SWIG_fail;
38524 }
38525 {
38526 arg3 = (int)(SWIG_As_int(obj2));
38527 if (SWIG_arg_fail(3)) SWIG_fail;
38528 }
38529 {
38530 arg4 = (int)(SWIG_As_int(obj3));
38531 if (SWIG_arg_fail(4)) SWIG_fail;
38532 }
38533 if (obj4) {
38534 arg5 = obj4;
38535 }
38536 {
38537 PyThreadState* __tstate = wxPyBeginAllowThreads();
38538 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38539
38540 wxPyEndAllowThreads(__tstate);
38541 if (PyErr_Occurred()) SWIG_fail;
38542 }
38543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38544 return resultobj;
38545 fail:
38546 return NULL;
38547 }
38548
38549
38550 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38551 PyObject *resultobj;
38552 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38553 PyObject * obj0 = 0 ;
38554 char *kwnames[] = {
38555 (char *) "self", NULL
38556 };
38557
38558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38560 if (SWIG_arg_fail(1)) SWIG_fail;
38561 {
38562 PyThreadState* __tstate = wxPyBeginAllowThreads();
38563 (arg1)->DeleteWindows();
38564
38565 wxPyEndAllowThreads(__tstate);
38566 if (PyErr_Occurred()) SWIG_fail;
38567 }
38568 Py_INCREF(Py_None); resultobj = Py_None;
38569 return resultobj;
38570 fail:
38571 return NULL;
38572 }
38573
38574
38575 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38576 PyObject *resultobj;
38577 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38578 PyObject * obj0 = 0 ;
38579 char *kwnames[] = {
38580 (char *) "self", NULL
38581 };
38582
38583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38585 if (SWIG_arg_fail(1)) SWIG_fail;
38586 {
38587 PyThreadState* __tstate = wxPyBeginAllowThreads();
38588 (arg1)->DetachSizer();
38589
38590 wxPyEndAllowThreads(__tstate);
38591 if (PyErr_Occurred()) SWIG_fail;
38592 }
38593 Py_INCREF(Py_None); resultobj = Py_None;
38594 return resultobj;
38595 fail:
38596 return NULL;
38597 }
38598
38599
38600 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38601 PyObject *resultobj;
38602 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38603 wxSize result;
38604 PyObject * obj0 = 0 ;
38605 char *kwnames[] = {
38606 (char *) "self", NULL
38607 };
38608
38609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38611 if (SWIG_arg_fail(1)) SWIG_fail;
38612 {
38613 PyThreadState* __tstate = wxPyBeginAllowThreads();
38614 result = (arg1)->GetSize();
38615
38616 wxPyEndAllowThreads(__tstate);
38617 if (PyErr_Occurred()) SWIG_fail;
38618 }
38619 {
38620 wxSize * resultptr;
38621 resultptr = new wxSize((wxSize &)(result));
38622 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38623 }
38624 return resultobj;
38625 fail:
38626 return NULL;
38627 }
38628
38629
38630 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38631 PyObject *resultobj;
38632 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38633 wxSize result;
38634 PyObject * obj0 = 0 ;
38635 char *kwnames[] = {
38636 (char *) "self", NULL
38637 };
38638
38639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38641 if (SWIG_arg_fail(1)) SWIG_fail;
38642 {
38643 PyThreadState* __tstate = wxPyBeginAllowThreads();
38644 result = (arg1)->CalcMin();
38645
38646 wxPyEndAllowThreads(__tstate);
38647 if (PyErr_Occurred()) SWIG_fail;
38648 }
38649 {
38650 wxSize * resultptr;
38651 resultptr = new wxSize((wxSize &)(result));
38652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38653 }
38654 return resultobj;
38655 fail:
38656 return NULL;
38657 }
38658
38659
38660 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38661 PyObject *resultobj;
38662 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38663 wxPoint arg2 ;
38664 wxSize arg3 ;
38665 PyObject * obj0 = 0 ;
38666 PyObject * obj1 = 0 ;
38667 PyObject * obj2 = 0 ;
38668 char *kwnames[] = {
38669 (char *) "self",(char *) "pos",(char *) "size", NULL
38670 };
38671
38672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38674 if (SWIG_arg_fail(1)) SWIG_fail;
38675 {
38676 wxPoint * argp;
38677 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38678 if (SWIG_arg_fail(2)) SWIG_fail;
38679 if (argp == NULL) {
38680 SWIG_null_ref("wxPoint");
38681 }
38682 if (SWIG_arg_fail(2)) SWIG_fail;
38683 arg2 = *argp;
38684 }
38685 {
38686 wxSize * argp;
38687 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38688 if (SWIG_arg_fail(3)) SWIG_fail;
38689 if (argp == NULL) {
38690 SWIG_null_ref("wxSize");
38691 }
38692 if (SWIG_arg_fail(3)) SWIG_fail;
38693 arg3 = *argp;
38694 }
38695 {
38696 PyThreadState* __tstate = wxPyBeginAllowThreads();
38697 (arg1)->SetDimension(arg2,arg3);
38698
38699 wxPyEndAllowThreads(__tstate);
38700 if (PyErr_Occurred()) SWIG_fail;
38701 }
38702 Py_INCREF(Py_None); resultobj = Py_None;
38703 return resultobj;
38704 fail:
38705 return NULL;
38706 }
38707
38708
38709 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38710 PyObject *resultobj;
38711 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38712 wxSize result;
38713 PyObject * obj0 = 0 ;
38714 char *kwnames[] = {
38715 (char *) "self", NULL
38716 };
38717
38718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38720 if (SWIG_arg_fail(1)) SWIG_fail;
38721 {
38722 PyThreadState* __tstate = wxPyBeginAllowThreads();
38723 result = (arg1)->GetMinSize();
38724
38725 wxPyEndAllowThreads(__tstate);
38726 if (PyErr_Occurred()) SWIG_fail;
38727 }
38728 {
38729 wxSize * resultptr;
38730 resultptr = new wxSize((wxSize &)(result));
38731 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38732 }
38733 return resultobj;
38734 fail:
38735 return NULL;
38736 }
38737
38738
38739 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38740 PyObject *resultobj;
38741 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38742 wxSize result;
38743 PyObject * obj0 = 0 ;
38744 char *kwnames[] = {
38745 (char *) "self", NULL
38746 };
38747
38748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38750 if (SWIG_arg_fail(1)) SWIG_fail;
38751 {
38752 PyThreadState* __tstate = wxPyBeginAllowThreads();
38753 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38754
38755 wxPyEndAllowThreads(__tstate);
38756 if (PyErr_Occurred()) SWIG_fail;
38757 }
38758 {
38759 wxSize * resultptr;
38760 resultptr = new wxSize((wxSize &)(result));
38761 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38762 }
38763 return resultobj;
38764 fail:
38765 return NULL;
38766 }
38767
38768
38769 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38770 PyObject *resultobj;
38771 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38772 int arg2 ;
38773 int arg3 ;
38774 PyObject * obj0 = 0 ;
38775 PyObject * obj1 = 0 ;
38776 PyObject * obj2 = 0 ;
38777 char *kwnames[] = {
38778 (char *) "self",(char *) "x",(char *) "y", NULL
38779 };
38780
38781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38783 if (SWIG_arg_fail(1)) SWIG_fail;
38784 {
38785 arg2 = (int)(SWIG_As_int(obj1));
38786 if (SWIG_arg_fail(2)) SWIG_fail;
38787 }
38788 {
38789 arg3 = (int)(SWIG_As_int(obj2));
38790 if (SWIG_arg_fail(3)) SWIG_fail;
38791 }
38792 {
38793 PyThreadState* __tstate = wxPyBeginAllowThreads();
38794 (arg1)->SetInitSize(arg2,arg3);
38795
38796 wxPyEndAllowThreads(__tstate);
38797 if (PyErr_Occurred()) SWIG_fail;
38798 }
38799 Py_INCREF(Py_None); resultobj = Py_None;
38800 return resultobj;
38801 fail:
38802 return NULL;
38803 }
38804
38805
38806 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38807 PyObject *resultobj;
38808 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38809 int arg2 ;
38810 int arg3 ;
38811 PyObject * obj0 = 0 ;
38812 PyObject * obj1 = 0 ;
38813 PyObject * obj2 = 0 ;
38814 char *kwnames[] = {
38815 (char *) "self",(char *) "width",(char *) "height", NULL
38816 };
38817
38818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38820 if (SWIG_arg_fail(1)) SWIG_fail;
38821 {
38822 arg2 = (int)(SWIG_As_int(obj1));
38823 if (SWIG_arg_fail(2)) SWIG_fail;
38824 }
38825 {
38826 arg3 = (int)(SWIG_As_int(obj2));
38827 if (SWIG_arg_fail(3)) SWIG_fail;
38828 }
38829 {
38830 PyThreadState* __tstate = wxPyBeginAllowThreads();
38831 (arg1)->SetRatio(arg2,arg3);
38832
38833 wxPyEndAllowThreads(__tstate);
38834 if (PyErr_Occurred()) SWIG_fail;
38835 }
38836 Py_INCREF(Py_None); resultobj = Py_None;
38837 return resultobj;
38838 fail:
38839 return NULL;
38840 }
38841
38842
38843 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38844 PyObject *resultobj;
38845 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38846 wxSize *arg2 = 0 ;
38847 wxSize temp2 ;
38848 PyObject * obj0 = 0 ;
38849 PyObject * obj1 = 0 ;
38850 char *kwnames[] = {
38851 (char *) "self",(char *) "size", NULL
38852 };
38853
38854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38856 if (SWIG_arg_fail(1)) SWIG_fail;
38857 {
38858 arg2 = &temp2;
38859 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38860 }
38861 {
38862 PyThreadState* __tstate = wxPyBeginAllowThreads();
38863 (arg1)->SetRatio((wxSize const &)*arg2);
38864
38865 wxPyEndAllowThreads(__tstate);
38866 if (PyErr_Occurred()) SWIG_fail;
38867 }
38868 Py_INCREF(Py_None); resultobj = Py_None;
38869 return resultobj;
38870 fail:
38871 return NULL;
38872 }
38873
38874
38875 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38876 PyObject *resultobj;
38877 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38878 float arg2 ;
38879 PyObject * obj0 = 0 ;
38880 PyObject * obj1 = 0 ;
38881 char *kwnames[] = {
38882 (char *) "self",(char *) "ratio", NULL
38883 };
38884
38885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38887 if (SWIG_arg_fail(1)) SWIG_fail;
38888 {
38889 arg2 = (float)(SWIG_As_float(obj1));
38890 if (SWIG_arg_fail(2)) SWIG_fail;
38891 }
38892 {
38893 PyThreadState* __tstate = wxPyBeginAllowThreads();
38894 (arg1)->SetRatio(arg2);
38895
38896 wxPyEndAllowThreads(__tstate);
38897 if (PyErr_Occurred()) SWIG_fail;
38898 }
38899 Py_INCREF(Py_None); resultobj = Py_None;
38900 return resultobj;
38901 fail:
38902 return NULL;
38903 }
38904
38905
38906 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38907 PyObject *resultobj;
38908 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38909 float result;
38910 PyObject * obj0 = 0 ;
38911 char *kwnames[] = {
38912 (char *) "self", NULL
38913 };
38914
38915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38917 if (SWIG_arg_fail(1)) SWIG_fail;
38918 {
38919 PyThreadState* __tstate = wxPyBeginAllowThreads();
38920 result = (float)(arg1)->GetRatio();
38921
38922 wxPyEndAllowThreads(__tstate);
38923 if (PyErr_Occurred()) SWIG_fail;
38924 }
38925 {
38926 resultobj = SWIG_From_float((float)(result));
38927 }
38928 return resultobj;
38929 fail:
38930 return NULL;
38931 }
38932
38933
38934 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38935 PyObject *resultobj;
38936 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38937 wxRect result;
38938 PyObject * obj0 = 0 ;
38939 char *kwnames[] = {
38940 (char *) "self", NULL
38941 };
38942
38943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38945 if (SWIG_arg_fail(1)) SWIG_fail;
38946 {
38947 PyThreadState* __tstate = wxPyBeginAllowThreads();
38948 result = (arg1)->GetRect();
38949
38950 wxPyEndAllowThreads(__tstate);
38951 if (PyErr_Occurred()) SWIG_fail;
38952 }
38953 {
38954 wxRect * resultptr;
38955 resultptr = new wxRect((wxRect &)(result));
38956 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38957 }
38958 return resultobj;
38959 fail:
38960 return NULL;
38961 }
38962
38963
38964 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38965 PyObject *resultobj;
38966 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38967 bool result;
38968 PyObject * obj0 = 0 ;
38969 char *kwnames[] = {
38970 (char *) "self", NULL
38971 };
38972
38973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38975 if (SWIG_arg_fail(1)) SWIG_fail;
38976 {
38977 PyThreadState* __tstate = wxPyBeginAllowThreads();
38978 result = (bool)(arg1)->IsWindow();
38979
38980 wxPyEndAllowThreads(__tstate);
38981 if (PyErr_Occurred()) SWIG_fail;
38982 }
38983 {
38984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38985 }
38986 return resultobj;
38987 fail:
38988 return NULL;
38989 }
38990
38991
38992 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38993 PyObject *resultobj;
38994 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38995 bool result;
38996 PyObject * obj0 = 0 ;
38997 char *kwnames[] = {
38998 (char *) "self", NULL
38999 };
39000
39001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39003 if (SWIG_arg_fail(1)) SWIG_fail;
39004 {
39005 PyThreadState* __tstate = wxPyBeginAllowThreads();
39006 result = (bool)(arg1)->IsSizer();
39007
39008 wxPyEndAllowThreads(__tstate);
39009 if (PyErr_Occurred()) SWIG_fail;
39010 }
39011 {
39012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39013 }
39014 return resultobj;
39015 fail:
39016 return NULL;
39017 }
39018
39019
39020 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39021 PyObject *resultobj;
39022 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39023 bool result;
39024 PyObject * obj0 = 0 ;
39025 char *kwnames[] = {
39026 (char *) "self", NULL
39027 };
39028
39029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39031 if (SWIG_arg_fail(1)) SWIG_fail;
39032 {
39033 PyThreadState* __tstate = wxPyBeginAllowThreads();
39034 result = (bool)(arg1)->IsSpacer();
39035
39036 wxPyEndAllowThreads(__tstate);
39037 if (PyErr_Occurred()) SWIG_fail;
39038 }
39039 {
39040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39041 }
39042 return resultobj;
39043 fail:
39044 return NULL;
39045 }
39046
39047
39048 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39049 PyObject *resultobj;
39050 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39051 int arg2 ;
39052 PyObject * obj0 = 0 ;
39053 PyObject * obj1 = 0 ;
39054 char *kwnames[] = {
39055 (char *) "self",(char *) "proportion", NULL
39056 };
39057
39058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39060 if (SWIG_arg_fail(1)) SWIG_fail;
39061 {
39062 arg2 = (int)(SWIG_As_int(obj1));
39063 if (SWIG_arg_fail(2)) SWIG_fail;
39064 }
39065 {
39066 PyThreadState* __tstate = wxPyBeginAllowThreads();
39067 (arg1)->SetProportion(arg2);
39068
39069 wxPyEndAllowThreads(__tstate);
39070 if (PyErr_Occurred()) SWIG_fail;
39071 }
39072 Py_INCREF(Py_None); resultobj = Py_None;
39073 return resultobj;
39074 fail:
39075 return NULL;
39076 }
39077
39078
39079 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39080 PyObject *resultobj;
39081 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39082 int result;
39083 PyObject * obj0 = 0 ;
39084 char *kwnames[] = {
39085 (char *) "self", NULL
39086 };
39087
39088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39090 if (SWIG_arg_fail(1)) SWIG_fail;
39091 {
39092 PyThreadState* __tstate = wxPyBeginAllowThreads();
39093 result = (int)(arg1)->GetProportion();
39094
39095 wxPyEndAllowThreads(__tstate);
39096 if (PyErr_Occurred()) SWIG_fail;
39097 }
39098 {
39099 resultobj = SWIG_From_int((int)(result));
39100 }
39101 return resultobj;
39102 fail:
39103 return NULL;
39104 }
39105
39106
39107 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39108 PyObject *resultobj;
39109 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39110 int arg2 ;
39111 PyObject * obj0 = 0 ;
39112 PyObject * obj1 = 0 ;
39113 char *kwnames[] = {
39114 (char *) "self",(char *) "flag", NULL
39115 };
39116
39117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39119 if (SWIG_arg_fail(1)) SWIG_fail;
39120 {
39121 arg2 = (int)(SWIG_As_int(obj1));
39122 if (SWIG_arg_fail(2)) SWIG_fail;
39123 }
39124 {
39125 PyThreadState* __tstate = wxPyBeginAllowThreads();
39126 (arg1)->SetFlag(arg2);
39127
39128 wxPyEndAllowThreads(__tstate);
39129 if (PyErr_Occurred()) SWIG_fail;
39130 }
39131 Py_INCREF(Py_None); resultobj = Py_None;
39132 return resultobj;
39133 fail:
39134 return NULL;
39135 }
39136
39137
39138 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39139 PyObject *resultobj;
39140 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39141 int result;
39142 PyObject * obj0 = 0 ;
39143 char *kwnames[] = {
39144 (char *) "self", NULL
39145 };
39146
39147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39149 if (SWIG_arg_fail(1)) SWIG_fail;
39150 {
39151 PyThreadState* __tstate = wxPyBeginAllowThreads();
39152 result = (int)(arg1)->GetFlag();
39153
39154 wxPyEndAllowThreads(__tstate);
39155 if (PyErr_Occurred()) SWIG_fail;
39156 }
39157 {
39158 resultobj = SWIG_From_int((int)(result));
39159 }
39160 return resultobj;
39161 fail:
39162 return NULL;
39163 }
39164
39165
39166 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39167 PyObject *resultobj;
39168 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39169 int arg2 ;
39170 PyObject * obj0 = 0 ;
39171 PyObject * obj1 = 0 ;
39172 char *kwnames[] = {
39173 (char *) "self",(char *) "border", NULL
39174 };
39175
39176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39178 if (SWIG_arg_fail(1)) SWIG_fail;
39179 {
39180 arg2 = (int)(SWIG_As_int(obj1));
39181 if (SWIG_arg_fail(2)) SWIG_fail;
39182 }
39183 {
39184 PyThreadState* __tstate = wxPyBeginAllowThreads();
39185 (arg1)->SetBorder(arg2);
39186
39187 wxPyEndAllowThreads(__tstate);
39188 if (PyErr_Occurred()) SWIG_fail;
39189 }
39190 Py_INCREF(Py_None); resultobj = Py_None;
39191 return resultobj;
39192 fail:
39193 return NULL;
39194 }
39195
39196
39197 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39198 PyObject *resultobj;
39199 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39200 int result;
39201 PyObject * obj0 = 0 ;
39202 char *kwnames[] = {
39203 (char *) "self", NULL
39204 };
39205
39206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39208 if (SWIG_arg_fail(1)) SWIG_fail;
39209 {
39210 PyThreadState* __tstate = wxPyBeginAllowThreads();
39211 result = (int)(arg1)->GetBorder();
39212
39213 wxPyEndAllowThreads(__tstate);
39214 if (PyErr_Occurred()) SWIG_fail;
39215 }
39216 {
39217 resultobj = SWIG_From_int((int)(result));
39218 }
39219 return resultobj;
39220 fail:
39221 return NULL;
39222 }
39223
39224
39225 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39226 PyObject *resultobj;
39227 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39228 wxWindow *result;
39229 PyObject * obj0 = 0 ;
39230 char *kwnames[] = {
39231 (char *) "self", NULL
39232 };
39233
39234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39236 if (SWIG_arg_fail(1)) SWIG_fail;
39237 {
39238 PyThreadState* __tstate = wxPyBeginAllowThreads();
39239 result = (wxWindow *)(arg1)->GetWindow();
39240
39241 wxPyEndAllowThreads(__tstate);
39242 if (PyErr_Occurred()) SWIG_fail;
39243 }
39244 {
39245 resultobj = wxPyMake_wxObject(result, 0);
39246 }
39247 return resultobj;
39248 fail:
39249 return NULL;
39250 }
39251
39252
39253 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39254 PyObject *resultobj;
39255 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39256 wxWindow *arg2 = (wxWindow *) 0 ;
39257 PyObject * obj0 = 0 ;
39258 PyObject * obj1 = 0 ;
39259 char *kwnames[] = {
39260 (char *) "self",(char *) "window", NULL
39261 };
39262
39263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39265 if (SWIG_arg_fail(1)) SWIG_fail;
39266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39267 if (SWIG_arg_fail(2)) SWIG_fail;
39268 {
39269 PyThreadState* __tstate = wxPyBeginAllowThreads();
39270 (arg1)->SetWindow(arg2);
39271
39272 wxPyEndAllowThreads(__tstate);
39273 if (PyErr_Occurred()) SWIG_fail;
39274 }
39275 Py_INCREF(Py_None); resultobj = Py_None;
39276 return resultobj;
39277 fail:
39278 return NULL;
39279 }
39280
39281
39282 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39283 PyObject *resultobj;
39284 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39285 wxSizer *result;
39286 PyObject * obj0 = 0 ;
39287 char *kwnames[] = {
39288 (char *) "self", NULL
39289 };
39290
39291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39293 if (SWIG_arg_fail(1)) SWIG_fail;
39294 {
39295 PyThreadState* __tstate = wxPyBeginAllowThreads();
39296 result = (wxSizer *)(arg1)->GetSizer();
39297
39298 wxPyEndAllowThreads(__tstate);
39299 if (PyErr_Occurred()) SWIG_fail;
39300 }
39301 {
39302 resultobj = wxPyMake_wxSizer(result, 0);
39303 }
39304 return resultobj;
39305 fail:
39306 return NULL;
39307 }
39308
39309
39310 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39311 PyObject *resultobj;
39312 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39313 wxSizer *arg2 = (wxSizer *) 0 ;
39314 PyObject * obj0 = 0 ;
39315 PyObject * obj1 = 0 ;
39316 char *kwnames[] = {
39317 (char *) "self",(char *) "sizer", NULL
39318 };
39319
39320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39322 if (SWIG_arg_fail(1)) SWIG_fail;
39323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39324 if (SWIG_arg_fail(2)) SWIG_fail;
39325 {
39326 PyThreadState* __tstate = wxPyBeginAllowThreads();
39327 (arg1)->SetSizer(arg2);
39328
39329 wxPyEndAllowThreads(__tstate);
39330 if (PyErr_Occurred()) SWIG_fail;
39331 }
39332 Py_INCREF(Py_None); resultobj = Py_None;
39333 return resultobj;
39334 fail:
39335 return NULL;
39336 }
39337
39338
39339 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39340 PyObject *resultobj;
39341 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39342 wxSize *result;
39343 PyObject * obj0 = 0 ;
39344 char *kwnames[] = {
39345 (char *) "self", NULL
39346 };
39347
39348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39350 if (SWIG_arg_fail(1)) SWIG_fail;
39351 {
39352 PyThreadState* __tstate = wxPyBeginAllowThreads();
39353 {
39354 wxSize const &_result_ref = (arg1)->GetSpacer();
39355 result = (wxSize *) &_result_ref;
39356 }
39357
39358 wxPyEndAllowThreads(__tstate);
39359 if (PyErr_Occurred()) SWIG_fail;
39360 }
39361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39362 return resultobj;
39363 fail:
39364 return NULL;
39365 }
39366
39367
39368 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39369 PyObject *resultobj;
39370 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39371 wxSize *arg2 = 0 ;
39372 wxSize temp2 ;
39373 PyObject * obj0 = 0 ;
39374 PyObject * obj1 = 0 ;
39375 char *kwnames[] = {
39376 (char *) "self",(char *) "size", NULL
39377 };
39378
39379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39381 if (SWIG_arg_fail(1)) SWIG_fail;
39382 {
39383 arg2 = &temp2;
39384 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39385 }
39386 {
39387 PyThreadState* __tstate = wxPyBeginAllowThreads();
39388 (arg1)->SetSpacer((wxSize const &)*arg2);
39389
39390 wxPyEndAllowThreads(__tstate);
39391 if (PyErr_Occurred()) SWIG_fail;
39392 }
39393 Py_INCREF(Py_None); resultobj = Py_None;
39394 return resultobj;
39395 fail:
39396 return NULL;
39397 }
39398
39399
39400 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39401 PyObject *resultobj;
39402 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39403 bool arg2 ;
39404 PyObject * obj0 = 0 ;
39405 PyObject * obj1 = 0 ;
39406 char *kwnames[] = {
39407 (char *) "self",(char *) "show", NULL
39408 };
39409
39410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39412 if (SWIG_arg_fail(1)) SWIG_fail;
39413 {
39414 arg2 = (bool)(SWIG_As_bool(obj1));
39415 if (SWIG_arg_fail(2)) SWIG_fail;
39416 }
39417 {
39418 PyThreadState* __tstate = wxPyBeginAllowThreads();
39419 (arg1)->Show(arg2);
39420
39421 wxPyEndAllowThreads(__tstate);
39422 if (PyErr_Occurred()) SWIG_fail;
39423 }
39424 Py_INCREF(Py_None); resultobj = Py_None;
39425 return resultobj;
39426 fail:
39427 return NULL;
39428 }
39429
39430
39431 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39432 PyObject *resultobj;
39433 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39434 bool result;
39435 PyObject * obj0 = 0 ;
39436 char *kwnames[] = {
39437 (char *) "self", NULL
39438 };
39439
39440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39442 if (SWIG_arg_fail(1)) SWIG_fail;
39443 {
39444 PyThreadState* __tstate = wxPyBeginAllowThreads();
39445 result = (bool)(arg1)->IsShown();
39446
39447 wxPyEndAllowThreads(__tstate);
39448 if (PyErr_Occurred()) SWIG_fail;
39449 }
39450 {
39451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39452 }
39453 return resultobj;
39454 fail:
39455 return NULL;
39456 }
39457
39458
39459 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39460 PyObject *resultobj;
39461 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39462 wxPoint result;
39463 PyObject * obj0 = 0 ;
39464 char *kwnames[] = {
39465 (char *) "self", NULL
39466 };
39467
39468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39470 if (SWIG_arg_fail(1)) SWIG_fail;
39471 {
39472 PyThreadState* __tstate = wxPyBeginAllowThreads();
39473 result = (arg1)->GetPosition();
39474
39475 wxPyEndAllowThreads(__tstate);
39476 if (PyErr_Occurred()) SWIG_fail;
39477 }
39478 {
39479 wxPoint * resultptr;
39480 resultptr = new wxPoint((wxPoint &)(result));
39481 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39482 }
39483 return resultobj;
39484 fail:
39485 return NULL;
39486 }
39487
39488
39489 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39490 PyObject *resultobj;
39491 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39492 PyObject *result;
39493 PyObject * obj0 = 0 ;
39494 char *kwnames[] = {
39495 (char *) "self", NULL
39496 };
39497
39498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39500 if (SWIG_arg_fail(1)) SWIG_fail;
39501 {
39502 PyThreadState* __tstate = wxPyBeginAllowThreads();
39503 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39504
39505 wxPyEndAllowThreads(__tstate);
39506 if (PyErr_Occurred()) SWIG_fail;
39507 }
39508 resultobj = result;
39509 return resultobj;
39510 fail:
39511 return NULL;
39512 }
39513
39514
39515 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39516 PyObject *obj;
39517 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39518 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39519 Py_INCREF(obj);
39520 return Py_BuildValue((char *)"");
39521 }
39522 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39523 PyObject *resultobj;
39524 wxSizer *arg1 = (wxSizer *) 0 ;
39525 PyObject *arg2 = (PyObject *) 0 ;
39526 PyObject * obj0 = 0 ;
39527 PyObject * obj1 = 0 ;
39528 char *kwnames[] = {
39529 (char *) "self",(char *) "_self", NULL
39530 };
39531
39532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39534 if (SWIG_arg_fail(1)) SWIG_fail;
39535 arg2 = obj1;
39536 {
39537 PyThreadState* __tstate = wxPyBeginAllowThreads();
39538 wxSizer__setOORInfo(arg1,arg2);
39539
39540 wxPyEndAllowThreads(__tstate);
39541 if (PyErr_Occurred()) SWIG_fail;
39542 }
39543 Py_INCREF(Py_None); resultobj = Py_None;
39544 return resultobj;
39545 fail:
39546 return NULL;
39547 }
39548
39549
39550 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39551 PyObject *resultobj;
39552 wxSizer *arg1 = (wxSizer *) 0 ;
39553 PyObject *arg2 = (PyObject *) 0 ;
39554 int arg3 = (int) 0 ;
39555 int arg4 = (int) 0 ;
39556 int arg5 = (int) 0 ;
39557 PyObject *arg6 = (PyObject *) NULL ;
39558 wxSizerItem *result;
39559 PyObject * obj0 = 0 ;
39560 PyObject * obj1 = 0 ;
39561 PyObject * obj2 = 0 ;
39562 PyObject * obj3 = 0 ;
39563 PyObject * obj4 = 0 ;
39564 PyObject * obj5 = 0 ;
39565 char *kwnames[] = {
39566 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39567 };
39568
39569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39571 if (SWIG_arg_fail(1)) SWIG_fail;
39572 arg2 = obj1;
39573 if (obj2) {
39574 {
39575 arg3 = (int)(SWIG_As_int(obj2));
39576 if (SWIG_arg_fail(3)) SWIG_fail;
39577 }
39578 }
39579 if (obj3) {
39580 {
39581 arg4 = (int)(SWIG_As_int(obj3));
39582 if (SWIG_arg_fail(4)) SWIG_fail;
39583 }
39584 }
39585 if (obj4) {
39586 {
39587 arg5 = (int)(SWIG_As_int(obj4));
39588 if (SWIG_arg_fail(5)) SWIG_fail;
39589 }
39590 }
39591 if (obj5) {
39592 arg6 = obj5;
39593 }
39594 {
39595 PyThreadState* __tstate = wxPyBeginAllowThreads();
39596 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39597
39598 wxPyEndAllowThreads(__tstate);
39599 if (PyErr_Occurred()) SWIG_fail;
39600 }
39601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39602 return resultobj;
39603 fail:
39604 return NULL;
39605 }
39606
39607
39608 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39609 PyObject *resultobj;
39610 wxSizer *arg1 = (wxSizer *) 0 ;
39611 int arg2 ;
39612 PyObject *arg3 = (PyObject *) 0 ;
39613 int arg4 = (int) 0 ;
39614 int arg5 = (int) 0 ;
39615 int arg6 = (int) 0 ;
39616 PyObject *arg7 = (PyObject *) NULL ;
39617 wxSizerItem *result;
39618 PyObject * obj0 = 0 ;
39619 PyObject * obj1 = 0 ;
39620 PyObject * obj2 = 0 ;
39621 PyObject * obj3 = 0 ;
39622 PyObject * obj4 = 0 ;
39623 PyObject * obj5 = 0 ;
39624 PyObject * obj6 = 0 ;
39625 char *kwnames[] = {
39626 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39627 };
39628
39629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39631 if (SWIG_arg_fail(1)) SWIG_fail;
39632 {
39633 arg2 = (int)(SWIG_As_int(obj1));
39634 if (SWIG_arg_fail(2)) SWIG_fail;
39635 }
39636 arg3 = obj2;
39637 if (obj3) {
39638 {
39639 arg4 = (int)(SWIG_As_int(obj3));
39640 if (SWIG_arg_fail(4)) SWIG_fail;
39641 }
39642 }
39643 if (obj4) {
39644 {
39645 arg5 = (int)(SWIG_As_int(obj4));
39646 if (SWIG_arg_fail(5)) SWIG_fail;
39647 }
39648 }
39649 if (obj5) {
39650 {
39651 arg6 = (int)(SWIG_As_int(obj5));
39652 if (SWIG_arg_fail(6)) SWIG_fail;
39653 }
39654 }
39655 if (obj6) {
39656 arg7 = obj6;
39657 }
39658 {
39659 PyThreadState* __tstate = wxPyBeginAllowThreads();
39660 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39661
39662 wxPyEndAllowThreads(__tstate);
39663 if (PyErr_Occurred()) SWIG_fail;
39664 }
39665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39666 return resultobj;
39667 fail:
39668 return NULL;
39669 }
39670
39671
39672 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39673 PyObject *resultobj;
39674 wxSizer *arg1 = (wxSizer *) 0 ;
39675 PyObject *arg2 = (PyObject *) 0 ;
39676 int arg3 = (int) 0 ;
39677 int arg4 = (int) 0 ;
39678 int arg5 = (int) 0 ;
39679 PyObject *arg6 = (PyObject *) NULL ;
39680 wxSizerItem *result;
39681 PyObject * obj0 = 0 ;
39682 PyObject * obj1 = 0 ;
39683 PyObject * obj2 = 0 ;
39684 PyObject * obj3 = 0 ;
39685 PyObject * obj4 = 0 ;
39686 PyObject * obj5 = 0 ;
39687 char *kwnames[] = {
39688 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39689 };
39690
39691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39693 if (SWIG_arg_fail(1)) SWIG_fail;
39694 arg2 = obj1;
39695 if (obj2) {
39696 {
39697 arg3 = (int)(SWIG_As_int(obj2));
39698 if (SWIG_arg_fail(3)) SWIG_fail;
39699 }
39700 }
39701 if (obj3) {
39702 {
39703 arg4 = (int)(SWIG_As_int(obj3));
39704 if (SWIG_arg_fail(4)) SWIG_fail;
39705 }
39706 }
39707 if (obj4) {
39708 {
39709 arg5 = (int)(SWIG_As_int(obj4));
39710 if (SWIG_arg_fail(5)) SWIG_fail;
39711 }
39712 }
39713 if (obj5) {
39714 arg6 = obj5;
39715 }
39716 {
39717 PyThreadState* __tstate = wxPyBeginAllowThreads();
39718 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39719
39720 wxPyEndAllowThreads(__tstate);
39721 if (PyErr_Occurred()) SWIG_fail;
39722 }
39723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39724 return resultobj;
39725 fail:
39726 return NULL;
39727 }
39728
39729
39730 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39731 PyObject *resultobj;
39732 wxSizer *arg1 = (wxSizer *) 0 ;
39733 PyObject *arg2 = (PyObject *) 0 ;
39734 bool result;
39735 PyObject * obj0 = 0 ;
39736 PyObject * obj1 = 0 ;
39737 char *kwnames[] = {
39738 (char *) "self",(char *) "item", NULL
39739 };
39740
39741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39743 if (SWIG_arg_fail(1)) SWIG_fail;
39744 arg2 = obj1;
39745 {
39746 PyThreadState* __tstate = wxPyBeginAllowThreads();
39747 result = (bool)wxSizer_Remove(arg1,arg2);
39748
39749 wxPyEndAllowThreads(__tstate);
39750 if (PyErr_Occurred()) SWIG_fail;
39751 }
39752 {
39753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39754 }
39755 return resultobj;
39756 fail:
39757 return NULL;
39758 }
39759
39760
39761 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39762 PyObject *resultobj;
39763 wxSizer *arg1 = (wxSizer *) 0 ;
39764 PyObject *arg2 = (PyObject *) 0 ;
39765 bool result;
39766 PyObject * obj0 = 0 ;
39767 PyObject * obj1 = 0 ;
39768 char *kwnames[] = {
39769 (char *) "self",(char *) "item", NULL
39770 };
39771
39772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39774 if (SWIG_arg_fail(1)) SWIG_fail;
39775 arg2 = obj1;
39776 {
39777 PyThreadState* __tstate = wxPyBeginAllowThreads();
39778 result = (bool)wxSizer_Detach(arg1,arg2);
39779
39780 wxPyEndAllowThreads(__tstate);
39781 if (PyErr_Occurred()) SWIG_fail;
39782 }
39783 {
39784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39785 }
39786 return resultobj;
39787 fail:
39788 return NULL;
39789 }
39790
39791
39792 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39793 PyObject *resultobj;
39794 wxSizer *arg1 = (wxSizer *) 0 ;
39795 PyObject *arg2 = (PyObject *) 0 ;
39796 wxSizerItem *result;
39797 PyObject * obj0 = 0 ;
39798 PyObject * obj1 = 0 ;
39799 char *kwnames[] = {
39800 (char *) "self",(char *) "item", NULL
39801 };
39802
39803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39805 if (SWIG_arg_fail(1)) SWIG_fail;
39806 arg2 = obj1;
39807 {
39808 PyThreadState* __tstate = wxPyBeginAllowThreads();
39809 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39810
39811 wxPyEndAllowThreads(__tstate);
39812 if (PyErr_Occurred()) SWIG_fail;
39813 }
39814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39815 return resultobj;
39816 fail:
39817 return NULL;
39818 }
39819
39820
39821 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39822 PyObject *resultobj;
39823 wxSizer *arg1 = (wxSizer *) 0 ;
39824 PyObject *arg2 = (PyObject *) 0 ;
39825 wxSize *arg3 = 0 ;
39826 wxSize temp3 ;
39827 PyObject * obj0 = 0 ;
39828 PyObject * obj1 = 0 ;
39829 PyObject * obj2 = 0 ;
39830 char *kwnames[] = {
39831 (char *) "self",(char *) "item",(char *) "size", NULL
39832 };
39833
39834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39836 if (SWIG_arg_fail(1)) SWIG_fail;
39837 arg2 = obj1;
39838 {
39839 arg3 = &temp3;
39840 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39841 }
39842 {
39843 PyThreadState* __tstate = wxPyBeginAllowThreads();
39844 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39845
39846 wxPyEndAllowThreads(__tstate);
39847 if (PyErr_Occurred()) SWIG_fail;
39848 }
39849 Py_INCREF(Py_None); resultobj = Py_None;
39850 return resultobj;
39851 fail:
39852 return NULL;
39853 }
39854
39855
39856 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39857 PyObject *resultobj;
39858 wxSizer *arg1 = (wxSizer *) 0 ;
39859 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39860 wxSizerItem *result;
39861 PyObject * obj0 = 0 ;
39862 PyObject * obj1 = 0 ;
39863 char *kwnames[] = {
39864 (char *) "self",(char *) "item", NULL
39865 };
39866
39867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39869 if (SWIG_arg_fail(1)) SWIG_fail;
39870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39871 if (SWIG_arg_fail(2)) SWIG_fail;
39872 {
39873 PyThreadState* __tstate = wxPyBeginAllowThreads();
39874 result = (wxSizerItem *)(arg1)->Add(arg2);
39875
39876 wxPyEndAllowThreads(__tstate);
39877 if (PyErr_Occurred()) SWIG_fail;
39878 }
39879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39880 return resultobj;
39881 fail:
39882 return NULL;
39883 }
39884
39885
39886 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39887 PyObject *resultobj;
39888 wxSizer *arg1 = (wxSizer *) 0 ;
39889 size_t arg2 ;
39890 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39891 wxSizerItem *result;
39892 PyObject * obj0 = 0 ;
39893 PyObject * obj1 = 0 ;
39894 PyObject * obj2 = 0 ;
39895 char *kwnames[] = {
39896 (char *) "self",(char *) "index",(char *) "item", NULL
39897 };
39898
39899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39901 if (SWIG_arg_fail(1)) SWIG_fail;
39902 {
39903 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39904 if (SWIG_arg_fail(2)) SWIG_fail;
39905 }
39906 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39907 if (SWIG_arg_fail(3)) SWIG_fail;
39908 {
39909 PyThreadState* __tstate = wxPyBeginAllowThreads();
39910 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39911
39912 wxPyEndAllowThreads(__tstate);
39913 if (PyErr_Occurred()) SWIG_fail;
39914 }
39915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39916 return resultobj;
39917 fail:
39918 return NULL;
39919 }
39920
39921
39922 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39923 PyObject *resultobj;
39924 wxSizer *arg1 = (wxSizer *) 0 ;
39925 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39926 wxSizerItem *result;
39927 PyObject * obj0 = 0 ;
39928 PyObject * obj1 = 0 ;
39929 char *kwnames[] = {
39930 (char *) "self",(char *) "item", NULL
39931 };
39932
39933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39935 if (SWIG_arg_fail(1)) SWIG_fail;
39936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39937 if (SWIG_arg_fail(2)) SWIG_fail;
39938 {
39939 PyThreadState* __tstate = wxPyBeginAllowThreads();
39940 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39941
39942 wxPyEndAllowThreads(__tstate);
39943 if (PyErr_Occurred()) SWIG_fail;
39944 }
39945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39946 return resultobj;
39947 fail:
39948 return NULL;
39949 }
39950
39951
39952 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39953 PyObject *resultobj;
39954 wxSizer *arg1 = (wxSizer *) 0 ;
39955 int arg2 ;
39956 int arg3 ;
39957 int arg4 ;
39958 int arg5 ;
39959 PyObject * obj0 = 0 ;
39960 PyObject * obj1 = 0 ;
39961 PyObject * obj2 = 0 ;
39962 PyObject * obj3 = 0 ;
39963 PyObject * obj4 = 0 ;
39964 char *kwnames[] = {
39965 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39966 };
39967
39968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39970 if (SWIG_arg_fail(1)) SWIG_fail;
39971 {
39972 arg2 = (int)(SWIG_As_int(obj1));
39973 if (SWIG_arg_fail(2)) SWIG_fail;
39974 }
39975 {
39976 arg3 = (int)(SWIG_As_int(obj2));
39977 if (SWIG_arg_fail(3)) SWIG_fail;
39978 }
39979 {
39980 arg4 = (int)(SWIG_As_int(obj3));
39981 if (SWIG_arg_fail(4)) SWIG_fail;
39982 }
39983 {
39984 arg5 = (int)(SWIG_As_int(obj4));
39985 if (SWIG_arg_fail(5)) SWIG_fail;
39986 }
39987 {
39988 PyThreadState* __tstate = wxPyBeginAllowThreads();
39989 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39990
39991 wxPyEndAllowThreads(__tstate);
39992 if (PyErr_Occurred()) SWIG_fail;
39993 }
39994 Py_INCREF(Py_None); resultobj = Py_None;
39995 return resultobj;
39996 fail:
39997 return NULL;
39998 }
39999
40000
40001 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40002 PyObject *resultobj;
40003 wxSizer *arg1 = (wxSizer *) 0 ;
40004 wxSize *arg2 = 0 ;
40005 wxSize temp2 ;
40006 PyObject * obj0 = 0 ;
40007 PyObject * obj1 = 0 ;
40008 char *kwnames[] = {
40009 (char *) "self",(char *) "size", NULL
40010 };
40011
40012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40014 if (SWIG_arg_fail(1)) SWIG_fail;
40015 {
40016 arg2 = &temp2;
40017 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40018 }
40019 {
40020 PyThreadState* __tstate = wxPyBeginAllowThreads();
40021 (arg1)->SetMinSize((wxSize const &)*arg2);
40022
40023 wxPyEndAllowThreads(__tstate);
40024 if (PyErr_Occurred()) SWIG_fail;
40025 }
40026 Py_INCREF(Py_None); resultobj = Py_None;
40027 return resultobj;
40028 fail:
40029 return NULL;
40030 }
40031
40032
40033 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40034 PyObject *resultobj;
40035 wxSizer *arg1 = (wxSizer *) 0 ;
40036 wxSize result;
40037 PyObject * obj0 = 0 ;
40038 char *kwnames[] = {
40039 (char *) "self", NULL
40040 };
40041
40042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40044 if (SWIG_arg_fail(1)) SWIG_fail;
40045 {
40046 PyThreadState* __tstate = wxPyBeginAllowThreads();
40047 result = (arg1)->GetSize();
40048
40049 wxPyEndAllowThreads(__tstate);
40050 if (PyErr_Occurred()) SWIG_fail;
40051 }
40052 {
40053 wxSize * resultptr;
40054 resultptr = new wxSize((wxSize &)(result));
40055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40056 }
40057 return resultobj;
40058 fail:
40059 return NULL;
40060 }
40061
40062
40063 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40064 PyObject *resultobj;
40065 wxSizer *arg1 = (wxSizer *) 0 ;
40066 wxPoint result;
40067 PyObject * obj0 = 0 ;
40068 char *kwnames[] = {
40069 (char *) "self", NULL
40070 };
40071
40072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40074 if (SWIG_arg_fail(1)) SWIG_fail;
40075 {
40076 PyThreadState* __tstate = wxPyBeginAllowThreads();
40077 result = (arg1)->GetPosition();
40078
40079 wxPyEndAllowThreads(__tstate);
40080 if (PyErr_Occurred()) SWIG_fail;
40081 }
40082 {
40083 wxPoint * resultptr;
40084 resultptr = new wxPoint((wxPoint &)(result));
40085 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40086 }
40087 return resultobj;
40088 fail:
40089 return NULL;
40090 }
40091
40092
40093 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40094 PyObject *resultobj;
40095 wxSizer *arg1 = (wxSizer *) 0 ;
40096 wxSize result;
40097 PyObject * obj0 = 0 ;
40098 char *kwnames[] = {
40099 (char *) "self", NULL
40100 };
40101
40102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40104 if (SWIG_arg_fail(1)) SWIG_fail;
40105 {
40106 PyThreadState* __tstate = wxPyBeginAllowThreads();
40107 result = (arg1)->GetMinSize();
40108
40109 wxPyEndAllowThreads(__tstate);
40110 if (PyErr_Occurred()) SWIG_fail;
40111 }
40112 {
40113 wxSize * resultptr;
40114 resultptr = new wxSize((wxSize &)(result));
40115 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40116 }
40117 return resultobj;
40118 fail:
40119 return NULL;
40120 }
40121
40122
40123 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40124 PyObject *resultobj;
40125 wxSizer *arg1 = (wxSizer *) 0 ;
40126 PyObject * obj0 = 0 ;
40127 char *kwnames[] = {
40128 (char *) "self", NULL
40129 };
40130
40131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40133 if (SWIG_arg_fail(1)) SWIG_fail;
40134 {
40135 PyThreadState* __tstate = wxPyBeginAllowThreads();
40136 (arg1)->RecalcSizes();
40137
40138 wxPyEndAllowThreads(__tstate);
40139 if (PyErr_Occurred()) SWIG_fail;
40140 }
40141 Py_INCREF(Py_None); resultobj = Py_None;
40142 return resultobj;
40143 fail:
40144 return NULL;
40145 }
40146
40147
40148 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40149 PyObject *resultobj;
40150 wxSizer *arg1 = (wxSizer *) 0 ;
40151 wxSize result;
40152 PyObject * obj0 = 0 ;
40153 char *kwnames[] = {
40154 (char *) "self", NULL
40155 };
40156
40157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40159 if (SWIG_arg_fail(1)) SWIG_fail;
40160 {
40161 PyThreadState* __tstate = wxPyBeginAllowThreads();
40162 result = (arg1)->CalcMin();
40163
40164 wxPyEndAllowThreads(__tstate);
40165 if (PyErr_Occurred()) SWIG_fail;
40166 }
40167 {
40168 wxSize * resultptr;
40169 resultptr = new wxSize((wxSize &)(result));
40170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40171 }
40172 return resultobj;
40173 fail:
40174 return NULL;
40175 }
40176
40177
40178 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40179 PyObject *resultobj;
40180 wxSizer *arg1 = (wxSizer *) 0 ;
40181 PyObject * obj0 = 0 ;
40182 char *kwnames[] = {
40183 (char *) "self", NULL
40184 };
40185
40186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40188 if (SWIG_arg_fail(1)) SWIG_fail;
40189 {
40190 PyThreadState* __tstate = wxPyBeginAllowThreads();
40191 (arg1)->Layout();
40192
40193 wxPyEndAllowThreads(__tstate);
40194 if (PyErr_Occurred()) SWIG_fail;
40195 }
40196 Py_INCREF(Py_None); resultobj = Py_None;
40197 return resultobj;
40198 fail:
40199 return NULL;
40200 }
40201
40202
40203 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40204 PyObject *resultobj;
40205 wxSizer *arg1 = (wxSizer *) 0 ;
40206 wxWindow *arg2 = (wxWindow *) 0 ;
40207 wxSize result;
40208 PyObject * obj0 = 0 ;
40209 PyObject * obj1 = 0 ;
40210 char *kwnames[] = {
40211 (char *) "self",(char *) "window", NULL
40212 };
40213
40214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40216 if (SWIG_arg_fail(1)) SWIG_fail;
40217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40218 if (SWIG_arg_fail(2)) SWIG_fail;
40219 {
40220 PyThreadState* __tstate = wxPyBeginAllowThreads();
40221 result = (arg1)->Fit(arg2);
40222
40223 wxPyEndAllowThreads(__tstate);
40224 if (PyErr_Occurred()) SWIG_fail;
40225 }
40226 {
40227 wxSize * resultptr;
40228 resultptr = new wxSize((wxSize &)(result));
40229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40230 }
40231 return resultobj;
40232 fail:
40233 return NULL;
40234 }
40235
40236
40237 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40238 PyObject *resultobj;
40239 wxSizer *arg1 = (wxSizer *) 0 ;
40240 wxWindow *arg2 = (wxWindow *) 0 ;
40241 PyObject * obj0 = 0 ;
40242 PyObject * obj1 = 0 ;
40243 char *kwnames[] = {
40244 (char *) "self",(char *) "window", NULL
40245 };
40246
40247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40249 if (SWIG_arg_fail(1)) SWIG_fail;
40250 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40251 if (SWIG_arg_fail(2)) SWIG_fail;
40252 {
40253 PyThreadState* __tstate = wxPyBeginAllowThreads();
40254 (arg1)->FitInside(arg2);
40255
40256 wxPyEndAllowThreads(__tstate);
40257 if (PyErr_Occurred()) SWIG_fail;
40258 }
40259 Py_INCREF(Py_None); resultobj = Py_None;
40260 return resultobj;
40261 fail:
40262 return NULL;
40263 }
40264
40265
40266 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40267 PyObject *resultobj;
40268 wxSizer *arg1 = (wxSizer *) 0 ;
40269 wxWindow *arg2 = (wxWindow *) 0 ;
40270 PyObject * obj0 = 0 ;
40271 PyObject * obj1 = 0 ;
40272 char *kwnames[] = {
40273 (char *) "self",(char *) "window", NULL
40274 };
40275
40276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40278 if (SWIG_arg_fail(1)) SWIG_fail;
40279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40280 if (SWIG_arg_fail(2)) SWIG_fail;
40281 {
40282 PyThreadState* __tstate = wxPyBeginAllowThreads();
40283 (arg1)->SetSizeHints(arg2);
40284
40285 wxPyEndAllowThreads(__tstate);
40286 if (PyErr_Occurred()) SWIG_fail;
40287 }
40288 Py_INCREF(Py_None); resultobj = Py_None;
40289 return resultobj;
40290 fail:
40291 return NULL;
40292 }
40293
40294
40295 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40296 PyObject *resultobj;
40297 wxSizer *arg1 = (wxSizer *) 0 ;
40298 wxWindow *arg2 = (wxWindow *) 0 ;
40299 PyObject * obj0 = 0 ;
40300 PyObject * obj1 = 0 ;
40301 char *kwnames[] = {
40302 (char *) "self",(char *) "window", NULL
40303 };
40304
40305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40307 if (SWIG_arg_fail(1)) SWIG_fail;
40308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40309 if (SWIG_arg_fail(2)) SWIG_fail;
40310 {
40311 PyThreadState* __tstate = wxPyBeginAllowThreads();
40312 (arg1)->SetVirtualSizeHints(arg2);
40313
40314 wxPyEndAllowThreads(__tstate);
40315 if (PyErr_Occurred()) SWIG_fail;
40316 }
40317 Py_INCREF(Py_None); resultobj = Py_None;
40318 return resultobj;
40319 fail:
40320 return NULL;
40321 }
40322
40323
40324 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40325 PyObject *resultobj;
40326 wxSizer *arg1 = (wxSizer *) 0 ;
40327 bool arg2 = (bool) false ;
40328 PyObject * obj0 = 0 ;
40329 PyObject * obj1 = 0 ;
40330 char *kwnames[] = {
40331 (char *) "self",(char *) "deleteWindows", NULL
40332 };
40333
40334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40336 if (SWIG_arg_fail(1)) SWIG_fail;
40337 if (obj1) {
40338 {
40339 arg2 = (bool)(SWIG_As_bool(obj1));
40340 if (SWIG_arg_fail(2)) SWIG_fail;
40341 }
40342 }
40343 {
40344 PyThreadState* __tstate = wxPyBeginAllowThreads();
40345 (arg1)->Clear(arg2);
40346
40347 wxPyEndAllowThreads(__tstate);
40348 if (PyErr_Occurred()) SWIG_fail;
40349 }
40350 Py_INCREF(Py_None); resultobj = Py_None;
40351 return resultobj;
40352 fail:
40353 return NULL;
40354 }
40355
40356
40357 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40358 PyObject *resultobj;
40359 wxSizer *arg1 = (wxSizer *) 0 ;
40360 PyObject * obj0 = 0 ;
40361 char *kwnames[] = {
40362 (char *) "self", NULL
40363 };
40364
40365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40367 if (SWIG_arg_fail(1)) SWIG_fail;
40368 {
40369 PyThreadState* __tstate = wxPyBeginAllowThreads();
40370 (arg1)->DeleteWindows();
40371
40372 wxPyEndAllowThreads(__tstate);
40373 if (PyErr_Occurred()) SWIG_fail;
40374 }
40375 Py_INCREF(Py_None); resultobj = Py_None;
40376 return resultobj;
40377 fail:
40378 return NULL;
40379 }
40380
40381
40382 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40383 PyObject *resultobj;
40384 wxSizer *arg1 = (wxSizer *) 0 ;
40385 PyObject *result;
40386 PyObject * obj0 = 0 ;
40387 char *kwnames[] = {
40388 (char *) "self", NULL
40389 };
40390
40391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40393 if (SWIG_arg_fail(1)) SWIG_fail;
40394 {
40395 PyThreadState* __tstate = wxPyBeginAllowThreads();
40396 result = (PyObject *)wxSizer_GetChildren(arg1);
40397
40398 wxPyEndAllowThreads(__tstate);
40399 if (PyErr_Occurred()) SWIG_fail;
40400 }
40401 resultobj = result;
40402 return resultobj;
40403 fail:
40404 return NULL;
40405 }
40406
40407
40408 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40409 PyObject *resultobj;
40410 wxSizer *arg1 = (wxSizer *) 0 ;
40411 PyObject *arg2 = (PyObject *) 0 ;
40412 bool arg3 = (bool) true ;
40413 bool arg4 = (bool) false ;
40414 bool result;
40415 PyObject * obj0 = 0 ;
40416 PyObject * obj1 = 0 ;
40417 PyObject * obj2 = 0 ;
40418 PyObject * obj3 = 0 ;
40419 char *kwnames[] = {
40420 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40421 };
40422
40423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40425 if (SWIG_arg_fail(1)) SWIG_fail;
40426 arg2 = obj1;
40427 if (obj2) {
40428 {
40429 arg3 = (bool)(SWIG_As_bool(obj2));
40430 if (SWIG_arg_fail(3)) SWIG_fail;
40431 }
40432 }
40433 if (obj3) {
40434 {
40435 arg4 = (bool)(SWIG_As_bool(obj3));
40436 if (SWIG_arg_fail(4)) SWIG_fail;
40437 }
40438 }
40439 {
40440 PyThreadState* __tstate = wxPyBeginAllowThreads();
40441 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40442
40443 wxPyEndAllowThreads(__tstate);
40444 if (PyErr_Occurred()) SWIG_fail;
40445 }
40446 {
40447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40448 }
40449 return resultobj;
40450 fail:
40451 return NULL;
40452 }
40453
40454
40455 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40456 PyObject *resultobj;
40457 wxSizer *arg1 = (wxSizer *) 0 ;
40458 PyObject *arg2 = (PyObject *) 0 ;
40459 bool result;
40460 PyObject * obj0 = 0 ;
40461 PyObject * obj1 = 0 ;
40462 char *kwnames[] = {
40463 (char *) "self",(char *) "item", NULL
40464 };
40465
40466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40468 if (SWIG_arg_fail(1)) SWIG_fail;
40469 arg2 = obj1;
40470 {
40471 PyThreadState* __tstate = wxPyBeginAllowThreads();
40472 result = (bool)wxSizer_IsShown(arg1,arg2);
40473
40474 wxPyEndAllowThreads(__tstate);
40475 if (PyErr_Occurred()) SWIG_fail;
40476 }
40477 {
40478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40479 }
40480 return resultobj;
40481 fail:
40482 return NULL;
40483 }
40484
40485
40486 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40487 PyObject *resultobj;
40488 wxSizer *arg1 = (wxSizer *) 0 ;
40489 bool arg2 ;
40490 PyObject * obj0 = 0 ;
40491 PyObject * obj1 = 0 ;
40492 char *kwnames[] = {
40493 (char *) "self",(char *) "show", NULL
40494 };
40495
40496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40498 if (SWIG_arg_fail(1)) SWIG_fail;
40499 {
40500 arg2 = (bool)(SWIG_As_bool(obj1));
40501 if (SWIG_arg_fail(2)) SWIG_fail;
40502 }
40503 {
40504 PyThreadState* __tstate = wxPyBeginAllowThreads();
40505 (arg1)->ShowItems(arg2);
40506
40507 wxPyEndAllowThreads(__tstate);
40508 if (PyErr_Occurred()) SWIG_fail;
40509 }
40510 Py_INCREF(Py_None); resultobj = Py_None;
40511 return resultobj;
40512 fail:
40513 return NULL;
40514 }
40515
40516
40517 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40518 PyObject *obj;
40519 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40520 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40521 Py_INCREF(obj);
40522 return Py_BuildValue((char *)"");
40523 }
40524 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40525 PyObject *resultobj;
40526 wxPySizer *result;
40527 char *kwnames[] = {
40528 NULL
40529 };
40530
40531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40532 {
40533 PyThreadState* __tstate = wxPyBeginAllowThreads();
40534 result = (wxPySizer *)new wxPySizer();
40535
40536 wxPyEndAllowThreads(__tstate);
40537 if (PyErr_Occurred()) SWIG_fail;
40538 }
40539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40540 return resultobj;
40541 fail:
40542 return NULL;
40543 }
40544
40545
40546 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40547 PyObject *resultobj;
40548 wxPySizer *arg1 = (wxPySizer *) 0 ;
40549 PyObject *arg2 = (PyObject *) 0 ;
40550 PyObject *arg3 = (PyObject *) 0 ;
40551 PyObject * obj0 = 0 ;
40552 PyObject * obj1 = 0 ;
40553 PyObject * obj2 = 0 ;
40554 char *kwnames[] = {
40555 (char *) "self",(char *) "self",(char *) "_class", NULL
40556 };
40557
40558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40560 if (SWIG_arg_fail(1)) SWIG_fail;
40561 arg2 = obj1;
40562 arg3 = obj2;
40563 {
40564 PyThreadState* __tstate = wxPyBeginAllowThreads();
40565 (arg1)->_setCallbackInfo(arg2,arg3);
40566
40567 wxPyEndAllowThreads(__tstate);
40568 if (PyErr_Occurred()) SWIG_fail;
40569 }
40570 Py_INCREF(Py_None); resultobj = Py_None;
40571 return resultobj;
40572 fail:
40573 return NULL;
40574 }
40575
40576
40577 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40578 PyObject *obj;
40579 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40580 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40581 Py_INCREF(obj);
40582 return Py_BuildValue((char *)"");
40583 }
40584 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40585 PyObject *resultobj;
40586 int arg1 = (int) wxHORIZONTAL ;
40587 wxBoxSizer *result;
40588 PyObject * obj0 = 0 ;
40589 char *kwnames[] = {
40590 (char *) "orient", NULL
40591 };
40592
40593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40594 if (obj0) {
40595 {
40596 arg1 = (int)(SWIG_As_int(obj0));
40597 if (SWIG_arg_fail(1)) SWIG_fail;
40598 }
40599 }
40600 {
40601 PyThreadState* __tstate = wxPyBeginAllowThreads();
40602 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40603
40604 wxPyEndAllowThreads(__tstate);
40605 if (PyErr_Occurred()) SWIG_fail;
40606 }
40607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40608 return resultobj;
40609 fail:
40610 return NULL;
40611 }
40612
40613
40614 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40615 PyObject *resultobj;
40616 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40617 int result;
40618 PyObject * obj0 = 0 ;
40619 char *kwnames[] = {
40620 (char *) "self", NULL
40621 };
40622
40623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40625 if (SWIG_arg_fail(1)) SWIG_fail;
40626 {
40627 PyThreadState* __tstate = wxPyBeginAllowThreads();
40628 result = (int)(arg1)->GetOrientation();
40629
40630 wxPyEndAllowThreads(__tstate);
40631 if (PyErr_Occurred()) SWIG_fail;
40632 }
40633 {
40634 resultobj = SWIG_From_int((int)(result));
40635 }
40636 return resultobj;
40637 fail:
40638 return NULL;
40639 }
40640
40641
40642 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40643 PyObject *resultobj;
40644 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40645 int arg2 ;
40646 PyObject * obj0 = 0 ;
40647 PyObject * obj1 = 0 ;
40648 char *kwnames[] = {
40649 (char *) "self",(char *) "orient", NULL
40650 };
40651
40652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40654 if (SWIG_arg_fail(1)) SWIG_fail;
40655 {
40656 arg2 = (int)(SWIG_As_int(obj1));
40657 if (SWIG_arg_fail(2)) SWIG_fail;
40658 }
40659 {
40660 PyThreadState* __tstate = wxPyBeginAllowThreads();
40661 (arg1)->SetOrientation(arg2);
40662
40663 wxPyEndAllowThreads(__tstate);
40664 if (PyErr_Occurred()) SWIG_fail;
40665 }
40666 Py_INCREF(Py_None); resultobj = Py_None;
40667 return resultobj;
40668 fail:
40669 return NULL;
40670 }
40671
40672
40673 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40674 PyObject *obj;
40675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40676 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40677 Py_INCREF(obj);
40678 return Py_BuildValue((char *)"");
40679 }
40680 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40681 PyObject *resultobj;
40682 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40683 int arg2 = (int) wxHORIZONTAL ;
40684 wxStaticBoxSizer *result;
40685 PyObject * obj0 = 0 ;
40686 PyObject * obj1 = 0 ;
40687 char *kwnames[] = {
40688 (char *) "box",(char *) "orient", NULL
40689 };
40690
40691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40693 if (SWIG_arg_fail(1)) SWIG_fail;
40694 if (obj1) {
40695 {
40696 arg2 = (int)(SWIG_As_int(obj1));
40697 if (SWIG_arg_fail(2)) SWIG_fail;
40698 }
40699 }
40700 {
40701 PyThreadState* __tstate = wxPyBeginAllowThreads();
40702 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40703
40704 wxPyEndAllowThreads(__tstate);
40705 if (PyErr_Occurred()) SWIG_fail;
40706 }
40707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40708 return resultobj;
40709 fail:
40710 return NULL;
40711 }
40712
40713
40714 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40715 PyObject *resultobj;
40716 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40717 wxStaticBox *result;
40718 PyObject * obj0 = 0 ;
40719 char *kwnames[] = {
40720 (char *) "self", NULL
40721 };
40722
40723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40725 if (SWIG_arg_fail(1)) SWIG_fail;
40726 {
40727 PyThreadState* __tstate = wxPyBeginAllowThreads();
40728 result = (wxStaticBox *)(arg1)->GetStaticBox();
40729
40730 wxPyEndAllowThreads(__tstate);
40731 if (PyErr_Occurred()) SWIG_fail;
40732 }
40733 {
40734 resultobj = wxPyMake_wxObject(result, 0);
40735 }
40736 return resultobj;
40737 fail:
40738 return NULL;
40739 }
40740
40741
40742 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40743 PyObject *obj;
40744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40745 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40746 Py_INCREF(obj);
40747 return Py_BuildValue((char *)"");
40748 }
40749 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40750 PyObject *resultobj;
40751 int arg1 = (int) 1 ;
40752 int arg2 = (int) 0 ;
40753 int arg3 = (int) 0 ;
40754 int arg4 = (int) 0 ;
40755 wxGridSizer *result;
40756 PyObject * obj0 = 0 ;
40757 PyObject * obj1 = 0 ;
40758 PyObject * obj2 = 0 ;
40759 PyObject * obj3 = 0 ;
40760 char *kwnames[] = {
40761 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40762 };
40763
40764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40765 if (obj0) {
40766 {
40767 arg1 = (int)(SWIG_As_int(obj0));
40768 if (SWIG_arg_fail(1)) SWIG_fail;
40769 }
40770 }
40771 if (obj1) {
40772 {
40773 arg2 = (int)(SWIG_As_int(obj1));
40774 if (SWIG_arg_fail(2)) SWIG_fail;
40775 }
40776 }
40777 if (obj2) {
40778 {
40779 arg3 = (int)(SWIG_As_int(obj2));
40780 if (SWIG_arg_fail(3)) SWIG_fail;
40781 }
40782 }
40783 if (obj3) {
40784 {
40785 arg4 = (int)(SWIG_As_int(obj3));
40786 if (SWIG_arg_fail(4)) SWIG_fail;
40787 }
40788 }
40789 {
40790 PyThreadState* __tstate = wxPyBeginAllowThreads();
40791 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40792
40793 wxPyEndAllowThreads(__tstate);
40794 if (PyErr_Occurred()) SWIG_fail;
40795 }
40796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40797 return resultobj;
40798 fail:
40799 return NULL;
40800 }
40801
40802
40803 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40804 PyObject *resultobj;
40805 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40806 int arg2 ;
40807 PyObject * obj0 = 0 ;
40808 PyObject * obj1 = 0 ;
40809 char *kwnames[] = {
40810 (char *) "self",(char *) "cols", NULL
40811 };
40812
40813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40815 if (SWIG_arg_fail(1)) SWIG_fail;
40816 {
40817 arg2 = (int)(SWIG_As_int(obj1));
40818 if (SWIG_arg_fail(2)) SWIG_fail;
40819 }
40820 {
40821 PyThreadState* __tstate = wxPyBeginAllowThreads();
40822 (arg1)->SetCols(arg2);
40823
40824 wxPyEndAllowThreads(__tstate);
40825 if (PyErr_Occurred()) SWIG_fail;
40826 }
40827 Py_INCREF(Py_None); resultobj = Py_None;
40828 return resultobj;
40829 fail:
40830 return NULL;
40831 }
40832
40833
40834 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40835 PyObject *resultobj;
40836 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40837 int arg2 ;
40838 PyObject * obj0 = 0 ;
40839 PyObject * obj1 = 0 ;
40840 char *kwnames[] = {
40841 (char *) "self",(char *) "rows", NULL
40842 };
40843
40844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40846 if (SWIG_arg_fail(1)) SWIG_fail;
40847 {
40848 arg2 = (int)(SWIG_As_int(obj1));
40849 if (SWIG_arg_fail(2)) SWIG_fail;
40850 }
40851 {
40852 PyThreadState* __tstate = wxPyBeginAllowThreads();
40853 (arg1)->SetRows(arg2);
40854
40855 wxPyEndAllowThreads(__tstate);
40856 if (PyErr_Occurred()) SWIG_fail;
40857 }
40858 Py_INCREF(Py_None); resultobj = Py_None;
40859 return resultobj;
40860 fail:
40861 return NULL;
40862 }
40863
40864
40865 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40866 PyObject *resultobj;
40867 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40868 int arg2 ;
40869 PyObject * obj0 = 0 ;
40870 PyObject * obj1 = 0 ;
40871 char *kwnames[] = {
40872 (char *) "self",(char *) "gap", NULL
40873 };
40874
40875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40877 if (SWIG_arg_fail(1)) SWIG_fail;
40878 {
40879 arg2 = (int)(SWIG_As_int(obj1));
40880 if (SWIG_arg_fail(2)) SWIG_fail;
40881 }
40882 {
40883 PyThreadState* __tstate = wxPyBeginAllowThreads();
40884 (arg1)->SetVGap(arg2);
40885
40886 wxPyEndAllowThreads(__tstate);
40887 if (PyErr_Occurred()) SWIG_fail;
40888 }
40889 Py_INCREF(Py_None); resultobj = Py_None;
40890 return resultobj;
40891 fail:
40892 return NULL;
40893 }
40894
40895
40896 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40897 PyObject *resultobj;
40898 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40899 int arg2 ;
40900 PyObject * obj0 = 0 ;
40901 PyObject * obj1 = 0 ;
40902 char *kwnames[] = {
40903 (char *) "self",(char *) "gap", NULL
40904 };
40905
40906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40908 if (SWIG_arg_fail(1)) SWIG_fail;
40909 {
40910 arg2 = (int)(SWIG_As_int(obj1));
40911 if (SWIG_arg_fail(2)) SWIG_fail;
40912 }
40913 {
40914 PyThreadState* __tstate = wxPyBeginAllowThreads();
40915 (arg1)->SetHGap(arg2);
40916
40917 wxPyEndAllowThreads(__tstate);
40918 if (PyErr_Occurred()) SWIG_fail;
40919 }
40920 Py_INCREF(Py_None); resultobj = Py_None;
40921 return resultobj;
40922 fail:
40923 return NULL;
40924 }
40925
40926
40927 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40928 PyObject *resultobj;
40929 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40930 int result;
40931 PyObject * obj0 = 0 ;
40932 char *kwnames[] = {
40933 (char *) "self", NULL
40934 };
40935
40936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40938 if (SWIG_arg_fail(1)) SWIG_fail;
40939 {
40940 PyThreadState* __tstate = wxPyBeginAllowThreads();
40941 result = (int)(arg1)->GetCols();
40942
40943 wxPyEndAllowThreads(__tstate);
40944 if (PyErr_Occurred()) SWIG_fail;
40945 }
40946 {
40947 resultobj = SWIG_From_int((int)(result));
40948 }
40949 return resultobj;
40950 fail:
40951 return NULL;
40952 }
40953
40954
40955 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40956 PyObject *resultobj;
40957 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40958 int result;
40959 PyObject * obj0 = 0 ;
40960 char *kwnames[] = {
40961 (char *) "self", NULL
40962 };
40963
40964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40966 if (SWIG_arg_fail(1)) SWIG_fail;
40967 {
40968 PyThreadState* __tstate = wxPyBeginAllowThreads();
40969 result = (int)(arg1)->GetRows();
40970
40971 wxPyEndAllowThreads(__tstate);
40972 if (PyErr_Occurred()) SWIG_fail;
40973 }
40974 {
40975 resultobj = SWIG_From_int((int)(result));
40976 }
40977 return resultobj;
40978 fail:
40979 return NULL;
40980 }
40981
40982
40983 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40984 PyObject *resultobj;
40985 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40986 int result;
40987 PyObject * obj0 = 0 ;
40988 char *kwnames[] = {
40989 (char *) "self", NULL
40990 };
40991
40992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40994 if (SWIG_arg_fail(1)) SWIG_fail;
40995 {
40996 PyThreadState* __tstate = wxPyBeginAllowThreads();
40997 result = (int)(arg1)->GetVGap();
40998
40999 wxPyEndAllowThreads(__tstate);
41000 if (PyErr_Occurred()) SWIG_fail;
41001 }
41002 {
41003 resultobj = SWIG_From_int((int)(result));
41004 }
41005 return resultobj;
41006 fail:
41007 return NULL;
41008 }
41009
41010
41011 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41012 PyObject *resultobj;
41013 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41014 int result;
41015 PyObject * obj0 = 0 ;
41016 char *kwnames[] = {
41017 (char *) "self", NULL
41018 };
41019
41020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41022 if (SWIG_arg_fail(1)) SWIG_fail;
41023 {
41024 PyThreadState* __tstate = wxPyBeginAllowThreads();
41025 result = (int)(arg1)->GetHGap();
41026
41027 wxPyEndAllowThreads(__tstate);
41028 if (PyErr_Occurred()) SWIG_fail;
41029 }
41030 {
41031 resultobj = SWIG_From_int((int)(result));
41032 }
41033 return resultobj;
41034 fail:
41035 return NULL;
41036 }
41037
41038
41039 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41040 PyObject *obj;
41041 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41042 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41043 Py_INCREF(obj);
41044 return Py_BuildValue((char *)"");
41045 }
41046 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41047 PyObject *resultobj;
41048 int arg1 = (int) 1 ;
41049 int arg2 = (int) 0 ;
41050 int arg3 = (int) 0 ;
41051 int arg4 = (int) 0 ;
41052 wxFlexGridSizer *result;
41053 PyObject * obj0 = 0 ;
41054 PyObject * obj1 = 0 ;
41055 PyObject * obj2 = 0 ;
41056 PyObject * obj3 = 0 ;
41057 char *kwnames[] = {
41058 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41059 };
41060
41061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41062 if (obj0) {
41063 {
41064 arg1 = (int)(SWIG_As_int(obj0));
41065 if (SWIG_arg_fail(1)) SWIG_fail;
41066 }
41067 }
41068 if (obj1) {
41069 {
41070 arg2 = (int)(SWIG_As_int(obj1));
41071 if (SWIG_arg_fail(2)) SWIG_fail;
41072 }
41073 }
41074 if (obj2) {
41075 {
41076 arg3 = (int)(SWIG_As_int(obj2));
41077 if (SWIG_arg_fail(3)) SWIG_fail;
41078 }
41079 }
41080 if (obj3) {
41081 {
41082 arg4 = (int)(SWIG_As_int(obj3));
41083 if (SWIG_arg_fail(4)) SWIG_fail;
41084 }
41085 }
41086 {
41087 PyThreadState* __tstate = wxPyBeginAllowThreads();
41088 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41089
41090 wxPyEndAllowThreads(__tstate);
41091 if (PyErr_Occurred()) SWIG_fail;
41092 }
41093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41094 return resultobj;
41095 fail:
41096 return NULL;
41097 }
41098
41099
41100 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41101 PyObject *resultobj;
41102 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41103 size_t arg2 ;
41104 int arg3 = (int) 0 ;
41105 PyObject * obj0 = 0 ;
41106 PyObject * obj1 = 0 ;
41107 PyObject * obj2 = 0 ;
41108 char *kwnames[] = {
41109 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41110 };
41111
41112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41114 if (SWIG_arg_fail(1)) SWIG_fail;
41115 {
41116 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41117 if (SWIG_arg_fail(2)) SWIG_fail;
41118 }
41119 if (obj2) {
41120 {
41121 arg3 = (int)(SWIG_As_int(obj2));
41122 if (SWIG_arg_fail(3)) SWIG_fail;
41123 }
41124 }
41125 {
41126 PyThreadState* __tstate = wxPyBeginAllowThreads();
41127 (arg1)->AddGrowableRow(arg2,arg3);
41128
41129 wxPyEndAllowThreads(__tstate);
41130 if (PyErr_Occurred()) SWIG_fail;
41131 }
41132 Py_INCREF(Py_None); resultobj = Py_None;
41133 return resultobj;
41134 fail:
41135 return NULL;
41136 }
41137
41138
41139 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41140 PyObject *resultobj;
41141 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41142 size_t arg2 ;
41143 PyObject * obj0 = 0 ;
41144 PyObject * obj1 = 0 ;
41145 char *kwnames[] = {
41146 (char *) "self",(char *) "idx", NULL
41147 };
41148
41149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41151 if (SWIG_arg_fail(1)) SWIG_fail;
41152 {
41153 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41154 if (SWIG_arg_fail(2)) SWIG_fail;
41155 }
41156 {
41157 PyThreadState* __tstate = wxPyBeginAllowThreads();
41158 (arg1)->RemoveGrowableRow(arg2);
41159
41160 wxPyEndAllowThreads(__tstate);
41161 if (PyErr_Occurred()) SWIG_fail;
41162 }
41163 Py_INCREF(Py_None); resultobj = Py_None;
41164 return resultobj;
41165 fail:
41166 return NULL;
41167 }
41168
41169
41170 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41171 PyObject *resultobj;
41172 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41173 size_t arg2 ;
41174 int arg3 = (int) 0 ;
41175 PyObject * obj0 = 0 ;
41176 PyObject * obj1 = 0 ;
41177 PyObject * obj2 = 0 ;
41178 char *kwnames[] = {
41179 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41180 };
41181
41182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41184 if (SWIG_arg_fail(1)) SWIG_fail;
41185 {
41186 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41187 if (SWIG_arg_fail(2)) SWIG_fail;
41188 }
41189 if (obj2) {
41190 {
41191 arg3 = (int)(SWIG_As_int(obj2));
41192 if (SWIG_arg_fail(3)) SWIG_fail;
41193 }
41194 }
41195 {
41196 PyThreadState* __tstate = wxPyBeginAllowThreads();
41197 (arg1)->AddGrowableCol(arg2,arg3);
41198
41199 wxPyEndAllowThreads(__tstate);
41200 if (PyErr_Occurred()) SWIG_fail;
41201 }
41202 Py_INCREF(Py_None); resultobj = Py_None;
41203 return resultobj;
41204 fail:
41205 return NULL;
41206 }
41207
41208
41209 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41210 PyObject *resultobj;
41211 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41212 size_t arg2 ;
41213 PyObject * obj0 = 0 ;
41214 PyObject * obj1 = 0 ;
41215 char *kwnames[] = {
41216 (char *) "self",(char *) "idx", NULL
41217 };
41218
41219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41221 if (SWIG_arg_fail(1)) SWIG_fail;
41222 {
41223 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41224 if (SWIG_arg_fail(2)) SWIG_fail;
41225 }
41226 {
41227 PyThreadState* __tstate = wxPyBeginAllowThreads();
41228 (arg1)->RemoveGrowableCol(arg2);
41229
41230 wxPyEndAllowThreads(__tstate);
41231 if (PyErr_Occurred()) SWIG_fail;
41232 }
41233 Py_INCREF(Py_None); resultobj = Py_None;
41234 return resultobj;
41235 fail:
41236 return NULL;
41237 }
41238
41239
41240 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41241 PyObject *resultobj;
41242 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41243 int arg2 ;
41244 PyObject * obj0 = 0 ;
41245 PyObject * obj1 = 0 ;
41246 char *kwnames[] = {
41247 (char *) "self",(char *) "direction", NULL
41248 };
41249
41250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41252 if (SWIG_arg_fail(1)) SWIG_fail;
41253 {
41254 arg2 = (int)(SWIG_As_int(obj1));
41255 if (SWIG_arg_fail(2)) SWIG_fail;
41256 }
41257 {
41258 PyThreadState* __tstate = wxPyBeginAllowThreads();
41259 (arg1)->SetFlexibleDirection(arg2);
41260
41261 wxPyEndAllowThreads(__tstate);
41262 if (PyErr_Occurred()) SWIG_fail;
41263 }
41264 Py_INCREF(Py_None); resultobj = Py_None;
41265 return resultobj;
41266 fail:
41267 return NULL;
41268 }
41269
41270
41271 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41272 PyObject *resultobj;
41273 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41274 int result;
41275 PyObject * obj0 = 0 ;
41276 char *kwnames[] = {
41277 (char *) "self", NULL
41278 };
41279
41280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41282 if (SWIG_arg_fail(1)) SWIG_fail;
41283 {
41284 PyThreadState* __tstate = wxPyBeginAllowThreads();
41285 result = (int)(arg1)->GetFlexibleDirection();
41286
41287 wxPyEndAllowThreads(__tstate);
41288 if (PyErr_Occurred()) SWIG_fail;
41289 }
41290 {
41291 resultobj = SWIG_From_int((int)(result));
41292 }
41293 return resultobj;
41294 fail:
41295 return NULL;
41296 }
41297
41298
41299 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41300 PyObject *resultobj;
41301 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41302 wxFlexSizerGrowMode arg2 ;
41303 PyObject * obj0 = 0 ;
41304 PyObject * obj1 = 0 ;
41305 char *kwnames[] = {
41306 (char *) "self",(char *) "mode", NULL
41307 };
41308
41309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41311 if (SWIG_arg_fail(1)) SWIG_fail;
41312 {
41313 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41314 if (SWIG_arg_fail(2)) SWIG_fail;
41315 }
41316 {
41317 PyThreadState* __tstate = wxPyBeginAllowThreads();
41318 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41319
41320 wxPyEndAllowThreads(__tstate);
41321 if (PyErr_Occurred()) SWIG_fail;
41322 }
41323 Py_INCREF(Py_None); resultobj = Py_None;
41324 return resultobj;
41325 fail:
41326 return NULL;
41327 }
41328
41329
41330 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41331 PyObject *resultobj;
41332 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41333 wxFlexSizerGrowMode result;
41334 PyObject * obj0 = 0 ;
41335 char *kwnames[] = {
41336 (char *) "self", NULL
41337 };
41338
41339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41341 if (SWIG_arg_fail(1)) SWIG_fail;
41342 {
41343 PyThreadState* __tstate = wxPyBeginAllowThreads();
41344 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41345
41346 wxPyEndAllowThreads(__tstate);
41347 if (PyErr_Occurred()) SWIG_fail;
41348 }
41349 resultobj = SWIG_From_int((result));
41350 return resultobj;
41351 fail:
41352 return NULL;
41353 }
41354
41355
41356 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41357 PyObject *resultobj;
41358 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41359 wxArrayInt *result;
41360 PyObject * obj0 = 0 ;
41361 char *kwnames[] = {
41362 (char *) "self", NULL
41363 };
41364
41365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41367 if (SWIG_arg_fail(1)) SWIG_fail;
41368 {
41369 PyThreadState* __tstate = wxPyBeginAllowThreads();
41370 {
41371 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41372 result = (wxArrayInt *) &_result_ref;
41373 }
41374
41375 wxPyEndAllowThreads(__tstate);
41376 if (PyErr_Occurred()) SWIG_fail;
41377 }
41378 {
41379 resultobj = PyList_New(0);
41380 size_t idx;
41381 for (idx = 0; idx < result->GetCount(); idx += 1) {
41382 PyObject* val = PyInt_FromLong( result->Item(idx) );
41383 PyList_Append(resultobj, val);
41384 Py_DECREF(val);
41385 }
41386 }
41387 return resultobj;
41388 fail:
41389 return NULL;
41390 }
41391
41392
41393 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41394 PyObject *resultobj;
41395 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41396 wxArrayInt *result;
41397 PyObject * obj0 = 0 ;
41398 char *kwnames[] = {
41399 (char *) "self", NULL
41400 };
41401
41402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41404 if (SWIG_arg_fail(1)) SWIG_fail;
41405 {
41406 PyThreadState* __tstate = wxPyBeginAllowThreads();
41407 {
41408 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41409 result = (wxArrayInt *) &_result_ref;
41410 }
41411
41412 wxPyEndAllowThreads(__tstate);
41413 if (PyErr_Occurred()) SWIG_fail;
41414 }
41415 {
41416 resultobj = PyList_New(0);
41417 size_t idx;
41418 for (idx = 0; idx < result->GetCount(); idx += 1) {
41419 PyObject* val = PyInt_FromLong( result->Item(idx) );
41420 PyList_Append(resultobj, val);
41421 Py_DECREF(val);
41422 }
41423 }
41424 return resultobj;
41425 fail:
41426 return NULL;
41427 }
41428
41429
41430 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41431 PyObject *obj;
41432 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41433 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41434 Py_INCREF(obj);
41435 return Py_BuildValue((char *)"");
41436 }
41437 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41438 PyObject *resultobj;
41439 wxStdDialogButtonSizer *result;
41440 char *kwnames[] = {
41441 NULL
41442 };
41443
41444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41445 {
41446 PyThreadState* __tstate = wxPyBeginAllowThreads();
41447 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41448
41449 wxPyEndAllowThreads(__tstate);
41450 if (PyErr_Occurred()) SWIG_fail;
41451 }
41452 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41453 return resultobj;
41454 fail:
41455 return NULL;
41456 }
41457
41458
41459 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41460 PyObject *resultobj;
41461 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41462 wxButton *arg2 = (wxButton *) 0 ;
41463 PyObject * obj0 = 0 ;
41464 PyObject * obj1 = 0 ;
41465 char *kwnames[] = {
41466 (char *) "self",(char *) "button", NULL
41467 };
41468
41469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41471 if (SWIG_arg_fail(1)) SWIG_fail;
41472 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41473 if (SWIG_arg_fail(2)) SWIG_fail;
41474 {
41475 PyThreadState* __tstate = wxPyBeginAllowThreads();
41476 (arg1)->AddButton(arg2);
41477
41478 wxPyEndAllowThreads(__tstate);
41479 if (PyErr_Occurred()) SWIG_fail;
41480 }
41481 Py_INCREF(Py_None); resultobj = Py_None;
41482 return resultobj;
41483 fail:
41484 return NULL;
41485 }
41486
41487
41488 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41489 PyObject *resultobj;
41490 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41491 PyObject * obj0 = 0 ;
41492 char *kwnames[] = {
41493 (char *) "self", NULL
41494 };
41495
41496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41498 if (SWIG_arg_fail(1)) SWIG_fail;
41499 {
41500 PyThreadState* __tstate = wxPyBeginAllowThreads();
41501 (arg1)->Realize();
41502
41503 wxPyEndAllowThreads(__tstate);
41504 if (PyErr_Occurred()) SWIG_fail;
41505 }
41506 Py_INCREF(Py_None); resultobj = Py_None;
41507 return resultobj;
41508 fail:
41509 return NULL;
41510 }
41511
41512
41513 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41514 PyObject *resultobj;
41515 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41516 wxButton *arg2 = (wxButton *) 0 ;
41517 PyObject * obj0 = 0 ;
41518 PyObject * obj1 = 0 ;
41519 char *kwnames[] = {
41520 (char *) "self",(char *) "button", NULL
41521 };
41522
41523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41525 if (SWIG_arg_fail(1)) SWIG_fail;
41526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41527 if (SWIG_arg_fail(2)) SWIG_fail;
41528 {
41529 PyThreadState* __tstate = wxPyBeginAllowThreads();
41530 (arg1)->SetAffirmativeButton(arg2);
41531
41532 wxPyEndAllowThreads(__tstate);
41533 if (PyErr_Occurred()) SWIG_fail;
41534 }
41535 Py_INCREF(Py_None); resultobj = Py_None;
41536 return resultobj;
41537 fail:
41538 return NULL;
41539 }
41540
41541
41542 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41543 PyObject *resultobj;
41544 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41545 wxButton *arg2 = (wxButton *) 0 ;
41546 PyObject * obj0 = 0 ;
41547 PyObject * obj1 = 0 ;
41548 char *kwnames[] = {
41549 (char *) "self",(char *) "button", NULL
41550 };
41551
41552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41554 if (SWIG_arg_fail(1)) SWIG_fail;
41555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41556 if (SWIG_arg_fail(2)) SWIG_fail;
41557 {
41558 PyThreadState* __tstate = wxPyBeginAllowThreads();
41559 (arg1)->SetNegativeButton(arg2);
41560
41561 wxPyEndAllowThreads(__tstate);
41562 if (PyErr_Occurred()) SWIG_fail;
41563 }
41564 Py_INCREF(Py_None); resultobj = Py_None;
41565 return resultobj;
41566 fail:
41567 return NULL;
41568 }
41569
41570
41571 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41572 PyObject *resultobj;
41573 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41574 wxButton *arg2 = (wxButton *) 0 ;
41575 PyObject * obj0 = 0 ;
41576 PyObject * obj1 = 0 ;
41577 char *kwnames[] = {
41578 (char *) "self",(char *) "button", NULL
41579 };
41580
41581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41583 if (SWIG_arg_fail(1)) SWIG_fail;
41584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41585 if (SWIG_arg_fail(2)) SWIG_fail;
41586 {
41587 PyThreadState* __tstate = wxPyBeginAllowThreads();
41588 (arg1)->SetCancelButton(arg2);
41589
41590 wxPyEndAllowThreads(__tstate);
41591 if (PyErr_Occurred()) SWIG_fail;
41592 }
41593 Py_INCREF(Py_None); resultobj = Py_None;
41594 return resultobj;
41595 fail:
41596 return NULL;
41597 }
41598
41599
41600 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41601 PyObject *resultobj;
41602 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41603 wxButton *result;
41604 PyObject * obj0 = 0 ;
41605 char *kwnames[] = {
41606 (char *) "self", NULL
41607 };
41608
41609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41611 if (SWIG_arg_fail(1)) SWIG_fail;
41612 {
41613 PyThreadState* __tstate = wxPyBeginAllowThreads();
41614 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41615
41616 wxPyEndAllowThreads(__tstate);
41617 if (PyErr_Occurred()) SWIG_fail;
41618 }
41619 {
41620 resultobj = wxPyMake_wxObject(result, 0);
41621 }
41622 return resultobj;
41623 fail:
41624 return NULL;
41625 }
41626
41627
41628 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41629 PyObject *resultobj;
41630 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41631 wxButton *result;
41632 PyObject * obj0 = 0 ;
41633 char *kwnames[] = {
41634 (char *) "self", NULL
41635 };
41636
41637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41639 if (SWIG_arg_fail(1)) SWIG_fail;
41640 {
41641 PyThreadState* __tstate = wxPyBeginAllowThreads();
41642 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41643
41644 wxPyEndAllowThreads(__tstate);
41645 if (PyErr_Occurred()) SWIG_fail;
41646 }
41647 {
41648 resultobj = wxPyMake_wxObject(result, 0);
41649 }
41650 return resultobj;
41651 fail:
41652 return NULL;
41653 }
41654
41655
41656 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41657 PyObject *resultobj;
41658 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41659 wxButton *result;
41660 PyObject * obj0 = 0 ;
41661 char *kwnames[] = {
41662 (char *) "self", NULL
41663 };
41664
41665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41667 if (SWIG_arg_fail(1)) SWIG_fail;
41668 {
41669 PyThreadState* __tstate = wxPyBeginAllowThreads();
41670 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41671
41672 wxPyEndAllowThreads(__tstate);
41673 if (PyErr_Occurred()) SWIG_fail;
41674 }
41675 {
41676 resultobj = wxPyMake_wxObject(result, 0);
41677 }
41678 return resultobj;
41679 fail:
41680 return NULL;
41681 }
41682
41683
41684 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41685 PyObject *resultobj;
41686 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41687 wxButton *result;
41688 PyObject * obj0 = 0 ;
41689 char *kwnames[] = {
41690 (char *) "self", NULL
41691 };
41692
41693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41695 if (SWIG_arg_fail(1)) SWIG_fail;
41696 {
41697 PyThreadState* __tstate = wxPyBeginAllowThreads();
41698 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41699
41700 wxPyEndAllowThreads(__tstate);
41701 if (PyErr_Occurred()) SWIG_fail;
41702 }
41703 {
41704 resultobj = wxPyMake_wxObject(result, 0);
41705 }
41706 return resultobj;
41707 fail:
41708 return NULL;
41709 }
41710
41711
41712 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41713 PyObject *resultobj;
41714 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41715 wxButton *result;
41716 PyObject * obj0 = 0 ;
41717 char *kwnames[] = {
41718 (char *) "self", NULL
41719 };
41720
41721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41723 if (SWIG_arg_fail(1)) SWIG_fail;
41724 {
41725 PyThreadState* __tstate = wxPyBeginAllowThreads();
41726 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41727
41728 wxPyEndAllowThreads(__tstate);
41729 if (PyErr_Occurred()) SWIG_fail;
41730 }
41731 {
41732 resultobj = wxPyMake_wxObject(result, 0);
41733 }
41734 return resultobj;
41735 fail:
41736 return NULL;
41737 }
41738
41739
41740 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41741 PyObject *obj;
41742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41743 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41744 Py_INCREF(obj);
41745 return Py_BuildValue((char *)"");
41746 }
41747 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41748 PyObject *resultobj;
41749 int arg1 = (int) 0 ;
41750 int arg2 = (int) 0 ;
41751 wxGBPosition *result;
41752 PyObject * obj0 = 0 ;
41753 PyObject * obj1 = 0 ;
41754 char *kwnames[] = {
41755 (char *) "row",(char *) "col", NULL
41756 };
41757
41758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41759 if (obj0) {
41760 {
41761 arg1 = (int)(SWIG_As_int(obj0));
41762 if (SWIG_arg_fail(1)) SWIG_fail;
41763 }
41764 }
41765 if (obj1) {
41766 {
41767 arg2 = (int)(SWIG_As_int(obj1));
41768 if (SWIG_arg_fail(2)) SWIG_fail;
41769 }
41770 }
41771 {
41772 PyThreadState* __tstate = wxPyBeginAllowThreads();
41773 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41774
41775 wxPyEndAllowThreads(__tstate);
41776 if (PyErr_Occurred()) SWIG_fail;
41777 }
41778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41779 return resultobj;
41780 fail:
41781 return NULL;
41782 }
41783
41784
41785 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41786 PyObject *resultobj;
41787 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41788 int result;
41789 PyObject * obj0 = 0 ;
41790 char *kwnames[] = {
41791 (char *) "self", NULL
41792 };
41793
41794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41796 if (SWIG_arg_fail(1)) SWIG_fail;
41797 {
41798 PyThreadState* __tstate = wxPyBeginAllowThreads();
41799 result = (int)((wxGBPosition const *)arg1)->GetRow();
41800
41801 wxPyEndAllowThreads(__tstate);
41802 if (PyErr_Occurred()) SWIG_fail;
41803 }
41804 {
41805 resultobj = SWIG_From_int((int)(result));
41806 }
41807 return resultobj;
41808 fail:
41809 return NULL;
41810 }
41811
41812
41813 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41814 PyObject *resultobj;
41815 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41816 int result;
41817 PyObject * obj0 = 0 ;
41818 char *kwnames[] = {
41819 (char *) "self", NULL
41820 };
41821
41822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41824 if (SWIG_arg_fail(1)) SWIG_fail;
41825 {
41826 PyThreadState* __tstate = wxPyBeginAllowThreads();
41827 result = (int)((wxGBPosition const *)arg1)->GetCol();
41828
41829 wxPyEndAllowThreads(__tstate);
41830 if (PyErr_Occurred()) SWIG_fail;
41831 }
41832 {
41833 resultobj = SWIG_From_int((int)(result));
41834 }
41835 return resultobj;
41836 fail:
41837 return NULL;
41838 }
41839
41840
41841 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41842 PyObject *resultobj;
41843 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41844 int arg2 ;
41845 PyObject * obj0 = 0 ;
41846 PyObject * obj1 = 0 ;
41847 char *kwnames[] = {
41848 (char *) "self",(char *) "row", NULL
41849 };
41850
41851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41853 if (SWIG_arg_fail(1)) SWIG_fail;
41854 {
41855 arg2 = (int)(SWIG_As_int(obj1));
41856 if (SWIG_arg_fail(2)) SWIG_fail;
41857 }
41858 {
41859 PyThreadState* __tstate = wxPyBeginAllowThreads();
41860 (arg1)->SetRow(arg2);
41861
41862 wxPyEndAllowThreads(__tstate);
41863 if (PyErr_Occurred()) SWIG_fail;
41864 }
41865 Py_INCREF(Py_None); resultobj = Py_None;
41866 return resultobj;
41867 fail:
41868 return NULL;
41869 }
41870
41871
41872 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41873 PyObject *resultobj;
41874 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41875 int arg2 ;
41876 PyObject * obj0 = 0 ;
41877 PyObject * obj1 = 0 ;
41878 char *kwnames[] = {
41879 (char *) "self",(char *) "col", NULL
41880 };
41881
41882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41884 if (SWIG_arg_fail(1)) SWIG_fail;
41885 {
41886 arg2 = (int)(SWIG_As_int(obj1));
41887 if (SWIG_arg_fail(2)) SWIG_fail;
41888 }
41889 {
41890 PyThreadState* __tstate = wxPyBeginAllowThreads();
41891 (arg1)->SetCol(arg2);
41892
41893 wxPyEndAllowThreads(__tstate);
41894 if (PyErr_Occurred()) SWIG_fail;
41895 }
41896 Py_INCREF(Py_None); resultobj = Py_None;
41897 return resultobj;
41898 fail:
41899 return NULL;
41900 }
41901
41902
41903 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41904 PyObject *resultobj;
41905 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41906 wxGBPosition *arg2 = 0 ;
41907 bool result;
41908 wxGBPosition temp2 ;
41909 PyObject * obj0 = 0 ;
41910 PyObject * obj1 = 0 ;
41911 char *kwnames[] = {
41912 (char *) "self",(char *) "other", NULL
41913 };
41914
41915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41917 if (SWIG_arg_fail(1)) SWIG_fail;
41918 {
41919 arg2 = &temp2;
41920 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41921 }
41922 {
41923 PyThreadState* __tstate = wxPyBeginAllowThreads();
41924 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41925
41926 wxPyEndAllowThreads(__tstate);
41927 if (PyErr_Occurred()) SWIG_fail;
41928 }
41929 {
41930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41931 }
41932 return resultobj;
41933 fail:
41934 return NULL;
41935 }
41936
41937
41938 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41939 PyObject *resultobj;
41940 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41941 wxGBPosition *arg2 = 0 ;
41942 bool result;
41943 wxGBPosition temp2 ;
41944 PyObject * obj0 = 0 ;
41945 PyObject * obj1 = 0 ;
41946 char *kwnames[] = {
41947 (char *) "self",(char *) "other", NULL
41948 };
41949
41950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41952 if (SWIG_arg_fail(1)) SWIG_fail;
41953 {
41954 arg2 = &temp2;
41955 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41956 }
41957 {
41958 PyThreadState* __tstate = wxPyBeginAllowThreads();
41959 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41960
41961 wxPyEndAllowThreads(__tstate);
41962 if (PyErr_Occurred()) SWIG_fail;
41963 }
41964 {
41965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41966 }
41967 return resultobj;
41968 fail:
41969 return NULL;
41970 }
41971
41972
41973 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41974 PyObject *resultobj;
41975 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41976 int arg2 = (int) 0 ;
41977 int arg3 = (int) 0 ;
41978 PyObject * obj0 = 0 ;
41979 PyObject * obj1 = 0 ;
41980 PyObject * obj2 = 0 ;
41981 char *kwnames[] = {
41982 (char *) "self",(char *) "row",(char *) "col", NULL
41983 };
41984
41985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41987 if (SWIG_arg_fail(1)) SWIG_fail;
41988 if (obj1) {
41989 {
41990 arg2 = (int)(SWIG_As_int(obj1));
41991 if (SWIG_arg_fail(2)) SWIG_fail;
41992 }
41993 }
41994 if (obj2) {
41995 {
41996 arg3 = (int)(SWIG_As_int(obj2));
41997 if (SWIG_arg_fail(3)) SWIG_fail;
41998 }
41999 }
42000 {
42001 PyThreadState* __tstate = wxPyBeginAllowThreads();
42002 wxGBPosition_Set(arg1,arg2,arg3);
42003
42004 wxPyEndAllowThreads(__tstate);
42005 if (PyErr_Occurred()) SWIG_fail;
42006 }
42007 Py_INCREF(Py_None); resultobj = Py_None;
42008 return resultobj;
42009 fail:
42010 return NULL;
42011 }
42012
42013
42014 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42015 PyObject *resultobj;
42016 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42017 PyObject *result;
42018 PyObject * obj0 = 0 ;
42019 char *kwnames[] = {
42020 (char *) "self", NULL
42021 };
42022
42023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42025 if (SWIG_arg_fail(1)) SWIG_fail;
42026 {
42027 PyThreadState* __tstate = wxPyBeginAllowThreads();
42028 result = (PyObject *)wxGBPosition_Get(arg1);
42029
42030 wxPyEndAllowThreads(__tstate);
42031 if (PyErr_Occurred()) SWIG_fail;
42032 }
42033 resultobj = result;
42034 return resultobj;
42035 fail:
42036 return NULL;
42037 }
42038
42039
42040 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42041 PyObject *obj;
42042 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42043 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42044 Py_INCREF(obj);
42045 return Py_BuildValue((char *)"");
42046 }
42047 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42048 PyObject *resultobj;
42049 int arg1 = (int) 1 ;
42050 int arg2 = (int) 1 ;
42051 wxGBSpan *result;
42052 PyObject * obj0 = 0 ;
42053 PyObject * obj1 = 0 ;
42054 char *kwnames[] = {
42055 (char *) "rowspan",(char *) "colspan", NULL
42056 };
42057
42058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42059 if (obj0) {
42060 {
42061 arg1 = (int)(SWIG_As_int(obj0));
42062 if (SWIG_arg_fail(1)) SWIG_fail;
42063 }
42064 }
42065 if (obj1) {
42066 {
42067 arg2 = (int)(SWIG_As_int(obj1));
42068 if (SWIG_arg_fail(2)) SWIG_fail;
42069 }
42070 }
42071 {
42072 PyThreadState* __tstate = wxPyBeginAllowThreads();
42073 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42074
42075 wxPyEndAllowThreads(__tstate);
42076 if (PyErr_Occurred()) SWIG_fail;
42077 }
42078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42079 return resultobj;
42080 fail:
42081 return NULL;
42082 }
42083
42084
42085 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42086 PyObject *resultobj;
42087 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42088 int result;
42089 PyObject * obj0 = 0 ;
42090 char *kwnames[] = {
42091 (char *) "self", NULL
42092 };
42093
42094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42096 if (SWIG_arg_fail(1)) SWIG_fail;
42097 {
42098 PyThreadState* __tstate = wxPyBeginAllowThreads();
42099 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42100
42101 wxPyEndAllowThreads(__tstate);
42102 if (PyErr_Occurred()) SWIG_fail;
42103 }
42104 {
42105 resultobj = SWIG_From_int((int)(result));
42106 }
42107 return resultobj;
42108 fail:
42109 return NULL;
42110 }
42111
42112
42113 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42114 PyObject *resultobj;
42115 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42116 int result;
42117 PyObject * obj0 = 0 ;
42118 char *kwnames[] = {
42119 (char *) "self", NULL
42120 };
42121
42122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42124 if (SWIG_arg_fail(1)) SWIG_fail;
42125 {
42126 PyThreadState* __tstate = wxPyBeginAllowThreads();
42127 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42128
42129 wxPyEndAllowThreads(__tstate);
42130 if (PyErr_Occurred()) SWIG_fail;
42131 }
42132 {
42133 resultobj = SWIG_From_int((int)(result));
42134 }
42135 return resultobj;
42136 fail:
42137 return NULL;
42138 }
42139
42140
42141 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42142 PyObject *resultobj;
42143 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42144 int arg2 ;
42145 PyObject * obj0 = 0 ;
42146 PyObject * obj1 = 0 ;
42147 char *kwnames[] = {
42148 (char *) "self",(char *) "rowspan", NULL
42149 };
42150
42151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42153 if (SWIG_arg_fail(1)) SWIG_fail;
42154 {
42155 arg2 = (int)(SWIG_As_int(obj1));
42156 if (SWIG_arg_fail(2)) SWIG_fail;
42157 }
42158 {
42159 PyThreadState* __tstate = wxPyBeginAllowThreads();
42160 (arg1)->SetRowspan(arg2);
42161
42162 wxPyEndAllowThreads(__tstate);
42163 if (PyErr_Occurred()) SWIG_fail;
42164 }
42165 Py_INCREF(Py_None); resultobj = Py_None;
42166 return resultobj;
42167 fail:
42168 return NULL;
42169 }
42170
42171
42172 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42173 PyObject *resultobj;
42174 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42175 int arg2 ;
42176 PyObject * obj0 = 0 ;
42177 PyObject * obj1 = 0 ;
42178 char *kwnames[] = {
42179 (char *) "self",(char *) "colspan", NULL
42180 };
42181
42182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42184 if (SWIG_arg_fail(1)) SWIG_fail;
42185 {
42186 arg2 = (int)(SWIG_As_int(obj1));
42187 if (SWIG_arg_fail(2)) SWIG_fail;
42188 }
42189 {
42190 PyThreadState* __tstate = wxPyBeginAllowThreads();
42191 (arg1)->SetColspan(arg2);
42192
42193 wxPyEndAllowThreads(__tstate);
42194 if (PyErr_Occurred()) SWIG_fail;
42195 }
42196 Py_INCREF(Py_None); resultobj = Py_None;
42197 return resultobj;
42198 fail:
42199 return NULL;
42200 }
42201
42202
42203 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42204 PyObject *resultobj;
42205 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42206 wxGBSpan *arg2 = 0 ;
42207 bool result;
42208 wxGBSpan temp2 ;
42209 PyObject * obj0 = 0 ;
42210 PyObject * obj1 = 0 ;
42211 char *kwnames[] = {
42212 (char *) "self",(char *) "other", NULL
42213 };
42214
42215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42217 if (SWIG_arg_fail(1)) SWIG_fail;
42218 {
42219 arg2 = &temp2;
42220 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42221 }
42222 {
42223 PyThreadState* __tstate = wxPyBeginAllowThreads();
42224 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42225
42226 wxPyEndAllowThreads(__tstate);
42227 if (PyErr_Occurred()) SWIG_fail;
42228 }
42229 {
42230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42231 }
42232 return resultobj;
42233 fail:
42234 return NULL;
42235 }
42236
42237
42238 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42239 PyObject *resultobj;
42240 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42241 wxGBSpan *arg2 = 0 ;
42242 bool result;
42243 wxGBSpan temp2 ;
42244 PyObject * obj0 = 0 ;
42245 PyObject * obj1 = 0 ;
42246 char *kwnames[] = {
42247 (char *) "self",(char *) "other", NULL
42248 };
42249
42250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42252 if (SWIG_arg_fail(1)) SWIG_fail;
42253 {
42254 arg2 = &temp2;
42255 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42256 }
42257 {
42258 PyThreadState* __tstate = wxPyBeginAllowThreads();
42259 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42260
42261 wxPyEndAllowThreads(__tstate);
42262 if (PyErr_Occurred()) SWIG_fail;
42263 }
42264 {
42265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42266 }
42267 return resultobj;
42268 fail:
42269 return NULL;
42270 }
42271
42272
42273 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42274 PyObject *resultobj;
42275 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42276 int arg2 = (int) 1 ;
42277 int arg3 = (int) 1 ;
42278 PyObject * obj0 = 0 ;
42279 PyObject * obj1 = 0 ;
42280 PyObject * obj2 = 0 ;
42281 char *kwnames[] = {
42282 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42283 };
42284
42285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42287 if (SWIG_arg_fail(1)) SWIG_fail;
42288 if (obj1) {
42289 {
42290 arg2 = (int)(SWIG_As_int(obj1));
42291 if (SWIG_arg_fail(2)) SWIG_fail;
42292 }
42293 }
42294 if (obj2) {
42295 {
42296 arg3 = (int)(SWIG_As_int(obj2));
42297 if (SWIG_arg_fail(3)) SWIG_fail;
42298 }
42299 }
42300 {
42301 PyThreadState* __tstate = wxPyBeginAllowThreads();
42302 wxGBSpan_Set(arg1,arg2,arg3);
42303
42304 wxPyEndAllowThreads(__tstate);
42305 if (PyErr_Occurred()) SWIG_fail;
42306 }
42307 Py_INCREF(Py_None); resultobj = Py_None;
42308 return resultobj;
42309 fail:
42310 return NULL;
42311 }
42312
42313
42314 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42315 PyObject *resultobj;
42316 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42317 PyObject *result;
42318 PyObject * obj0 = 0 ;
42319 char *kwnames[] = {
42320 (char *) "self", NULL
42321 };
42322
42323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42325 if (SWIG_arg_fail(1)) SWIG_fail;
42326 {
42327 PyThreadState* __tstate = wxPyBeginAllowThreads();
42328 result = (PyObject *)wxGBSpan_Get(arg1);
42329
42330 wxPyEndAllowThreads(__tstate);
42331 if (PyErr_Occurred()) SWIG_fail;
42332 }
42333 resultobj = result;
42334 return resultobj;
42335 fail:
42336 return NULL;
42337 }
42338
42339
42340 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42341 PyObject *obj;
42342 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42343 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42344 Py_INCREF(obj);
42345 return Py_BuildValue((char *)"");
42346 }
42347 static int _wrap_DefaultSpan_set(PyObject *) {
42348 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42349 return 1;
42350 }
42351
42352
42353 static PyObject *_wrap_DefaultSpan_get(void) {
42354 PyObject *pyobj;
42355
42356 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42357 return pyobj;
42358 }
42359
42360
42361 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42362 PyObject *resultobj;
42363 wxGBSizerItem *result;
42364 char *kwnames[] = {
42365 NULL
42366 };
42367
42368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42369 {
42370 PyThreadState* __tstate = wxPyBeginAllowThreads();
42371 result = (wxGBSizerItem *)new wxGBSizerItem();
42372
42373 wxPyEndAllowThreads(__tstate);
42374 if (PyErr_Occurred()) SWIG_fail;
42375 }
42376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42377 return resultobj;
42378 fail:
42379 return NULL;
42380 }
42381
42382
42383 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42384 PyObject *resultobj;
42385 wxWindow *arg1 = (wxWindow *) 0 ;
42386 wxGBPosition *arg2 = 0 ;
42387 wxGBSpan *arg3 = 0 ;
42388 int arg4 ;
42389 int arg5 ;
42390 PyObject *arg6 = (PyObject *) NULL ;
42391 wxGBSizerItem *result;
42392 wxGBPosition temp2 ;
42393 wxGBSpan temp3 ;
42394 PyObject * obj0 = 0 ;
42395 PyObject * obj1 = 0 ;
42396 PyObject * obj2 = 0 ;
42397 PyObject * obj3 = 0 ;
42398 PyObject * obj4 = 0 ;
42399 PyObject * obj5 = 0 ;
42400 char *kwnames[] = {
42401 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42402 };
42403
42404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42406 if (SWIG_arg_fail(1)) SWIG_fail;
42407 {
42408 arg2 = &temp2;
42409 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42410 }
42411 {
42412 arg3 = &temp3;
42413 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42414 }
42415 {
42416 arg4 = (int)(SWIG_As_int(obj3));
42417 if (SWIG_arg_fail(4)) SWIG_fail;
42418 }
42419 {
42420 arg5 = (int)(SWIG_As_int(obj4));
42421 if (SWIG_arg_fail(5)) SWIG_fail;
42422 }
42423 if (obj5) {
42424 arg6 = obj5;
42425 }
42426 {
42427 PyThreadState* __tstate = wxPyBeginAllowThreads();
42428 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42429
42430 wxPyEndAllowThreads(__tstate);
42431 if (PyErr_Occurred()) SWIG_fail;
42432 }
42433 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42434 return resultobj;
42435 fail:
42436 return NULL;
42437 }
42438
42439
42440 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42441 PyObject *resultobj;
42442 wxSizer *arg1 = (wxSizer *) 0 ;
42443 wxGBPosition *arg2 = 0 ;
42444 wxGBSpan *arg3 = 0 ;
42445 int arg4 ;
42446 int arg5 ;
42447 PyObject *arg6 = (PyObject *) NULL ;
42448 wxGBSizerItem *result;
42449 wxGBPosition temp2 ;
42450 wxGBSpan temp3 ;
42451 PyObject * obj0 = 0 ;
42452 PyObject * obj1 = 0 ;
42453 PyObject * obj2 = 0 ;
42454 PyObject * obj3 = 0 ;
42455 PyObject * obj4 = 0 ;
42456 PyObject * obj5 = 0 ;
42457 char *kwnames[] = {
42458 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42459 };
42460
42461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42463 if (SWIG_arg_fail(1)) SWIG_fail;
42464 {
42465 arg2 = &temp2;
42466 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42467 }
42468 {
42469 arg3 = &temp3;
42470 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42471 }
42472 {
42473 arg4 = (int)(SWIG_As_int(obj3));
42474 if (SWIG_arg_fail(4)) SWIG_fail;
42475 }
42476 {
42477 arg5 = (int)(SWIG_As_int(obj4));
42478 if (SWIG_arg_fail(5)) SWIG_fail;
42479 }
42480 if (obj5) {
42481 arg6 = obj5;
42482 }
42483 {
42484 PyThreadState* __tstate = wxPyBeginAllowThreads();
42485 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42486
42487 wxPyEndAllowThreads(__tstate);
42488 if (PyErr_Occurred()) SWIG_fail;
42489 }
42490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42491 return resultobj;
42492 fail:
42493 return NULL;
42494 }
42495
42496
42497 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42498 PyObject *resultobj;
42499 int arg1 ;
42500 int arg2 ;
42501 wxGBPosition *arg3 = 0 ;
42502 wxGBSpan *arg4 = 0 ;
42503 int arg5 ;
42504 int arg6 ;
42505 PyObject *arg7 = (PyObject *) NULL ;
42506 wxGBSizerItem *result;
42507 wxGBPosition temp3 ;
42508 wxGBSpan temp4 ;
42509 PyObject * obj0 = 0 ;
42510 PyObject * obj1 = 0 ;
42511 PyObject * obj2 = 0 ;
42512 PyObject * obj3 = 0 ;
42513 PyObject * obj4 = 0 ;
42514 PyObject * obj5 = 0 ;
42515 PyObject * obj6 = 0 ;
42516 char *kwnames[] = {
42517 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42518 };
42519
42520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42521 {
42522 arg1 = (int)(SWIG_As_int(obj0));
42523 if (SWIG_arg_fail(1)) SWIG_fail;
42524 }
42525 {
42526 arg2 = (int)(SWIG_As_int(obj1));
42527 if (SWIG_arg_fail(2)) SWIG_fail;
42528 }
42529 {
42530 arg3 = &temp3;
42531 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42532 }
42533 {
42534 arg4 = &temp4;
42535 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42536 }
42537 {
42538 arg5 = (int)(SWIG_As_int(obj4));
42539 if (SWIG_arg_fail(5)) SWIG_fail;
42540 }
42541 {
42542 arg6 = (int)(SWIG_As_int(obj5));
42543 if (SWIG_arg_fail(6)) SWIG_fail;
42544 }
42545 if (obj6) {
42546 arg7 = obj6;
42547 }
42548 {
42549 PyThreadState* __tstate = wxPyBeginAllowThreads();
42550 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42551
42552 wxPyEndAllowThreads(__tstate);
42553 if (PyErr_Occurred()) SWIG_fail;
42554 }
42555 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42556 return resultobj;
42557 fail:
42558 return NULL;
42559 }
42560
42561
42562 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42563 PyObject *resultobj;
42564 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42565 wxGBPosition result;
42566 PyObject * obj0 = 0 ;
42567 char *kwnames[] = {
42568 (char *) "self", NULL
42569 };
42570
42571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42573 if (SWIG_arg_fail(1)) SWIG_fail;
42574 {
42575 PyThreadState* __tstate = wxPyBeginAllowThreads();
42576 result = ((wxGBSizerItem const *)arg1)->GetPos();
42577
42578 wxPyEndAllowThreads(__tstate);
42579 if (PyErr_Occurred()) SWIG_fail;
42580 }
42581 {
42582 wxGBPosition * resultptr;
42583 resultptr = new wxGBPosition((wxGBPosition &)(result));
42584 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42585 }
42586 return resultobj;
42587 fail:
42588 return NULL;
42589 }
42590
42591
42592 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42593 PyObject *resultobj;
42594 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42595 wxGBSpan result;
42596 PyObject * obj0 = 0 ;
42597 char *kwnames[] = {
42598 (char *) "self", NULL
42599 };
42600
42601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42603 if (SWIG_arg_fail(1)) SWIG_fail;
42604 {
42605 PyThreadState* __tstate = wxPyBeginAllowThreads();
42606 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42607
42608 wxPyEndAllowThreads(__tstate);
42609 if (PyErr_Occurred()) SWIG_fail;
42610 }
42611 {
42612 wxGBSpan * resultptr;
42613 resultptr = new wxGBSpan((wxGBSpan &)(result));
42614 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42615 }
42616 return resultobj;
42617 fail:
42618 return NULL;
42619 }
42620
42621
42622 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42623 PyObject *resultobj;
42624 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42625 wxGBPosition *arg2 = 0 ;
42626 bool result;
42627 wxGBPosition temp2 ;
42628 PyObject * obj0 = 0 ;
42629 PyObject * obj1 = 0 ;
42630 char *kwnames[] = {
42631 (char *) "self",(char *) "pos", NULL
42632 };
42633
42634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42636 if (SWIG_arg_fail(1)) SWIG_fail;
42637 {
42638 arg2 = &temp2;
42639 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42640 }
42641 {
42642 PyThreadState* __tstate = wxPyBeginAllowThreads();
42643 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42644
42645 wxPyEndAllowThreads(__tstate);
42646 if (PyErr_Occurred()) SWIG_fail;
42647 }
42648 {
42649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42650 }
42651 return resultobj;
42652 fail:
42653 return NULL;
42654 }
42655
42656
42657 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42658 PyObject *resultobj;
42659 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42660 wxGBSpan *arg2 = 0 ;
42661 bool result;
42662 wxGBSpan temp2 ;
42663 PyObject * obj0 = 0 ;
42664 PyObject * obj1 = 0 ;
42665 char *kwnames[] = {
42666 (char *) "self",(char *) "span", NULL
42667 };
42668
42669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42671 if (SWIG_arg_fail(1)) SWIG_fail;
42672 {
42673 arg2 = &temp2;
42674 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42675 }
42676 {
42677 PyThreadState* __tstate = wxPyBeginAllowThreads();
42678 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42679
42680 wxPyEndAllowThreads(__tstate);
42681 if (PyErr_Occurred()) SWIG_fail;
42682 }
42683 {
42684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42685 }
42686 return resultobj;
42687 fail:
42688 return NULL;
42689 }
42690
42691
42692 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42693 PyObject *resultobj;
42694 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42695 wxGBSizerItem *arg2 = 0 ;
42696 bool result;
42697 PyObject * obj0 = 0 ;
42698 PyObject * obj1 = 0 ;
42699 char *kwnames[] = {
42700 (char *) "self",(char *) "other", NULL
42701 };
42702
42703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42705 if (SWIG_arg_fail(1)) SWIG_fail;
42706 {
42707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42708 if (SWIG_arg_fail(2)) SWIG_fail;
42709 if (arg2 == NULL) {
42710 SWIG_null_ref("wxGBSizerItem");
42711 }
42712 if (SWIG_arg_fail(2)) SWIG_fail;
42713 }
42714 {
42715 PyThreadState* __tstate = wxPyBeginAllowThreads();
42716 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42717
42718 wxPyEndAllowThreads(__tstate);
42719 if (PyErr_Occurred()) SWIG_fail;
42720 }
42721 {
42722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42723 }
42724 return resultobj;
42725 fail:
42726 return NULL;
42727 }
42728
42729
42730 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42731 PyObject *resultobj;
42732 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42733 wxGBPosition *arg2 = 0 ;
42734 wxGBSpan *arg3 = 0 ;
42735 bool result;
42736 wxGBPosition temp2 ;
42737 wxGBSpan temp3 ;
42738 PyObject * obj0 = 0 ;
42739 PyObject * obj1 = 0 ;
42740 PyObject * obj2 = 0 ;
42741 char *kwnames[] = {
42742 (char *) "self",(char *) "pos",(char *) "span", NULL
42743 };
42744
42745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42747 if (SWIG_arg_fail(1)) SWIG_fail;
42748 {
42749 arg2 = &temp2;
42750 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42751 }
42752 {
42753 arg3 = &temp3;
42754 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42755 }
42756 {
42757 PyThreadState* __tstate = wxPyBeginAllowThreads();
42758 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42759
42760 wxPyEndAllowThreads(__tstate);
42761 if (PyErr_Occurred()) SWIG_fail;
42762 }
42763 {
42764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42765 }
42766 return resultobj;
42767 fail:
42768 return NULL;
42769 }
42770
42771
42772 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42773 PyObject *resultobj;
42774 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42775 wxGBPosition result;
42776 PyObject * obj0 = 0 ;
42777 char *kwnames[] = {
42778 (char *) "self", NULL
42779 };
42780
42781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42783 if (SWIG_arg_fail(1)) SWIG_fail;
42784 {
42785 PyThreadState* __tstate = wxPyBeginAllowThreads();
42786 result = wxGBSizerItem_GetEndPos(arg1);
42787
42788 wxPyEndAllowThreads(__tstate);
42789 if (PyErr_Occurred()) SWIG_fail;
42790 }
42791 {
42792 wxGBPosition * resultptr;
42793 resultptr = new wxGBPosition((wxGBPosition &)(result));
42794 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42795 }
42796 return resultobj;
42797 fail:
42798 return NULL;
42799 }
42800
42801
42802 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42803 PyObject *resultobj;
42804 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42805 wxGridBagSizer *result;
42806 PyObject * obj0 = 0 ;
42807 char *kwnames[] = {
42808 (char *) "self", NULL
42809 };
42810
42811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42813 if (SWIG_arg_fail(1)) SWIG_fail;
42814 {
42815 PyThreadState* __tstate = wxPyBeginAllowThreads();
42816 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42817
42818 wxPyEndAllowThreads(__tstate);
42819 if (PyErr_Occurred()) SWIG_fail;
42820 }
42821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42822 return resultobj;
42823 fail:
42824 return NULL;
42825 }
42826
42827
42828 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42829 PyObject *resultobj;
42830 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42831 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42832 PyObject * obj0 = 0 ;
42833 PyObject * obj1 = 0 ;
42834 char *kwnames[] = {
42835 (char *) "self",(char *) "sizer", NULL
42836 };
42837
42838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42840 if (SWIG_arg_fail(1)) SWIG_fail;
42841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42842 if (SWIG_arg_fail(2)) SWIG_fail;
42843 {
42844 PyThreadState* __tstate = wxPyBeginAllowThreads();
42845 (arg1)->SetGBSizer(arg2);
42846
42847 wxPyEndAllowThreads(__tstate);
42848 if (PyErr_Occurred()) SWIG_fail;
42849 }
42850 Py_INCREF(Py_None); resultobj = Py_None;
42851 return resultobj;
42852 fail:
42853 return NULL;
42854 }
42855
42856
42857 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42858 PyObject *obj;
42859 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42860 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42861 Py_INCREF(obj);
42862 return Py_BuildValue((char *)"");
42863 }
42864 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42865 PyObject *resultobj;
42866 int arg1 = (int) 0 ;
42867 int arg2 = (int) 0 ;
42868 wxGridBagSizer *result;
42869 PyObject * obj0 = 0 ;
42870 PyObject * obj1 = 0 ;
42871 char *kwnames[] = {
42872 (char *) "vgap",(char *) "hgap", NULL
42873 };
42874
42875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42876 if (obj0) {
42877 {
42878 arg1 = (int)(SWIG_As_int(obj0));
42879 if (SWIG_arg_fail(1)) SWIG_fail;
42880 }
42881 }
42882 if (obj1) {
42883 {
42884 arg2 = (int)(SWIG_As_int(obj1));
42885 if (SWIG_arg_fail(2)) SWIG_fail;
42886 }
42887 }
42888 {
42889 PyThreadState* __tstate = wxPyBeginAllowThreads();
42890 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42891
42892 wxPyEndAllowThreads(__tstate);
42893 if (PyErr_Occurred()) SWIG_fail;
42894 }
42895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42896 return resultobj;
42897 fail:
42898 return NULL;
42899 }
42900
42901
42902 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42903 PyObject *resultobj;
42904 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42905 PyObject *arg2 = (PyObject *) 0 ;
42906 wxGBPosition *arg3 = 0 ;
42907 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42908 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42909 int arg5 = (int) 0 ;
42910 int arg6 = (int) 0 ;
42911 PyObject *arg7 = (PyObject *) NULL ;
42912 wxGBSizerItem *result;
42913 wxGBPosition temp3 ;
42914 wxGBSpan temp4 ;
42915 PyObject * obj0 = 0 ;
42916 PyObject * obj1 = 0 ;
42917 PyObject * obj2 = 0 ;
42918 PyObject * obj3 = 0 ;
42919 PyObject * obj4 = 0 ;
42920 PyObject * obj5 = 0 ;
42921 PyObject * obj6 = 0 ;
42922 char *kwnames[] = {
42923 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42924 };
42925
42926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42928 if (SWIG_arg_fail(1)) SWIG_fail;
42929 arg2 = obj1;
42930 {
42931 arg3 = &temp3;
42932 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42933 }
42934 if (obj3) {
42935 {
42936 arg4 = &temp4;
42937 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42938 }
42939 }
42940 if (obj4) {
42941 {
42942 arg5 = (int)(SWIG_As_int(obj4));
42943 if (SWIG_arg_fail(5)) SWIG_fail;
42944 }
42945 }
42946 if (obj5) {
42947 {
42948 arg6 = (int)(SWIG_As_int(obj5));
42949 if (SWIG_arg_fail(6)) SWIG_fail;
42950 }
42951 }
42952 if (obj6) {
42953 arg7 = obj6;
42954 }
42955 {
42956 PyThreadState* __tstate = wxPyBeginAllowThreads();
42957 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42958
42959 wxPyEndAllowThreads(__tstate);
42960 if (PyErr_Occurred()) SWIG_fail;
42961 }
42962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42963 return resultobj;
42964 fail:
42965 return NULL;
42966 }
42967
42968
42969 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42970 PyObject *resultobj;
42971 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42972 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42973 wxGBSizerItem *result;
42974 PyObject * obj0 = 0 ;
42975 PyObject * obj1 = 0 ;
42976 char *kwnames[] = {
42977 (char *) "self",(char *) "item", NULL
42978 };
42979
42980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42982 if (SWIG_arg_fail(1)) SWIG_fail;
42983 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42984 if (SWIG_arg_fail(2)) SWIG_fail;
42985 {
42986 PyThreadState* __tstate = wxPyBeginAllowThreads();
42987 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42988
42989 wxPyEndAllowThreads(__tstate);
42990 if (PyErr_Occurred()) SWIG_fail;
42991 }
42992 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42993 return resultobj;
42994 fail:
42995 return NULL;
42996 }
42997
42998
42999 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43000 PyObject *resultobj;
43001 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43002 int arg2 ;
43003 int arg3 ;
43004 wxSize result;
43005 PyObject * obj0 = 0 ;
43006 PyObject * obj1 = 0 ;
43007 PyObject * obj2 = 0 ;
43008 char *kwnames[] = {
43009 (char *) "self",(char *) "row",(char *) "col", NULL
43010 };
43011
43012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43014 if (SWIG_arg_fail(1)) SWIG_fail;
43015 {
43016 arg2 = (int)(SWIG_As_int(obj1));
43017 if (SWIG_arg_fail(2)) SWIG_fail;
43018 }
43019 {
43020 arg3 = (int)(SWIG_As_int(obj2));
43021 if (SWIG_arg_fail(3)) SWIG_fail;
43022 }
43023 {
43024 PyThreadState* __tstate = wxPyBeginAllowThreads();
43025 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43026
43027 wxPyEndAllowThreads(__tstate);
43028 if (PyErr_Occurred()) SWIG_fail;
43029 }
43030 {
43031 wxSize * resultptr;
43032 resultptr = new wxSize((wxSize &)(result));
43033 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43034 }
43035 return resultobj;
43036 fail:
43037 return NULL;
43038 }
43039
43040
43041 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43042 PyObject *resultobj;
43043 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43044 wxSize result;
43045 PyObject * obj0 = 0 ;
43046 char *kwnames[] = {
43047 (char *) "self", NULL
43048 };
43049
43050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43052 if (SWIG_arg_fail(1)) SWIG_fail;
43053 {
43054 PyThreadState* __tstate = wxPyBeginAllowThreads();
43055 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43056
43057 wxPyEndAllowThreads(__tstate);
43058 if (PyErr_Occurred()) SWIG_fail;
43059 }
43060 {
43061 wxSize * resultptr;
43062 resultptr = new wxSize((wxSize &)(result));
43063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43064 }
43065 return resultobj;
43066 fail:
43067 return NULL;
43068 }
43069
43070
43071 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43072 PyObject *resultobj;
43073 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43074 wxSize *arg2 = 0 ;
43075 wxSize temp2 ;
43076 PyObject * obj0 = 0 ;
43077 PyObject * obj1 = 0 ;
43078 char *kwnames[] = {
43079 (char *) "self",(char *) "sz", NULL
43080 };
43081
43082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43084 if (SWIG_arg_fail(1)) SWIG_fail;
43085 {
43086 arg2 = &temp2;
43087 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43088 }
43089 {
43090 PyThreadState* __tstate = wxPyBeginAllowThreads();
43091 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43092
43093 wxPyEndAllowThreads(__tstate);
43094 if (PyErr_Occurred()) SWIG_fail;
43095 }
43096 Py_INCREF(Py_None); resultobj = Py_None;
43097 return resultobj;
43098 fail:
43099 return NULL;
43100 }
43101
43102
43103 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43104 PyObject *resultobj;
43105 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43106 wxWindow *arg2 = (wxWindow *) 0 ;
43107 wxGBPosition result;
43108 PyObject * obj0 = 0 ;
43109 PyObject * obj1 = 0 ;
43110
43111 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43113 if (SWIG_arg_fail(1)) SWIG_fail;
43114 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43115 if (SWIG_arg_fail(2)) SWIG_fail;
43116 {
43117 PyThreadState* __tstate = wxPyBeginAllowThreads();
43118 result = (arg1)->GetItemPosition(arg2);
43119
43120 wxPyEndAllowThreads(__tstate);
43121 if (PyErr_Occurred()) SWIG_fail;
43122 }
43123 {
43124 wxGBPosition * resultptr;
43125 resultptr = new wxGBPosition((wxGBPosition &)(result));
43126 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43127 }
43128 return resultobj;
43129 fail:
43130 return NULL;
43131 }
43132
43133
43134 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43135 PyObject *resultobj;
43136 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43137 wxSizer *arg2 = (wxSizer *) 0 ;
43138 wxGBPosition result;
43139 PyObject * obj0 = 0 ;
43140 PyObject * obj1 = 0 ;
43141
43142 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43144 if (SWIG_arg_fail(1)) SWIG_fail;
43145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43146 if (SWIG_arg_fail(2)) SWIG_fail;
43147 {
43148 PyThreadState* __tstate = wxPyBeginAllowThreads();
43149 result = (arg1)->GetItemPosition(arg2);
43150
43151 wxPyEndAllowThreads(__tstate);
43152 if (PyErr_Occurred()) SWIG_fail;
43153 }
43154 {
43155 wxGBPosition * resultptr;
43156 resultptr = new wxGBPosition((wxGBPosition &)(result));
43157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43158 }
43159 return resultobj;
43160 fail:
43161 return NULL;
43162 }
43163
43164
43165 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43166 PyObject *resultobj;
43167 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43168 size_t arg2 ;
43169 wxGBPosition result;
43170 PyObject * obj0 = 0 ;
43171 PyObject * obj1 = 0 ;
43172
43173 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43175 if (SWIG_arg_fail(1)) SWIG_fail;
43176 {
43177 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43178 if (SWIG_arg_fail(2)) SWIG_fail;
43179 }
43180 {
43181 PyThreadState* __tstate = wxPyBeginAllowThreads();
43182 result = (arg1)->GetItemPosition(arg2);
43183
43184 wxPyEndAllowThreads(__tstate);
43185 if (PyErr_Occurred()) SWIG_fail;
43186 }
43187 {
43188 wxGBPosition * resultptr;
43189 resultptr = new wxGBPosition((wxGBPosition &)(result));
43190 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43191 }
43192 return resultobj;
43193 fail:
43194 return NULL;
43195 }
43196
43197
43198 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43199 int argc;
43200 PyObject *argv[3];
43201 int ii;
43202
43203 argc = PyObject_Length(args);
43204 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43205 argv[ii] = PyTuple_GetItem(args,ii);
43206 }
43207 if (argc == 2) {
43208 int _v;
43209 {
43210 void *ptr;
43211 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43212 _v = 0;
43213 PyErr_Clear();
43214 } else {
43215 _v = 1;
43216 }
43217 }
43218 if (_v) {
43219 {
43220 void *ptr;
43221 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43222 _v = 0;
43223 PyErr_Clear();
43224 } else {
43225 _v = 1;
43226 }
43227 }
43228 if (_v) {
43229 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43230 }
43231 }
43232 }
43233 if (argc == 2) {
43234 int _v;
43235 {
43236 void *ptr;
43237 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43238 _v = 0;
43239 PyErr_Clear();
43240 } else {
43241 _v = 1;
43242 }
43243 }
43244 if (_v) {
43245 {
43246 void *ptr;
43247 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43248 _v = 0;
43249 PyErr_Clear();
43250 } else {
43251 _v = 1;
43252 }
43253 }
43254 if (_v) {
43255 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43256 }
43257 }
43258 }
43259 if (argc == 2) {
43260 int _v;
43261 {
43262 void *ptr;
43263 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43264 _v = 0;
43265 PyErr_Clear();
43266 } else {
43267 _v = 1;
43268 }
43269 }
43270 if (_v) {
43271 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43272 if (_v) {
43273 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43274 }
43275 }
43276 }
43277
43278 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43279 return NULL;
43280 }
43281
43282
43283 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43284 PyObject *resultobj;
43285 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43286 wxWindow *arg2 = (wxWindow *) 0 ;
43287 wxGBPosition *arg3 = 0 ;
43288 bool result;
43289 wxGBPosition temp3 ;
43290 PyObject * obj0 = 0 ;
43291 PyObject * obj1 = 0 ;
43292 PyObject * obj2 = 0 ;
43293
43294 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43296 if (SWIG_arg_fail(1)) SWIG_fail;
43297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43298 if (SWIG_arg_fail(2)) SWIG_fail;
43299 {
43300 arg3 = &temp3;
43301 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43302 }
43303 {
43304 PyThreadState* __tstate = wxPyBeginAllowThreads();
43305 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43306
43307 wxPyEndAllowThreads(__tstate);
43308 if (PyErr_Occurred()) SWIG_fail;
43309 }
43310 {
43311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43312 }
43313 return resultobj;
43314 fail:
43315 return NULL;
43316 }
43317
43318
43319 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43320 PyObject *resultobj;
43321 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43322 wxSizer *arg2 = (wxSizer *) 0 ;
43323 wxGBPosition *arg3 = 0 ;
43324 bool result;
43325 wxGBPosition temp3 ;
43326 PyObject * obj0 = 0 ;
43327 PyObject * obj1 = 0 ;
43328 PyObject * obj2 = 0 ;
43329
43330 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43332 if (SWIG_arg_fail(1)) SWIG_fail;
43333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43334 if (SWIG_arg_fail(2)) SWIG_fail;
43335 {
43336 arg3 = &temp3;
43337 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43338 }
43339 {
43340 PyThreadState* __tstate = wxPyBeginAllowThreads();
43341 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43342
43343 wxPyEndAllowThreads(__tstate);
43344 if (PyErr_Occurred()) SWIG_fail;
43345 }
43346 {
43347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43348 }
43349 return resultobj;
43350 fail:
43351 return NULL;
43352 }
43353
43354
43355 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43356 PyObject *resultobj;
43357 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43358 size_t arg2 ;
43359 wxGBPosition *arg3 = 0 ;
43360 bool result;
43361 wxGBPosition temp3 ;
43362 PyObject * obj0 = 0 ;
43363 PyObject * obj1 = 0 ;
43364 PyObject * obj2 = 0 ;
43365
43366 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43368 if (SWIG_arg_fail(1)) SWIG_fail;
43369 {
43370 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43371 if (SWIG_arg_fail(2)) SWIG_fail;
43372 }
43373 {
43374 arg3 = &temp3;
43375 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43376 }
43377 {
43378 PyThreadState* __tstate = wxPyBeginAllowThreads();
43379 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43380
43381 wxPyEndAllowThreads(__tstate);
43382 if (PyErr_Occurred()) SWIG_fail;
43383 }
43384 {
43385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43386 }
43387 return resultobj;
43388 fail:
43389 return NULL;
43390 }
43391
43392
43393 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43394 int argc;
43395 PyObject *argv[4];
43396 int ii;
43397
43398 argc = PyObject_Length(args);
43399 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43400 argv[ii] = PyTuple_GetItem(args,ii);
43401 }
43402 if (argc == 3) {
43403 int _v;
43404 {
43405 void *ptr;
43406 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43407 _v = 0;
43408 PyErr_Clear();
43409 } else {
43410 _v = 1;
43411 }
43412 }
43413 if (_v) {
43414 {
43415 void *ptr;
43416 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43417 _v = 0;
43418 PyErr_Clear();
43419 } else {
43420 _v = 1;
43421 }
43422 }
43423 if (_v) {
43424 {
43425 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43426 }
43427 if (_v) {
43428 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43429 }
43430 }
43431 }
43432 }
43433 if (argc == 3) {
43434 int _v;
43435 {
43436 void *ptr;
43437 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43438 _v = 0;
43439 PyErr_Clear();
43440 } else {
43441 _v = 1;
43442 }
43443 }
43444 if (_v) {
43445 {
43446 void *ptr;
43447 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43448 _v = 0;
43449 PyErr_Clear();
43450 } else {
43451 _v = 1;
43452 }
43453 }
43454 if (_v) {
43455 {
43456 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43457 }
43458 if (_v) {
43459 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43460 }
43461 }
43462 }
43463 }
43464 if (argc == 3) {
43465 int _v;
43466 {
43467 void *ptr;
43468 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43469 _v = 0;
43470 PyErr_Clear();
43471 } else {
43472 _v = 1;
43473 }
43474 }
43475 if (_v) {
43476 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43477 if (_v) {
43478 {
43479 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43480 }
43481 if (_v) {
43482 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43483 }
43484 }
43485 }
43486 }
43487
43488 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43489 return NULL;
43490 }
43491
43492
43493 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43494 PyObject *resultobj;
43495 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43496 wxWindow *arg2 = (wxWindow *) 0 ;
43497 wxGBSpan result;
43498 PyObject * obj0 = 0 ;
43499 PyObject * obj1 = 0 ;
43500
43501 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43503 if (SWIG_arg_fail(1)) SWIG_fail;
43504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43505 if (SWIG_arg_fail(2)) SWIG_fail;
43506 {
43507 PyThreadState* __tstate = wxPyBeginAllowThreads();
43508 result = (arg1)->GetItemSpan(arg2);
43509
43510 wxPyEndAllowThreads(__tstate);
43511 if (PyErr_Occurred()) SWIG_fail;
43512 }
43513 {
43514 wxGBSpan * resultptr;
43515 resultptr = new wxGBSpan((wxGBSpan &)(result));
43516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43517 }
43518 return resultobj;
43519 fail:
43520 return NULL;
43521 }
43522
43523
43524 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43525 PyObject *resultobj;
43526 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43527 wxSizer *arg2 = (wxSizer *) 0 ;
43528 wxGBSpan result;
43529 PyObject * obj0 = 0 ;
43530 PyObject * obj1 = 0 ;
43531
43532 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43534 if (SWIG_arg_fail(1)) SWIG_fail;
43535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43536 if (SWIG_arg_fail(2)) SWIG_fail;
43537 {
43538 PyThreadState* __tstate = wxPyBeginAllowThreads();
43539 result = (arg1)->GetItemSpan(arg2);
43540
43541 wxPyEndAllowThreads(__tstate);
43542 if (PyErr_Occurred()) SWIG_fail;
43543 }
43544 {
43545 wxGBSpan * resultptr;
43546 resultptr = new wxGBSpan((wxGBSpan &)(result));
43547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43548 }
43549 return resultobj;
43550 fail:
43551 return NULL;
43552 }
43553
43554
43555 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43556 PyObject *resultobj;
43557 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43558 size_t arg2 ;
43559 wxGBSpan result;
43560 PyObject * obj0 = 0 ;
43561 PyObject * obj1 = 0 ;
43562
43563 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43565 if (SWIG_arg_fail(1)) SWIG_fail;
43566 {
43567 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43568 if (SWIG_arg_fail(2)) SWIG_fail;
43569 }
43570 {
43571 PyThreadState* __tstate = wxPyBeginAllowThreads();
43572 result = (arg1)->GetItemSpan(arg2);
43573
43574 wxPyEndAllowThreads(__tstate);
43575 if (PyErr_Occurred()) SWIG_fail;
43576 }
43577 {
43578 wxGBSpan * resultptr;
43579 resultptr = new wxGBSpan((wxGBSpan &)(result));
43580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43581 }
43582 return resultobj;
43583 fail:
43584 return NULL;
43585 }
43586
43587
43588 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43589 int argc;
43590 PyObject *argv[3];
43591 int ii;
43592
43593 argc = PyObject_Length(args);
43594 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43595 argv[ii] = PyTuple_GetItem(args,ii);
43596 }
43597 if (argc == 2) {
43598 int _v;
43599 {
43600 void *ptr;
43601 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43602 _v = 0;
43603 PyErr_Clear();
43604 } else {
43605 _v = 1;
43606 }
43607 }
43608 if (_v) {
43609 {
43610 void *ptr;
43611 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43612 _v = 0;
43613 PyErr_Clear();
43614 } else {
43615 _v = 1;
43616 }
43617 }
43618 if (_v) {
43619 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43620 }
43621 }
43622 }
43623 if (argc == 2) {
43624 int _v;
43625 {
43626 void *ptr;
43627 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43628 _v = 0;
43629 PyErr_Clear();
43630 } else {
43631 _v = 1;
43632 }
43633 }
43634 if (_v) {
43635 {
43636 void *ptr;
43637 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43638 _v = 0;
43639 PyErr_Clear();
43640 } else {
43641 _v = 1;
43642 }
43643 }
43644 if (_v) {
43645 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43646 }
43647 }
43648 }
43649 if (argc == 2) {
43650 int _v;
43651 {
43652 void *ptr;
43653 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43654 _v = 0;
43655 PyErr_Clear();
43656 } else {
43657 _v = 1;
43658 }
43659 }
43660 if (_v) {
43661 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43662 if (_v) {
43663 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43664 }
43665 }
43666 }
43667
43668 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43669 return NULL;
43670 }
43671
43672
43673 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43674 PyObject *resultobj;
43675 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43676 wxWindow *arg2 = (wxWindow *) 0 ;
43677 wxGBSpan *arg3 = 0 ;
43678 bool result;
43679 wxGBSpan temp3 ;
43680 PyObject * obj0 = 0 ;
43681 PyObject * obj1 = 0 ;
43682 PyObject * obj2 = 0 ;
43683
43684 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43686 if (SWIG_arg_fail(1)) SWIG_fail;
43687 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43688 if (SWIG_arg_fail(2)) SWIG_fail;
43689 {
43690 arg3 = &temp3;
43691 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43692 }
43693 {
43694 PyThreadState* __tstate = wxPyBeginAllowThreads();
43695 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43696
43697 wxPyEndAllowThreads(__tstate);
43698 if (PyErr_Occurred()) SWIG_fail;
43699 }
43700 {
43701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43702 }
43703 return resultobj;
43704 fail:
43705 return NULL;
43706 }
43707
43708
43709 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43710 PyObject *resultobj;
43711 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43712 wxSizer *arg2 = (wxSizer *) 0 ;
43713 wxGBSpan *arg3 = 0 ;
43714 bool result;
43715 wxGBSpan temp3 ;
43716 PyObject * obj0 = 0 ;
43717 PyObject * obj1 = 0 ;
43718 PyObject * obj2 = 0 ;
43719
43720 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43722 if (SWIG_arg_fail(1)) SWIG_fail;
43723 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43724 if (SWIG_arg_fail(2)) SWIG_fail;
43725 {
43726 arg3 = &temp3;
43727 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43728 }
43729 {
43730 PyThreadState* __tstate = wxPyBeginAllowThreads();
43731 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43732
43733 wxPyEndAllowThreads(__tstate);
43734 if (PyErr_Occurred()) SWIG_fail;
43735 }
43736 {
43737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43738 }
43739 return resultobj;
43740 fail:
43741 return NULL;
43742 }
43743
43744
43745 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43746 PyObject *resultobj;
43747 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43748 size_t arg2 ;
43749 wxGBSpan *arg3 = 0 ;
43750 bool result;
43751 wxGBSpan temp3 ;
43752 PyObject * obj0 = 0 ;
43753 PyObject * obj1 = 0 ;
43754 PyObject * obj2 = 0 ;
43755
43756 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43758 if (SWIG_arg_fail(1)) SWIG_fail;
43759 {
43760 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43761 if (SWIG_arg_fail(2)) SWIG_fail;
43762 }
43763 {
43764 arg3 = &temp3;
43765 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43766 }
43767 {
43768 PyThreadState* __tstate = wxPyBeginAllowThreads();
43769 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43770
43771 wxPyEndAllowThreads(__tstate);
43772 if (PyErr_Occurred()) SWIG_fail;
43773 }
43774 {
43775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43776 }
43777 return resultobj;
43778 fail:
43779 return NULL;
43780 }
43781
43782
43783 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43784 int argc;
43785 PyObject *argv[4];
43786 int ii;
43787
43788 argc = PyObject_Length(args);
43789 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43790 argv[ii] = PyTuple_GetItem(args,ii);
43791 }
43792 if (argc == 3) {
43793 int _v;
43794 {
43795 void *ptr;
43796 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43797 _v = 0;
43798 PyErr_Clear();
43799 } else {
43800 _v = 1;
43801 }
43802 }
43803 if (_v) {
43804 {
43805 void *ptr;
43806 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43807 _v = 0;
43808 PyErr_Clear();
43809 } else {
43810 _v = 1;
43811 }
43812 }
43813 if (_v) {
43814 {
43815 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43816 }
43817 if (_v) {
43818 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43819 }
43820 }
43821 }
43822 }
43823 if (argc == 3) {
43824 int _v;
43825 {
43826 void *ptr;
43827 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43828 _v = 0;
43829 PyErr_Clear();
43830 } else {
43831 _v = 1;
43832 }
43833 }
43834 if (_v) {
43835 {
43836 void *ptr;
43837 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43838 _v = 0;
43839 PyErr_Clear();
43840 } else {
43841 _v = 1;
43842 }
43843 }
43844 if (_v) {
43845 {
43846 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43847 }
43848 if (_v) {
43849 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43850 }
43851 }
43852 }
43853 }
43854 if (argc == 3) {
43855 int _v;
43856 {
43857 void *ptr;
43858 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43859 _v = 0;
43860 PyErr_Clear();
43861 } else {
43862 _v = 1;
43863 }
43864 }
43865 if (_v) {
43866 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43867 if (_v) {
43868 {
43869 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43870 }
43871 if (_v) {
43872 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43873 }
43874 }
43875 }
43876 }
43877
43878 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43879 return NULL;
43880 }
43881
43882
43883 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43884 PyObject *resultobj;
43885 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43886 wxWindow *arg2 = (wxWindow *) 0 ;
43887 wxGBSizerItem *result;
43888 PyObject * obj0 = 0 ;
43889 PyObject * obj1 = 0 ;
43890
43891 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43893 if (SWIG_arg_fail(1)) SWIG_fail;
43894 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43895 if (SWIG_arg_fail(2)) SWIG_fail;
43896 {
43897 PyThreadState* __tstate = wxPyBeginAllowThreads();
43898 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43899
43900 wxPyEndAllowThreads(__tstate);
43901 if (PyErr_Occurred()) SWIG_fail;
43902 }
43903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43904 return resultobj;
43905 fail:
43906 return NULL;
43907 }
43908
43909
43910 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43911 PyObject *resultobj;
43912 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43913 wxSizer *arg2 = (wxSizer *) 0 ;
43914 wxGBSizerItem *result;
43915 PyObject * obj0 = 0 ;
43916 PyObject * obj1 = 0 ;
43917
43918 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43920 if (SWIG_arg_fail(1)) SWIG_fail;
43921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43922 if (SWIG_arg_fail(2)) SWIG_fail;
43923 {
43924 PyThreadState* __tstate = wxPyBeginAllowThreads();
43925 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43926
43927 wxPyEndAllowThreads(__tstate);
43928 if (PyErr_Occurred()) SWIG_fail;
43929 }
43930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43931 return resultobj;
43932 fail:
43933 return NULL;
43934 }
43935
43936
43937 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43938 int argc;
43939 PyObject *argv[3];
43940 int ii;
43941
43942 argc = PyObject_Length(args);
43943 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43944 argv[ii] = PyTuple_GetItem(args,ii);
43945 }
43946 if (argc == 2) {
43947 int _v;
43948 {
43949 void *ptr;
43950 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43951 _v = 0;
43952 PyErr_Clear();
43953 } else {
43954 _v = 1;
43955 }
43956 }
43957 if (_v) {
43958 {
43959 void *ptr;
43960 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43961 _v = 0;
43962 PyErr_Clear();
43963 } else {
43964 _v = 1;
43965 }
43966 }
43967 if (_v) {
43968 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43969 }
43970 }
43971 }
43972 if (argc == 2) {
43973 int _v;
43974 {
43975 void *ptr;
43976 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43977 _v = 0;
43978 PyErr_Clear();
43979 } else {
43980 _v = 1;
43981 }
43982 }
43983 if (_v) {
43984 {
43985 void *ptr;
43986 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43987 _v = 0;
43988 PyErr_Clear();
43989 } else {
43990 _v = 1;
43991 }
43992 }
43993 if (_v) {
43994 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43995 }
43996 }
43997 }
43998
43999 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44000 return NULL;
44001 }
44002
44003
44004 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44005 PyObject *resultobj;
44006 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44007 wxGBPosition *arg2 = 0 ;
44008 wxGBSizerItem *result;
44009 wxGBPosition temp2 ;
44010 PyObject * obj0 = 0 ;
44011 PyObject * obj1 = 0 ;
44012 char *kwnames[] = {
44013 (char *) "self",(char *) "pos", NULL
44014 };
44015
44016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44018 if (SWIG_arg_fail(1)) SWIG_fail;
44019 {
44020 arg2 = &temp2;
44021 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44022 }
44023 {
44024 PyThreadState* __tstate = wxPyBeginAllowThreads();
44025 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44026
44027 wxPyEndAllowThreads(__tstate);
44028 if (PyErr_Occurred()) SWIG_fail;
44029 }
44030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44031 return resultobj;
44032 fail:
44033 return NULL;
44034 }
44035
44036
44037 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44038 PyObject *resultobj;
44039 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44040 wxPoint *arg2 = 0 ;
44041 wxGBSizerItem *result;
44042 wxPoint temp2 ;
44043 PyObject * obj0 = 0 ;
44044 PyObject * obj1 = 0 ;
44045 char *kwnames[] = {
44046 (char *) "self",(char *) "pt", NULL
44047 };
44048
44049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44051 if (SWIG_arg_fail(1)) SWIG_fail;
44052 {
44053 arg2 = &temp2;
44054 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44055 }
44056 {
44057 PyThreadState* __tstate = wxPyBeginAllowThreads();
44058 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44059
44060 wxPyEndAllowThreads(__tstate);
44061 if (PyErr_Occurred()) SWIG_fail;
44062 }
44063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44064 return resultobj;
44065 fail:
44066 return NULL;
44067 }
44068
44069
44070 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44071 PyObject *resultobj;
44072 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44073 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44074 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44075 bool result;
44076 PyObject * obj0 = 0 ;
44077 PyObject * obj1 = 0 ;
44078 PyObject * obj2 = 0 ;
44079 char *kwnames[] = {
44080 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44081 };
44082
44083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44085 if (SWIG_arg_fail(1)) SWIG_fail;
44086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44087 if (SWIG_arg_fail(2)) SWIG_fail;
44088 if (obj2) {
44089 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44090 if (SWIG_arg_fail(3)) SWIG_fail;
44091 }
44092 {
44093 PyThreadState* __tstate = wxPyBeginAllowThreads();
44094 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44095
44096 wxPyEndAllowThreads(__tstate);
44097 if (PyErr_Occurred()) SWIG_fail;
44098 }
44099 {
44100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44101 }
44102 return resultobj;
44103 fail:
44104 return NULL;
44105 }
44106
44107
44108 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44109 PyObject *resultobj;
44110 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44111 wxGBPosition *arg2 = 0 ;
44112 wxGBSpan *arg3 = 0 ;
44113 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44114 bool result;
44115 wxGBPosition temp2 ;
44116 wxGBSpan temp3 ;
44117 PyObject * obj0 = 0 ;
44118 PyObject * obj1 = 0 ;
44119 PyObject * obj2 = 0 ;
44120 PyObject * obj3 = 0 ;
44121 char *kwnames[] = {
44122 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44123 };
44124
44125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44127 if (SWIG_arg_fail(1)) SWIG_fail;
44128 {
44129 arg2 = &temp2;
44130 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44131 }
44132 {
44133 arg3 = &temp3;
44134 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44135 }
44136 if (obj3) {
44137 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44138 if (SWIG_arg_fail(4)) SWIG_fail;
44139 }
44140 {
44141 PyThreadState* __tstate = wxPyBeginAllowThreads();
44142 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44143
44144 wxPyEndAllowThreads(__tstate);
44145 if (PyErr_Occurred()) SWIG_fail;
44146 }
44147 {
44148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44149 }
44150 return resultobj;
44151 fail:
44152 return NULL;
44153 }
44154
44155
44156 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44157 PyObject *obj;
44158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44159 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44160 Py_INCREF(obj);
44161 return Py_BuildValue((char *)"");
44162 }
44163 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44164 PyObject *resultobj;
44165 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44166 wxRelationship arg2 ;
44167 wxWindow *arg3 = (wxWindow *) 0 ;
44168 wxEdge arg4 ;
44169 int arg5 = (int) 0 ;
44170 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44171 PyObject * obj0 = 0 ;
44172 PyObject * obj1 = 0 ;
44173 PyObject * obj2 = 0 ;
44174 PyObject * obj3 = 0 ;
44175 PyObject * obj4 = 0 ;
44176 PyObject * obj5 = 0 ;
44177 char *kwnames[] = {
44178 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44179 };
44180
44181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44183 if (SWIG_arg_fail(1)) SWIG_fail;
44184 {
44185 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44186 if (SWIG_arg_fail(2)) SWIG_fail;
44187 }
44188 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44189 if (SWIG_arg_fail(3)) SWIG_fail;
44190 {
44191 arg4 = (wxEdge)(SWIG_As_int(obj3));
44192 if (SWIG_arg_fail(4)) SWIG_fail;
44193 }
44194 if (obj4) {
44195 {
44196 arg5 = (int)(SWIG_As_int(obj4));
44197 if (SWIG_arg_fail(5)) SWIG_fail;
44198 }
44199 }
44200 if (obj5) {
44201 {
44202 arg6 = (int)(SWIG_As_int(obj5));
44203 if (SWIG_arg_fail(6)) SWIG_fail;
44204 }
44205 }
44206 {
44207 PyThreadState* __tstate = wxPyBeginAllowThreads();
44208 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44209
44210 wxPyEndAllowThreads(__tstate);
44211 if (PyErr_Occurred()) SWIG_fail;
44212 }
44213 Py_INCREF(Py_None); resultobj = Py_None;
44214 return resultobj;
44215 fail:
44216 return NULL;
44217 }
44218
44219
44220 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44221 PyObject *resultobj;
44222 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44223 wxWindow *arg2 = (wxWindow *) 0 ;
44224 int arg3 = (int) 0 ;
44225 PyObject * obj0 = 0 ;
44226 PyObject * obj1 = 0 ;
44227 PyObject * obj2 = 0 ;
44228 char *kwnames[] = {
44229 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44230 };
44231
44232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44234 if (SWIG_arg_fail(1)) SWIG_fail;
44235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44236 if (SWIG_arg_fail(2)) SWIG_fail;
44237 if (obj2) {
44238 {
44239 arg3 = (int)(SWIG_As_int(obj2));
44240 if (SWIG_arg_fail(3)) SWIG_fail;
44241 }
44242 }
44243 {
44244 PyThreadState* __tstate = wxPyBeginAllowThreads();
44245 (arg1)->LeftOf(arg2,arg3);
44246
44247 wxPyEndAllowThreads(__tstate);
44248 if (PyErr_Occurred()) SWIG_fail;
44249 }
44250 Py_INCREF(Py_None); resultobj = Py_None;
44251 return resultobj;
44252 fail:
44253 return NULL;
44254 }
44255
44256
44257 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44258 PyObject *resultobj;
44259 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44260 wxWindow *arg2 = (wxWindow *) 0 ;
44261 int arg3 = (int) 0 ;
44262 PyObject * obj0 = 0 ;
44263 PyObject * obj1 = 0 ;
44264 PyObject * obj2 = 0 ;
44265 char *kwnames[] = {
44266 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44267 };
44268
44269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44271 if (SWIG_arg_fail(1)) SWIG_fail;
44272 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44273 if (SWIG_arg_fail(2)) SWIG_fail;
44274 if (obj2) {
44275 {
44276 arg3 = (int)(SWIG_As_int(obj2));
44277 if (SWIG_arg_fail(3)) SWIG_fail;
44278 }
44279 }
44280 {
44281 PyThreadState* __tstate = wxPyBeginAllowThreads();
44282 (arg1)->RightOf(arg2,arg3);
44283
44284 wxPyEndAllowThreads(__tstate);
44285 if (PyErr_Occurred()) SWIG_fail;
44286 }
44287 Py_INCREF(Py_None); resultobj = Py_None;
44288 return resultobj;
44289 fail:
44290 return NULL;
44291 }
44292
44293
44294 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44295 PyObject *resultobj;
44296 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44297 wxWindow *arg2 = (wxWindow *) 0 ;
44298 int arg3 = (int) 0 ;
44299 PyObject * obj0 = 0 ;
44300 PyObject * obj1 = 0 ;
44301 PyObject * obj2 = 0 ;
44302 char *kwnames[] = {
44303 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44304 };
44305
44306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44308 if (SWIG_arg_fail(1)) SWIG_fail;
44309 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44310 if (SWIG_arg_fail(2)) SWIG_fail;
44311 if (obj2) {
44312 {
44313 arg3 = (int)(SWIG_As_int(obj2));
44314 if (SWIG_arg_fail(3)) SWIG_fail;
44315 }
44316 }
44317 {
44318 PyThreadState* __tstate = wxPyBeginAllowThreads();
44319 (arg1)->Above(arg2,arg3);
44320
44321 wxPyEndAllowThreads(__tstate);
44322 if (PyErr_Occurred()) SWIG_fail;
44323 }
44324 Py_INCREF(Py_None); resultobj = Py_None;
44325 return resultobj;
44326 fail:
44327 return NULL;
44328 }
44329
44330
44331 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44332 PyObject *resultobj;
44333 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44334 wxWindow *arg2 = (wxWindow *) 0 ;
44335 int arg3 = (int) 0 ;
44336 PyObject * obj0 = 0 ;
44337 PyObject * obj1 = 0 ;
44338 PyObject * obj2 = 0 ;
44339 char *kwnames[] = {
44340 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44341 };
44342
44343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44345 if (SWIG_arg_fail(1)) SWIG_fail;
44346 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44347 if (SWIG_arg_fail(2)) SWIG_fail;
44348 if (obj2) {
44349 {
44350 arg3 = (int)(SWIG_As_int(obj2));
44351 if (SWIG_arg_fail(3)) SWIG_fail;
44352 }
44353 }
44354 {
44355 PyThreadState* __tstate = wxPyBeginAllowThreads();
44356 (arg1)->Below(arg2,arg3);
44357
44358 wxPyEndAllowThreads(__tstate);
44359 if (PyErr_Occurred()) SWIG_fail;
44360 }
44361 Py_INCREF(Py_None); resultobj = Py_None;
44362 return resultobj;
44363 fail:
44364 return NULL;
44365 }
44366
44367
44368 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44369 PyObject *resultobj;
44370 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44371 wxWindow *arg2 = (wxWindow *) 0 ;
44372 wxEdge arg3 ;
44373 int arg4 = (int) 0 ;
44374 PyObject * obj0 = 0 ;
44375 PyObject * obj1 = 0 ;
44376 PyObject * obj2 = 0 ;
44377 PyObject * obj3 = 0 ;
44378 char *kwnames[] = {
44379 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44380 };
44381
44382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44384 if (SWIG_arg_fail(1)) SWIG_fail;
44385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44386 if (SWIG_arg_fail(2)) SWIG_fail;
44387 {
44388 arg3 = (wxEdge)(SWIG_As_int(obj2));
44389 if (SWIG_arg_fail(3)) SWIG_fail;
44390 }
44391 if (obj3) {
44392 {
44393 arg4 = (int)(SWIG_As_int(obj3));
44394 if (SWIG_arg_fail(4)) SWIG_fail;
44395 }
44396 }
44397 {
44398 PyThreadState* __tstate = wxPyBeginAllowThreads();
44399 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44400
44401 wxPyEndAllowThreads(__tstate);
44402 if (PyErr_Occurred()) SWIG_fail;
44403 }
44404 Py_INCREF(Py_None); resultobj = Py_None;
44405 return resultobj;
44406 fail:
44407 return NULL;
44408 }
44409
44410
44411 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44412 PyObject *resultobj;
44413 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44414 wxWindow *arg2 = (wxWindow *) 0 ;
44415 wxEdge arg3 ;
44416 int arg4 ;
44417 PyObject * obj0 = 0 ;
44418 PyObject * obj1 = 0 ;
44419 PyObject * obj2 = 0 ;
44420 PyObject * obj3 = 0 ;
44421 char *kwnames[] = {
44422 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44423 };
44424
44425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44427 if (SWIG_arg_fail(1)) SWIG_fail;
44428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44429 if (SWIG_arg_fail(2)) SWIG_fail;
44430 {
44431 arg3 = (wxEdge)(SWIG_As_int(obj2));
44432 if (SWIG_arg_fail(3)) SWIG_fail;
44433 }
44434 {
44435 arg4 = (int)(SWIG_As_int(obj3));
44436 if (SWIG_arg_fail(4)) SWIG_fail;
44437 }
44438 {
44439 PyThreadState* __tstate = wxPyBeginAllowThreads();
44440 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44441
44442 wxPyEndAllowThreads(__tstate);
44443 if (PyErr_Occurred()) SWIG_fail;
44444 }
44445 Py_INCREF(Py_None); resultobj = Py_None;
44446 return resultobj;
44447 fail:
44448 return NULL;
44449 }
44450
44451
44452 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44453 PyObject *resultobj;
44454 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44455 int arg2 ;
44456 PyObject * obj0 = 0 ;
44457 PyObject * obj1 = 0 ;
44458 char *kwnames[] = {
44459 (char *) "self",(char *) "val", NULL
44460 };
44461
44462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44464 if (SWIG_arg_fail(1)) SWIG_fail;
44465 {
44466 arg2 = (int)(SWIG_As_int(obj1));
44467 if (SWIG_arg_fail(2)) SWIG_fail;
44468 }
44469 {
44470 PyThreadState* __tstate = wxPyBeginAllowThreads();
44471 (arg1)->Absolute(arg2);
44472
44473 wxPyEndAllowThreads(__tstate);
44474 if (PyErr_Occurred()) SWIG_fail;
44475 }
44476 Py_INCREF(Py_None); resultobj = Py_None;
44477 return resultobj;
44478 fail:
44479 return NULL;
44480 }
44481
44482
44483 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44484 PyObject *resultobj;
44485 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44486 PyObject * obj0 = 0 ;
44487 char *kwnames[] = {
44488 (char *) "self", NULL
44489 };
44490
44491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44493 if (SWIG_arg_fail(1)) SWIG_fail;
44494 {
44495 PyThreadState* __tstate = wxPyBeginAllowThreads();
44496 (arg1)->Unconstrained();
44497
44498 wxPyEndAllowThreads(__tstate);
44499 if (PyErr_Occurred()) SWIG_fail;
44500 }
44501 Py_INCREF(Py_None); resultobj = Py_None;
44502 return resultobj;
44503 fail:
44504 return NULL;
44505 }
44506
44507
44508 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44509 PyObject *resultobj;
44510 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44511 PyObject * obj0 = 0 ;
44512 char *kwnames[] = {
44513 (char *) "self", NULL
44514 };
44515
44516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44518 if (SWIG_arg_fail(1)) SWIG_fail;
44519 {
44520 PyThreadState* __tstate = wxPyBeginAllowThreads();
44521 (arg1)->AsIs();
44522
44523 wxPyEndAllowThreads(__tstate);
44524 if (PyErr_Occurred()) SWIG_fail;
44525 }
44526 Py_INCREF(Py_None); resultobj = Py_None;
44527 return resultobj;
44528 fail:
44529 return NULL;
44530 }
44531
44532
44533 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44534 PyObject *resultobj;
44535 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44536 wxWindow *result;
44537 PyObject * obj0 = 0 ;
44538 char *kwnames[] = {
44539 (char *) "self", NULL
44540 };
44541
44542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44544 if (SWIG_arg_fail(1)) SWIG_fail;
44545 {
44546 PyThreadState* __tstate = wxPyBeginAllowThreads();
44547 result = (wxWindow *)(arg1)->GetOtherWindow();
44548
44549 wxPyEndAllowThreads(__tstate);
44550 if (PyErr_Occurred()) SWIG_fail;
44551 }
44552 {
44553 resultobj = wxPyMake_wxObject(result, 0);
44554 }
44555 return resultobj;
44556 fail:
44557 return NULL;
44558 }
44559
44560
44561 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44562 PyObject *resultobj;
44563 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44564 wxEdge result;
44565 PyObject * obj0 = 0 ;
44566 char *kwnames[] = {
44567 (char *) "self", NULL
44568 };
44569
44570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44572 if (SWIG_arg_fail(1)) SWIG_fail;
44573 {
44574 PyThreadState* __tstate = wxPyBeginAllowThreads();
44575 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44576
44577 wxPyEndAllowThreads(__tstate);
44578 if (PyErr_Occurred()) SWIG_fail;
44579 }
44580 resultobj = SWIG_From_int((result));
44581 return resultobj;
44582 fail:
44583 return NULL;
44584 }
44585
44586
44587 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44588 PyObject *resultobj;
44589 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44590 wxEdge arg2 ;
44591 PyObject * obj0 = 0 ;
44592 PyObject * obj1 = 0 ;
44593 char *kwnames[] = {
44594 (char *) "self",(char *) "which", NULL
44595 };
44596
44597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44599 if (SWIG_arg_fail(1)) SWIG_fail;
44600 {
44601 arg2 = (wxEdge)(SWIG_As_int(obj1));
44602 if (SWIG_arg_fail(2)) SWIG_fail;
44603 }
44604 {
44605 PyThreadState* __tstate = wxPyBeginAllowThreads();
44606 (arg1)->SetEdge((wxEdge )arg2);
44607
44608 wxPyEndAllowThreads(__tstate);
44609 if (PyErr_Occurred()) SWIG_fail;
44610 }
44611 Py_INCREF(Py_None); resultobj = Py_None;
44612 return resultobj;
44613 fail:
44614 return NULL;
44615 }
44616
44617
44618 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44619 PyObject *resultobj;
44620 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44621 int arg2 ;
44622 PyObject * obj0 = 0 ;
44623 PyObject * obj1 = 0 ;
44624 char *kwnames[] = {
44625 (char *) "self",(char *) "v", NULL
44626 };
44627
44628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44630 if (SWIG_arg_fail(1)) SWIG_fail;
44631 {
44632 arg2 = (int)(SWIG_As_int(obj1));
44633 if (SWIG_arg_fail(2)) SWIG_fail;
44634 }
44635 {
44636 PyThreadState* __tstate = wxPyBeginAllowThreads();
44637 (arg1)->SetValue(arg2);
44638
44639 wxPyEndAllowThreads(__tstate);
44640 if (PyErr_Occurred()) SWIG_fail;
44641 }
44642 Py_INCREF(Py_None); resultobj = Py_None;
44643 return resultobj;
44644 fail:
44645 return NULL;
44646 }
44647
44648
44649 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44650 PyObject *resultobj;
44651 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44652 int result;
44653 PyObject * obj0 = 0 ;
44654 char *kwnames[] = {
44655 (char *) "self", NULL
44656 };
44657
44658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44660 if (SWIG_arg_fail(1)) SWIG_fail;
44661 {
44662 PyThreadState* __tstate = wxPyBeginAllowThreads();
44663 result = (int)(arg1)->GetMargin();
44664
44665 wxPyEndAllowThreads(__tstate);
44666 if (PyErr_Occurred()) SWIG_fail;
44667 }
44668 {
44669 resultobj = SWIG_From_int((int)(result));
44670 }
44671 return resultobj;
44672 fail:
44673 return NULL;
44674 }
44675
44676
44677 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44678 PyObject *resultobj;
44679 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44680 int arg2 ;
44681 PyObject * obj0 = 0 ;
44682 PyObject * obj1 = 0 ;
44683 char *kwnames[] = {
44684 (char *) "self",(char *) "m", NULL
44685 };
44686
44687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44689 if (SWIG_arg_fail(1)) SWIG_fail;
44690 {
44691 arg2 = (int)(SWIG_As_int(obj1));
44692 if (SWIG_arg_fail(2)) SWIG_fail;
44693 }
44694 {
44695 PyThreadState* __tstate = wxPyBeginAllowThreads();
44696 (arg1)->SetMargin(arg2);
44697
44698 wxPyEndAllowThreads(__tstate);
44699 if (PyErr_Occurred()) SWIG_fail;
44700 }
44701 Py_INCREF(Py_None); resultobj = Py_None;
44702 return resultobj;
44703 fail:
44704 return NULL;
44705 }
44706
44707
44708 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44709 PyObject *resultobj;
44710 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44711 int result;
44712 PyObject * obj0 = 0 ;
44713 char *kwnames[] = {
44714 (char *) "self", NULL
44715 };
44716
44717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44719 if (SWIG_arg_fail(1)) SWIG_fail;
44720 {
44721 PyThreadState* __tstate = wxPyBeginAllowThreads();
44722 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44723
44724 wxPyEndAllowThreads(__tstate);
44725 if (PyErr_Occurred()) SWIG_fail;
44726 }
44727 {
44728 resultobj = SWIG_From_int((int)(result));
44729 }
44730 return resultobj;
44731 fail:
44732 return NULL;
44733 }
44734
44735
44736 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44737 PyObject *resultobj;
44738 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44739 int result;
44740 PyObject * obj0 = 0 ;
44741 char *kwnames[] = {
44742 (char *) "self", NULL
44743 };
44744
44745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44747 if (SWIG_arg_fail(1)) SWIG_fail;
44748 {
44749 PyThreadState* __tstate = wxPyBeginAllowThreads();
44750 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44751
44752 wxPyEndAllowThreads(__tstate);
44753 if (PyErr_Occurred()) SWIG_fail;
44754 }
44755 {
44756 resultobj = SWIG_From_int((int)(result));
44757 }
44758 return resultobj;
44759 fail:
44760 return NULL;
44761 }
44762
44763
44764 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44765 PyObject *resultobj;
44766 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44767 int result;
44768 PyObject * obj0 = 0 ;
44769 char *kwnames[] = {
44770 (char *) "self", NULL
44771 };
44772
44773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44775 if (SWIG_arg_fail(1)) SWIG_fail;
44776 {
44777 PyThreadState* __tstate = wxPyBeginAllowThreads();
44778 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44779
44780 wxPyEndAllowThreads(__tstate);
44781 if (PyErr_Occurred()) SWIG_fail;
44782 }
44783 {
44784 resultobj = SWIG_From_int((int)(result));
44785 }
44786 return resultobj;
44787 fail:
44788 return NULL;
44789 }
44790
44791
44792 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44793 PyObject *resultobj;
44794 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44795 bool result;
44796 PyObject * obj0 = 0 ;
44797 char *kwnames[] = {
44798 (char *) "self", NULL
44799 };
44800
44801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44803 if (SWIG_arg_fail(1)) SWIG_fail;
44804 {
44805 PyThreadState* __tstate = wxPyBeginAllowThreads();
44806 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44807
44808 wxPyEndAllowThreads(__tstate);
44809 if (PyErr_Occurred()) SWIG_fail;
44810 }
44811 {
44812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44813 }
44814 return resultobj;
44815 fail:
44816 return NULL;
44817 }
44818
44819
44820 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44821 PyObject *resultobj;
44822 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44823 bool arg2 ;
44824 PyObject * obj0 = 0 ;
44825 PyObject * obj1 = 0 ;
44826 char *kwnames[] = {
44827 (char *) "self",(char *) "d", NULL
44828 };
44829
44830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44832 if (SWIG_arg_fail(1)) SWIG_fail;
44833 {
44834 arg2 = (bool)(SWIG_As_bool(obj1));
44835 if (SWIG_arg_fail(2)) SWIG_fail;
44836 }
44837 {
44838 PyThreadState* __tstate = wxPyBeginAllowThreads();
44839 (arg1)->SetDone(arg2);
44840
44841 wxPyEndAllowThreads(__tstate);
44842 if (PyErr_Occurred()) SWIG_fail;
44843 }
44844 Py_INCREF(Py_None); resultobj = Py_None;
44845 return resultobj;
44846 fail:
44847 return NULL;
44848 }
44849
44850
44851 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44852 PyObject *resultobj;
44853 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44854 wxRelationship result;
44855 PyObject * obj0 = 0 ;
44856 char *kwnames[] = {
44857 (char *) "self", NULL
44858 };
44859
44860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44862 if (SWIG_arg_fail(1)) SWIG_fail;
44863 {
44864 PyThreadState* __tstate = wxPyBeginAllowThreads();
44865 result = (wxRelationship)(arg1)->GetRelationship();
44866
44867 wxPyEndAllowThreads(__tstate);
44868 if (PyErr_Occurred()) SWIG_fail;
44869 }
44870 resultobj = SWIG_From_int((result));
44871 return resultobj;
44872 fail:
44873 return NULL;
44874 }
44875
44876
44877 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44878 PyObject *resultobj;
44879 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44880 wxRelationship arg2 ;
44881 PyObject * obj0 = 0 ;
44882 PyObject * obj1 = 0 ;
44883 char *kwnames[] = {
44884 (char *) "self",(char *) "r", NULL
44885 };
44886
44887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44889 if (SWIG_arg_fail(1)) SWIG_fail;
44890 {
44891 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44892 if (SWIG_arg_fail(2)) SWIG_fail;
44893 }
44894 {
44895 PyThreadState* __tstate = wxPyBeginAllowThreads();
44896 (arg1)->SetRelationship((wxRelationship )arg2);
44897
44898 wxPyEndAllowThreads(__tstate);
44899 if (PyErr_Occurred()) SWIG_fail;
44900 }
44901 Py_INCREF(Py_None); resultobj = Py_None;
44902 return resultobj;
44903 fail:
44904 return NULL;
44905 }
44906
44907
44908 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44909 PyObject *resultobj;
44910 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44911 wxWindow *arg2 = (wxWindow *) 0 ;
44912 bool result;
44913 PyObject * obj0 = 0 ;
44914 PyObject * obj1 = 0 ;
44915 char *kwnames[] = {
44916 (char *) "self",(char *) "otherW", NULL
44917 };
44918
44919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44921 if (SWIG_arg_fail(1)) SWIG_fail;
44922 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44923 if (SWIG_arg_fail(2)) SWIG_fail;
44924 {
44925 PyThreadState* __tstate = wxPyBeginAllowThreads();
44926 result = (bool)(arg1)->ResetIfWin(arg2);
44927
44928 wxPyEndAllowThreads(__tstate);
44929 if (PyErr_Occurred()) SWIG_fail;
44930 }
44931 {
44932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44933 }
44934 return resultobj;
44935 fail:
44936 return NULL;
44937 }
44938
44939
44940 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44941 PyObject *resultobj;
44942 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44943 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44944 wxWindow *arg3 = (wxWindow *) 0 ;
44945 bool result;
44946 PyObject * obj0 = 0 ;
44947 PyObject * obj1 = 0 ;
44948 PyObject * obj2 = 0 ;
44949 char *kwnames[] = {
44950 (char *) "self",(char *) "constraints",(char *) "win", NULL
44951 };
44952
44953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44955 if (SWIG_arg_fail(1)) SWIG_fail;
44956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44957 if (SWIG_arg_fail(2)) SWIG_fail;
44958 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44959 if (SWIG_arg_fail(3)) SWIG_fail;
44960 {
44961 PyThreadState* __tstate = wxPyBeginAllowThreads();
44962 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44963
44964 wxPyEndAllowThreads(__tstate);
44965 if (PyErr_Occurred()) SWIG_fail;
44966 }
44967 {
44968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44969 }
44970 return resultobj;
44971 fail:
44972 return NULL;
44973 }
44974
44975
44976 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44977 PyObject *resultobj;
44978 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44979 wxEdge arg2 ;
44980 wxWindow *arg3 = (wxWindow *) 0 ;
44981 wxWindow *arg4 = (wxWindow *) 0 ;
44982 int result;
44983 PyObject * obj0 = 0 ;
44984 PyObject * obj1 = 0 ;
44985 PyObject * obj2 = 0 ;
44986 PyObject * obj3 = 0 ;
44987 char *kwnames[] = {
44988 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44989 };
44990
44991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44993 if (SWIG_arg_fail(1)) SWIG_fail;
44994 {
44995 arg2 = (wxEdge)(SWIG_As_int(obj1));
44996 if (SWIG_arg_fail(2)) SWIG_fail;
44997 }
44998 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44999 if (SWIG_arg_fail(3)) SWIG_fail;
45000 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45001 if (SWIG_arg_fail(4)) SWIG_fail;
45002 {
45003 PyThreadState* __tstate = wxPyBeginAllowThreads();
45004 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45005
45006 wxPyEndAllowThreads(__tstate);
45007 if (PyErr_Occurred()) SWIG_fail;
45008 }
45009 {
45010 resultobj = SWIG_From_int((int)(result));
45011 }
45012 return resultobj;
45013 fail:
45014 return NULL;
45015 }
45016
45017
45018 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45019 PyObject *obj;
45020 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45021 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45022 Py_INCREF(obj);
45023 return Py_BuildValue((char *)"");
45024 }
45025 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45026 PyObject *resultobj;
45027 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45028 wxIndividualLayoutConstraint *result;
45029 PyObject * obj0 = 0 ;
45030 char *kwnames[] = {
45031 (char *) "self", NULL
45032 };
45033
45034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45036 if (SWIG_arg_fail(1)) SWIG_fail;
45037 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45038
45039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45040 return resultobj;
45041 fail:
45042 return NULL;
45043 }
45044
45045
45046 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45047 PyObject *resultobj;
45048 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45049 wxIndividualLayoutConstraint *result;
45050 PyObject * obj0 = 0 ;
45051 char *kwnames[] = {
45052 (char *) "self", NULL
45053 };
45054
45055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45057 if (SWIG_arg_fail(1)) SWIG_fail;
45058 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45059
45060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45061 return resultobj;
45062 fail:
45063 return NULL;
45064 }
45065
45066
45067 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45068 PyObject *resultobj;
45069 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45070 wxIndividualLayoutConstraint *result;
45071 PyObject * obj0 = 0 ;
45072 char *kwnames[] = {
45073 (char *) "self", NULL
45074 };
45075
45076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45078 if (SWIG_arg_fail(1)) SWIG_fail;
45079 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45080
45081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45082 return resultobj;
45083 fail:
45084 return NULL;
45085 }
45086
45087
45088 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45089 PyObject *resultobj;
45090 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45091 wxIndividualLayoutConstraint *result;
45092 PyObject * obj0 = 0 ;
45093 char *kwnames[] = {
45094 (char *) "self", NULL
45095 };
45096
45097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45099 if (SWIG_arg_fail(1)) SWIG_fail;
45100 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45101
45102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45103 return resultobj;
45104 fail:
45105 return NULL;
45106 }
45107
45108
45109 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45110 PyObject *resultobj;
45111 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45112 wxIndividualLayoutConstraint *result;
45113 PyObject * obj0 = 0 ;
45114 char *kwnames[] = {
45115 (char *) "self", NULL
45116 };
45117
45118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45120 if (SWIG_arg_fail(1)) SWIG_fail;
45121 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45122
45123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45124 return resultobj;
45125 fail:
45126 return NULL;
45127 }
45128
45129
45130 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45131 PyObject *resultobj;
45132 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45133 wxIndividualLayoutConstraint *result;
45134 PyObject * obj0 = 0 ;
45135 char *kwnames[] = {
45136 (char *) "self", NULL
45137 };
45138
45139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45141 if (SWIG_arg_fail(1)) SWIG_fail;
45142 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45143
45144 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45145 return resultobj;
45146 fail:
45147 return NULL;
45148 }
45149
45150
45151 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45152 PyObject *resultobj;
45153 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45154 wxIndividualLayoutConstraint *result;
45155 PyObject * obj0 = 0 ;
45156 char *kwnames[] = {
45157 (char *) "self", NULL
45158 };
45159
45160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45162 if (SWIG_arg_fail(1)) SWIG_fail;
45163 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45164
45165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45166 return resultobj;
45167 fail:
45168 return NULL;
45169 }
45170
45171
45172 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45173 PyObject *resultobj;
45174 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45175 wxIndividualLayoutConstraint *result;
45176 PyObject * obj0 = 0 ;
45177 char *kwnames[] = {
45178 (char *) "self", NULL
45179 };
45180
45181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45183 if (SWIG_arg_fail(1)) SWIG_fail;
45184 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45185
45186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45187 return resultobj;
45188 fail:
45189 return NULL;
45190 }
45191
45192
45193 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45194 PyObject *resultobj;
45195 wxLayoutConstraints *result;
45196 char *kwnames[] = {
45197 NULL
45198 };
45199
45200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45201 {
45202 PyThreadState* __tstate = wxPyBeginAllowThreads();
45203 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45204
45205 wxPyEndAllowThreads(__tstate);
45206 if (PyErr_Occurred()) SWIG_fail;
45207 }
45208 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45209 return resultobj;
45210 fail:
45211 return NULL;
45212 }
45213
45214
45215 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45216 PyObject *resultobj;
45217 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45218 wxWindow *arg2 = (wxWindow *) 0 ;
45219 int *arg3 = (int *) 0 ;
45220 bool result;
45221 int temp3 ;
45222 int res3 = 0 ;
45223 PyObject * obj0 = 0 ;
45224 PyObject * obj1 = 0 ;
45225 char *kwnames[] = {
45226 (char *) "self",(char *) "win", NULL
45227 };
45228
45229 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45232 if (SWIG_arg_fail(1)) SWIG_fail;
45233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45234 if (SWIG_arg_fail(2)) SWIG_fail;
45235 {
45236 PyThreadState* __tstate = wxPyBeginAllowThreads();
45237 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45238
45239 wxPyEndAllowThreads(__tstate);
45240 if (PyErr_Occurred()) SWIG_fail;
45241 }
45242 {
45243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45244 }
45245 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45246 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45247 return resultobj;
45248 fail:
45249 return NULL;
45250 }
45251
45252
45253 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45254 PyObject *resultobj;
45255 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45256 bool result;
45257 PyObject * obj0 = 0 ;
45258 char *kwnames[] = {
45259 (char *) "self", NULL
45260 };
45261
45262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45264 if (SWIG_arg_fail(1)) SWIG_fail;
45265 {
45266 PyThreadState* __tstate = wxPyBeginAllowThreads();
45267 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45268
45269 wxPyEndAllowThreads(__tstate);
45270 if (PyErr_Occurred()) SWIG_fail;
45271 }
45272 {
45273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45274 }
45275 return resultobj;
45276 fail:
45277 return NULL;
45278 }
45279
45280
45281 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45282 PyObject *obj;
45283 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45284 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45285 Py_INCREF(obj);
45286 return Py_BuildValue((char *)"");
45287 }
45288 static PyMethodDef SwigMethods[] = {
45289 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45290 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45291 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45294 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45315 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45328 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45343 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45397 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45425 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45444 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45446 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45454 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45455 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45467 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45479 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45483 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45489 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45499 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45509 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45516 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45596 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45598 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45600 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45602 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45604 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45606 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45608 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45610 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45612 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45614 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45616 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45618 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45620 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45634 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45652 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45655 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45658 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45670 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45675 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45681 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45687 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45750 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45757 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45793 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45803 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45809 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45811 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45813 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45816 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45820 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45823 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45826 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45828 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45833 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45841 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45845 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45848 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45850 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45854 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45871 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45873 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45876 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45878 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45882 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45886 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45897 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45900 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45903 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45907 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45914 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45919 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45924 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45928 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45973 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45993 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46000 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46004 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46014 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46186 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46226 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46241 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46244 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46299 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46326 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46370 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46378 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46397 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46398 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46435 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46465 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46468 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46472 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46475 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46485 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46497 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46509 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46519 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46529 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46543 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46550 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46551 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46552 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46553 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46554 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46559 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46586 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46598 { NULL, NULL, 0, NULL }
46599 };
46600
46601
46602 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46603
46604 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46605 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46606 }
46607 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46608 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46609 }
46610 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46611 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46612 }
46613 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46614 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46615 }
46616 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46617 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46618 }
46619 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46620 return (void *)((wxSizer *) ((wxGridSizer *) x));
46621 }
46622 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46623 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46624 }
46625 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46626 return (void *)((wxSizer *) ((wxPySizer *) x));
46627 }
46628 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46629 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46630 }
46631 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46632 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46633 }
46634 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46635 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46636 }
46637 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46638 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46639 }
46640 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46641 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46642 }
46643 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46644 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46645 }
46646 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46647 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46648 }
46649 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46650 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46651 }
46652 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46653 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46654 }
46655 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46656 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46657 }
46658 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46659 return (void *)((wxEvent *) ((wxPyEvent *) x));
46660 }
46661 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46662 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46663 }
46664 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46665 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46666 }
46667 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46668 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46669 }
46670 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46671 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46672 }
46673 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46674 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46675 }
46676 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46677 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46678 }
46679 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46680 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46681 }
46682 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46683 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46684 }
46685 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46686 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46687 }
46688 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46689 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46690 }
46691 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46692 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46693 }
46694 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46695 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46696 }
46697 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46698 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46699 }
46700 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46701 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46702 }
46703 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46704 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46705 }
46706 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46707 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46708 }
46709 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46710 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46711 }
46712 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46713 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46714 }
46715 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46716 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46717 }
46718 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46719 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46720 }
46721 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46722 return (void *)((wxEvent *) ((wxShowEvent *) x));
46723 }
46724 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46725 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46726 }
46727 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46728 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46729 }
46730 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46731 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46732 }
46733 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46734 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46735 }
46736 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46737 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46738 }
46739 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46740 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46741 }
46742 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46743 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46744 }
46745 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46746 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46747 }
46748 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46749 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46750 }
46751 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46752 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46753 }
46754 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46755 return (void *)((wxControl *) ((wxControlWithItems *) x));
46756 }
46757 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46758 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46759 }
46760 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46761 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46762 }
46763 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46764 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46765 }
46766 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46767 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46768 }
46769 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46770 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46771 }
46772 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46773 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46774 }
46775 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46776 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46777 }
46778 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46779 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46780 }
46781 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46782 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46783 }
46784 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46785 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46786 }
46787 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46788 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46789 }
46790 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46791 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46792 }
46793 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46794 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46795 }
46796 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46797 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46798 }
46799 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46800 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46801 }
46802 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46803 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46804 }
46805 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46806 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46807 }
46808 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46809 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46810 }
46811 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46812 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46813 }
46814 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46815 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46816 }
46817 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46818 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46819 }
46820 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46821 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46822 }
46823 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46824 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46825 }
46826 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46827 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46828 }
46829 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46830 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46831 }
46832 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46833 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46834 }
46835 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46836 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46837 }
46838 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46839 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46840 }
46841 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46842 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46843 }
46844 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46845 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46846 }
46847 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46848 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46849 }
46850 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46851 return (void *)((wxObject *) ((wxSizerItem *) x));
46852 }
46853 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46854 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46855 }
46856 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46857 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46858 }
46859 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46860 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46861 }
46862 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46863 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46864 }
46865 static void *_p_wxSizerTo_p_wxObject(void *x) {
46866 return (void *)((wxObject *) ((wxSizer *) x));
46867 }
46868 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46869 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46870 }
46871 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46872 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46873 }
46874 static void *_p_wxEventTo_p_wxObject(void *x) {
46875 return (void *)((wxObject *) ((wxEvent *) x));
46876 }
46877 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46878 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46879 }
46880 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46881 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46882 }
46883 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46884 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46885 }
46886 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46887 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46888 }
46889 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46890 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46891 }
46892 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46893 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46894 }
46895 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46896 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46897 }
46898 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46899 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46900 }
46901 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46902 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46903 }
46904 static void *_p_wxControlTo_p_wxObject(void *x) {
46905 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46906 }
46907 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46908 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46909 }
46910 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46911 return (void *)((wxObject *) ((wxFSFile *) x));
46912 }
46913 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46914 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46915 }
46916 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46917 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46918 }
46919 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46920 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46921 }
46922 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46923 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46924 }
46925 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46926 return (void *)((wxObject *) ((wxMenuItem *) x));
46927 }
46928 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46929 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46930 }
46931 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46932 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46933 }
46934 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46935 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46936 }
46937 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46938 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46939 }
46940 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46941 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46942 }
46943 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46944 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46945 }
46946 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46947 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46948 }
46949 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46950 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46951 }
46952 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46953 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46954 }
46955 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46956 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46957 }
46958 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46959 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46960 }
46961 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46962 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46963 }
46964 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46965 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46966 }
46967 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46968 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46969 }
46970 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46971 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46972 }
46973 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46974 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46975 }
46976 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46977 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46978 }
46979 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46980 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46981 }
46982 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46983 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46984 }
46985 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46986 return (void *)((wxObject *) ((wxImageHandler *) x));
46987 }
46988 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46989 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46990 }
46991 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46992 return (void *)((wxObject *) ((wxEvtHandler *) x));
46993 }
46994 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46995 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46996 }
46997 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46998 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46999 }
47000 static void *_p_wxImageTo_p_wxObject(void *x) {
47001 return (void *)((wxObject *) ((wxImage *) x));
47002 }
47003 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47004 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47005 }
47006 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47007 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47008 }
47009 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47010 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47011 }
47012 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47013 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47014 }
47015 static void *_p_wxWindowTo_p_wxObject(void *x) {
47016 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47017 }
47018 static void *_p_wxMenuTo_p_wxObject(void *x) {
47019 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47020 }
47021 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47022 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47023 }
47024 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47025 return (void *)((wxObject *) ((wxFileSystem *) x));
47026 }
47027 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47028 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47029 }
47030 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47031 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47032 }
47033 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47034 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47035 }
47036 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47037 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47038 }
47039 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47040 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47041 }
47042 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47043 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47044 }
47045 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47046 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47047 }
47048 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47049 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47050 }
47051 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47052 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47053 }
47054 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47055 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47056 }
47057 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47058 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47059 }
47060 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47061 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47062 }
47063 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47064 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47065 }
47066 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47067 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47068 }
47069 static void *_p_wxControlTo_p_wxWindow(void *x) {
47070 return (void *)((wxWindow *) ((wxControl *) x));
47071 }
47072 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47073 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47074 }
47075 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47076 return (void *)((wxWindow *) ((wxMenuBar *) x));
47077 }
47078 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47079 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47080 }
47081 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47082 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47083 }
47084 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47085 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47086 }
47087 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47088 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47089 }
47090 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47091 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47092 }
47093 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47094 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47095 }
47096 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47097 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47098 }
47099 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47100 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47101 }
47102 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47103 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47104 }
47105 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47106 return (void *)((wxValidator *) ((wxPyValidator *) x));
47107 }
47108 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}};
47109 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}};
47110 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}};
47111 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}};
47112 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}};
47113 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}};
47114 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}};
47115 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}};
47116 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}};
47117 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}};
47118 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}};
47119 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}};
47120 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}};
47121 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47122 static swig_type_info _swigt__p_buffer[] = {{"_p_buffer", 0, "buffer *", 0, 0, 0, 0},{"_p_buffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47123 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}};
47124 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}};
47125 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}};
47126 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}};
47127 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}};
47128 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}};
47129 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}};
47130 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}};
47131 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}};
47132 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}};
47133 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}};
47134 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}};
47135 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}};
47136 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}};
47137 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}};
47138 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}};
47139 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}};
47140 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}};
47141 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}};
47142 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}};
47143 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}};
47144 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}};
47145 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}};
47146 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}};
47147 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}};
47148 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}};
47149 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}};
47150 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}};
47151 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}};
47152 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}};
47153 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}};
47154 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}};
47155 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}};
47156 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}};
47157 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}};
47158 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}};
47159 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}};
47160 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}};
47161 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}};
47162 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}};
47163 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}};
47164 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}};
47165 static swig_type_info _swigt__p_wxDateEvent[] = {{"_p_wxDateEvent", 0, "wxDateEvent *", 0, 0, 0, 0},{"_p_wxDateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47166 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}};
47167 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}};
47168 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}};
47169 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}};
47170 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}};
47171 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}};
47172 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}};
47173 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}};
47174 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}};
47175 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}};
47176 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}};
47177 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}};
47178 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}};
47179 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}};
47180 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}};
47181 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}};
47182 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}};
47183 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}};
47184 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}};
47185 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}};
47186 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}};
47187 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}};
47188 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}};
47189 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}};
47190 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}};
47191 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}};
47192 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}};
47193 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}};
47194 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}};
47195 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}};
47196 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}};
47197 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}};
47198 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}};
47199 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}};
47200 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}};
47201 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}};
47202 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}};
47203 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47204 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}};
47205 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}};
47206 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}};
47207 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}};
47208 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}};
47209 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}};
47210 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}};
47211 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}};
47212 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}};
47213 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}};
47214 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}};
47215 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}};
47216 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}};
47217 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}};
47218 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}};
47219 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}};
47220 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47221 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}};
47222 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}};
47223 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}};
47224 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}};
47225 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47226 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}};
47227 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}};
47228 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}};
47229 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}};
47230 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}};
47231 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}};
47232 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}};
47233 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}};
47234 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}};
47235 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}};
47236
47237 static swig_type_info *swig_types_initial[] = {
47238 _swigt__p_wxLayoutConstraints,
47239 _swigt__p_wxRealPoint,
47240 _swigt__p_wxSizerItem,
47241 _swigt__p_wxGBSizerItem,
47242 _swigt__p_wxScrollEvent,
47243 _swigt__p_wxEventLoop,
47244 _swigt__p_wxIndividualLayoutConstraint,
47245 _swigt__p_wxSizer,
47246 _swigt__p_wxBoxSizer,
47247 _swigt__p_wxStaticBoxSizer,
47248 _swigt__p_wxGridBagSizer,
47249 _swigt__p_wxAcceleratorEntry,
47250 _swigt__p_wxUpdateUIEvent,
47251 _swigt__p_wxEvent,
47252 _swigt__p_buffer,
47253 _swigt__p_wxMenu,
47254 _swigt__p_wxGridSizer,
47255 _swigt__p_wxFlexGridSizer,
47256 _swigt__p_wxInitDialogEvent,
47257 _swigt__p_wxItemContainer,
47258 _swigt__p_wxNcPaintEvent,
47259 _swigt__p_wxPaintEvent,
47260 _swigt__p_wxSysColourChangedEvent,
47261 _swigt__p_wxMouseCaptureChangedEvent,
47262 _swigt__p_wxDisplayChangedEvent,
47263 _swigt__p_wxPaletteChangedEvent,
47264 _swigt__p_wxControl,
47265 _swigt__p_wxFont,
47266 _swigt__p_wxMenuBarBase,
47267 _swigt__p_wxSetCursorEvent,
47268 _swigt__p_wxFSFile,
47269 _swigt__p_wxCaret,
47270 _swigt__ptrdiff_t,
47271 _swigt__std__ptrdiff_t,
47272 _swigt__p_wxRegion,
47273 _swigt__p_wxPoint2D,
47274 _swigt__p_int,
47275 _swigt__p_wxSize,
47276 _swigt__p_wxDC,
47277 _swigt__p_wxPySizer,
47278 _swigt__p_wxVisualAttributes,
47279 _swigt__p_wxNotifyEvent,
47280 _swigt__p_wxPyEvent,
47281 _swigt__p_wxPropagationDisabler,
47282 _swigt__p_form_ops_t,
47283 _swigt__p_wxAppTraits,
47284 _swigt__p_wxArrayString,
47285 _swigt__p_wxShowEvent,
47286 _swigt__p_wxToolTip,
47287 _swigt__p_wxMoveEvent,
47288 _swigt__p_wxSizeEvent,
47289 _swigt__p_wxActivateEvent,
47290 _swigt__p_wxIconizeEvent,
47291 _swigt__p_wxMaximizeEvent,
47292 _swigt__p_wxQueryNewPaletteEvent,
47293 _swigt__p_wxWindowCreateEvent,
47294 _swigt__p_wxIdleEvent,
47295 _swigt__p_wxDateEvent,
47296 _swigt__p_wxMenuItem,
47297 _swigt__p_wxStaticBox,
47298 _swigt__p_long,
47299 _swigt__p_wxDuplexMode,
47300 _swigt__p_wxTIFFHandler,
47301 _swigt__p_wxXPMHandler,
47302 _swigt__p_wxPNMHandler,
47303 _swigt__p_wxJPEGHandler,
47304 _swigt__p_wxPCXHandler,
47305 _swigt__p_wxGIFHandler,
47306 _swigt__p_wxPNGHandler,
47307 _swigt__p_wxANIHandler,
47308 _swigt__p_wxMemoryFSHandler,
47309 _swigt__p_wxZipFSHandler,
47310 _swigt__p_wxInternetFSHandler,
47311 _swigt__p_wxPyFileSystemHandler,
47312 _swigt__p_wxEvtHandler,
47313 _swigt__p_wxCURHandler,
47314 _swigt__p_wxICOHandler,
47315 _swigt__p_wxBMPHandler,
47316 _swigt__p_wxImageHandler,
47317 _swigt__p_wxFileSystemHandler,
47318 _swigt__p_wxRect,
47319 _swigt__p_wxButton,
47320 _swigt__p_wxGBSpan,
47321 _swigt__p_wxPropagateOnce,
47322 _swigt__p_wxAcceleratorTable,
47323 _swigt__p_wxStdDialogButtonSizer,
47324 _swigt__p_char,
47325 _swigt__p_wxGBPosition,
47326 _swigt__p_wxImage,
47327 _swigt__p_wxFrame,
47328 _swigt__p_wxScrollWinEvent,
47329 _swigt__p_wxPaperSize,
47330 _swigt__p_wxImageHistogram,
47331 _swigt__p_wxPoint,
47332 _swigt__p_wxCursor,
47333 _swigt__p_wxObject,
47334 _swigt__p_wxInputStream,
47335 _swigt__p_wxOutputStream,
47336 _swigt__p_wxPyInputStream,
47337 _swigt__p_wxDateTime,
47338 _swigt__p_wxKeyEvent,
47339 _swigt__p_wxNavigationKeyEvent,
47340 _swigt__p_wxWindowDestroyEvent,
47341 _swigt__p_unsigned_long,
47342 _swigt__p_wxWindow,
47343 _swigt__p_wxMenuBar,
47344 _swigt__p_wxFileSystem,
47345 _swigt__p_wxBitmap,
47346 _swigt__unsigned_int,
47347 _swigt__p_unsigned_int,
47348 _swigt__p_wxMenuEvent,
47349 _swigt__p_wxContextMenuEvent,
47350 _swigt__p_unsigned_char,
47351 _swigt__p_wxEraseEvent,
47352 _swigt__p_wxMouseEvent,
47353 _swigt__p_wxCloseEvent,
47354 _swigt__p_wxPyApp,
47355 _swigt__p_wxCommandEvent,
47356 _swigt__p_wxPyCommandEvent,
47357 _swigt__p_wxPyDropTarget,
47358 _swigt__p_wxQuantize,
47359 _swigt__p_wxFocusEvent,
47360 _swigt__p_wxChildFocusEvent,
47361 _swigt__p_wxDropFilesEvent,
47362 _swigt__p_wxControlWithItems,
47363 _swigt__p_wxColour,
47364 _swigt__p_wxValidator,
47365 _swigt__p_wxPyValidator,
47366 0
47367 };
47368
47369
47370 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47371
47372 static swig_const_info swig_const_table[] = {
47373 {0, 0, 0, 0.0, 0, 0}};
47374
47375 #ifdef __cplusplus
47376 }
47377 #endif
47378
47379
47380 #ifdef __cplusplus
47381 extern "C" {
47382 #endif
47383
47384 /* Python-specific SWIG API */
47385 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47386 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47387 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47388
47389 /* -----------------------------------------------------------------------------
47390 * global variable support code.
47391 * ----------------------------------------------------------------------------- */
47392
47393 typedef struct swig_globalvar {
47394 char *name; /* Name of global variable */
47395 PyObject *(*get_attr)(); /* Return the current value */
47396 int (*set_attr)(PyObject *); /* Set the value */
47397 struct swig_globalvar *next;
47398 } swig_globalvar;
47399
47400 typedef struct swig_varlinkobject {
47401 PyObject_HEAD
47402 swig_globalvar *vars;
47403 } swig_varlinkobject;
47404
47405 static PyObject *
47406 swig_varlink_repr(swig_varlinkobject *v) {
47407 v = v;
47408 return PyString_FromString("<Swig global variables>");
47409 }
47410
47411 static int
47412 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47413 swig_globalvar *var;
47414 flags = flags;
47415 fprintf(fp,"Swig global variables { ");
47416 for (var = v->vars; var; var=var->next) {
47417 fprintf(fp,"%s", var->name);
47418 if (var->next) fprintf(fp,", ");
47419 }
47420 fprintf(fp," }\n");
47421 return 0;
47422 }
47423
47424 static PyObject *
47425 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47426 swig_globalvar *var = v->vars;
47427 while (var) {
47428 if (strcmp(var->name,n) == 0) {
47429 return (*var->get_attr)();
47430 }
47431 var = var->next;
47432 }
47433 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47434 return NULL;
47435 }
47436
47437 static int
47438 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47439 swig_globalvar *var = v->vars;
47440 while (var) {
47441 if (strcmp(var->name,n) == 0) {
47442 return (*var->set_attr)(p);
47443 }
47444 var = var->next;
47445 }
47446 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47447 return 1;
47448 }
47449
47450 static PyTypeObject varlinktype = {
47451 PyObject_HEAD_INIT(0)
47452 0, /* Number of items in variable part (ob_size) */
47453 (char *)"swigvarlink", /* Type name (tp_name) */
47454 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47455 0, /* Itemsize (tp_itemsize) */
47456 0, /* Deallocator (tp_dealloc) */
47457 (printfunc) swig_varlink_print, /* Print (tp_print) */
47458 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47459 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47460 0, /* tp_compare */
47461 (reprfunc) swig_varlink_repr, /* tp_repr */
47462 0, /* tp_as_number */
47463 0, /* tp_as_sequence */
47464 0, /* tp_as_mapping */
47465 0, /* tp_hash */
47466 0, /* tp_call */
47467 0, /* tp_str */
47468 0, /* tp_getattro */
47469 0, /* tp_setattro */
47470 0, /* tp_as_buffer */
47471 0, /* tp_flags */
47472 0, /* tp_doc */
47473 #if PY_VERSION_HEX >= 0x02000000
47474 0, /* tp_traverse */
47475 0, /* tp_clear */
47476 #endif
47477 #if PY_VERSION_HEX >= 0x02010000
47478 0, /* tp_richcompare */
47479 0, /* tp_weaklistoffset */
47480 #endif
47481 #if PY_VERSION_HEX >= 0x02020000
47482 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47483 #endif
47484 #if PY_VERSION_HEX >= 0x02030000
47485 0, /* tp_del */
47486 #endif
47487 #ifdef COUNT_ALLOCS
47488 0,0,0,0 /* tp_alloc -> tp_next */
47489 #endif
47490 };
47491
47492 /* Create a variable linking object for use later */
47493 static PyObject *
47494 SWIG_Python_newvarlink(void) {
47495 swig_varlinkobject *result = 0;
47496 result = PyMem_NEW(swig_varlinkobject,1);
47497 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47498 result->ob_type = &varlinktype;
47499 result->vars = 0;
47500 result->ob_refcnt = 0;
47501 Py_XINCREF((PyObject *) result);
47502 return ((PyObject*) result);
47503 }
47504
47505 static void
47506 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47507 swig_varlinkobject *v;
47508 swig_globalvar *gv;
47509 v= (swig_varlinkobject *) p;
47510 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47511 gv->name = (char *) malloc(strlen(name)+1);
47512 strcpy(gv->name,name);
47513 gv->get_attr = get_attr;
47514 gv->set_attr = set_attr;
47515 gv->next = v->vars;
47516 v->vars = gv;
47517 }
47518
47519 /* -----------------------------------------------------------------------------
47520 * constants/methods manipulation
47521 * ----------------------------------------------------------------------------- */
47522
47523 /* Install Constants */
47524 static void
47525 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47526 PyObject *obj = 0;
47527 size_t i;
47528 for (i = 0; constants[i].type; i++) {
47529 switch(constants[i].type) {
47530 case SWIG_PY_INT:
47531 obj = PyInt_FromLong(constants[i].lvalue);
47532 break;
47533 case SWIG_PY_FLOAT:
47534 obj = PyFloat_FromDouble(constants[i].dvalue);
47535 break;
47536 case SWIG_PY_STRING:
47537 if (constants[i].pvalue) {
47538 obj = PyString_FromString((char *) constants[i].pvalue);
47539 } else {
47540 Py_INCREF(Py_None);
47541 obj = Py_None;
47542 }
47543 break;
47544 case SWIG_PY_POINTER:
47545 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47546 break;
47547 case SWIG_PY_BINARY:
47548 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47549 break;
47550 default:
47551 obj = 0;
47552 break;
47553 }
47554 if (obj) {
47555 PyDict_SetItemString(d,constants[i].name,obj);
47556 Py_DECREF(obj);
47557 }
47558 }
47559 }
47560
47561 /* -----------------------------------------------------------------------------*/
47562 /* Fix SwigMethods to carry the callback ptrs when needed */
47563 /* -----------------------------------------------------------------------------*/
47564
47565 static void
47566 SWIG_Python_FixMethods(PyMethodDef *methods,
47567 swig_const_info *const_table,
47568 swig_type_info **types,
47569 swig_type_info **types_initial) {
47570 size_t i;
47571 for (i = 0; methods[i].ml_name; ++i) {
47572 char *c = methods[i].ml_doc;
47573 if (c && (c = strstr(c, "swig_ptr: "))) {
47574 int j;
47575 swig_const_info *ci = 0;
47576 char *name = c + 10;
47577 for (j = 0; const_table[j].type; j++) {
47578 if (strncmp(const_table[j].name, name,
47579 strlen(const_table[j].name)) == 0) {
47580 ci = &(const_table[j]);
47581 break;
47582 }
47583 }
47584 if (ci) {
47585 size_t shift = (ci->ptype) - types;
47586 swig_type_info *ty = types_initial[shift];
47587 size_t ldoc = (c - methods[i].ml_doc);
47588 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47589 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47590 char *buff = ndoc;
47591 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47592 strncpy(buff, methods[i].ml_doc, ldoc);
47593 buff += ldoc;
47594 strncpy(buff, "swig_ptr: ", 10);
47595 buff += 10;
47596 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47597 methods[i].ml_doc = ndoc;
47598 }
47599 }
47600 }
47601 }
47602
47603 /* -----------------------------------------------------------------------------*
47604 * Initialize type list
47605 * -----------------------------------------------------------------------------*/
47606
47607 #if PY_MAJOR_VERSION < 2
47608 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47609 is copied out of Python/modsupport.c in python version 2.3.4 */
47610 static int
47611 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47612 {
47613 PyObject *dict;
47614 if (!PyModule_Check(m)) {
47615 PyErr_SetString(PyExc_TypeError,
47616 "PyModule_AddObject() needs module as first arg");
47617 return -1;
47618 }
47619 if (!o) {
47620 PyErr_SetString(PyExc_TypeError,
47621 "PyModule_AddObject() needs non-NULL value");
47622 return -1;
47623 }
47624
47625 dict = PyModule_GetDict(m);
47626 if (dict == NULL) {
47627 /* Internal error -- modules must have a dict! */
47628 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47629 PyModule_GetName(m));
47630 return -1;
47631 }
47632 if (PyDict_SetItemString(dict, name, o))
47633 return -1;
47634 Py_DECREF(o);
47635 return 0;
47636 }
47637 #endif
47638
47639 static swig_type_info **
47640 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47641 static PyMethodDef swig_empty_runtime_method_table[] = {
47642 {
47643 NULL, NULL, 0, NULL
47644 }
47645 };/* Sentinel */
47646
47647 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47648 swig_empty_runtime_method_table);
47649 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47650 if (pointer && module) {
47651 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47652 }
47653 return type_list_handle;
47654 }
47655
47656 static swig_type_info **
47657 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47658 swig_type_info **type_pointer;
47659
47660 /* first check if module already created */
47661 type_pointer = SWIG_Python_GetTypeListHandle();
47662 if (type_pointer) {
47663 return type_pointer;
47664 } else {
47665 /* create a new module and variable */
47666 return SWIG_Python_SetTypeListHandle(type_list_handle);
47667 }
47668 }
47669
47670 #ifdef __cplusplus
47671 }
47672 #endif
47673
47674 /* -----------------------------------------------------------------------------*
47675 * Partial Init method
47676 * -----------------------------------------------------------------------------*/
47677
47678 #ifdef SWIG_LINK_RUNTIME
47679 #ifdef __cplusplus
47680 extern "C"
47681 #endif
47682 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47683 #endif
47684
47685 #ifdef __cplusplus
47686 extern "C"
47687 #endif
47688 SWIGEXPORT(void) SWIG_init(void) {
47689 static PyObject *SWIG_globals = 0;
47690 static int typeinit = 0;
47691 PyObject *m, *d;
47692 int i;
47693 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47694
47695 /* Fix SwigMethods to carry the callback ptrs when needed */
47696 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47697
47698 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47699 d = PyModule_GetDict(m);
47700
47701 if (!typeinit) {
47702 #ifdef SWIG_LINK_RUNTIME
47703 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47704 #else
47705 # ifndef SWIG_STATIC_RUNTIME
47706 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47707 # endif
47708 #endif
47709 for (i = 0; swig_types_initial[i]; i++) {
47710 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47711 }
47712 typeinit = 1;
47713 }
47714 SWIG_InstallConstants(d,swig_const_table);
47715
47716
47717 #ifndef wxPyUSE_EXPORT
47718 // Make our API structure a CObject so other modules can import it
47719 // from this module.
47720 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47721 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47722 Py_XDECREF(cobj);
47723 #endif
47724
47725 {
47726 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49176 }
49177 {
49178 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49179 }
49180 {
49181 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49182 }
49183 {
49184 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49185 }
49186 {
49187 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49188 }
49189 {
49190 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49383 }
49384 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49385 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49386 {
49387 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49388 }
49389 {
49390 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49391 }
49392 {
49393 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49394 }
49395 {
49396 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49397 }
49398 {
49399 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49400 }
49401 {
49402 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49403 }
49404 {
49405 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49406 }
49407 {
49408 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49409 }
49410 {
49411 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49412 }
49413 {
49414 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49415 }
49416 {
49417 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49418 }
49419 {
49420 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49421 }
49422 {
49423 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49424 }
49425 {
49426 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49427 }
49428 {
49429 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49430 }
49431 {
49432 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49433 }
49434 {
49435 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49436 }
49437 {
49438 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49439 }
49440 {
49441 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49442 }
49443 {
49444 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49445 }
49446 {
49447 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49448 }
49449 {
49450 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49451 }
49452 {
49453 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49460 }
49461 {
49462 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49463 }
49464 {
49465 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49466 }
49467 {
49468 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49469 }
49470 {
49471 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49472 }
49473 {
49474 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49475 }
49476 {
49477 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49478 }
49479 {
49480 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49481 }
49482 {
49483 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49484 }
49485 {
49486 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49487 }
49488 {
49489 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49490 }
49491 {
49492 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49514 }
49515 {
49516 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49517 }
49518 {
49519 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49520 }
49521 {
49522 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49529 }
49530 {
49531 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49532 }
49533 {
49534 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49535 }
49536 {
49537 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49538 }
49539 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49540 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49541 {
49542 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49543 }
49544 {
49545 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49546 }
49547 {
49548 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49549 }
49550
49551 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49552
49553
49554 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49555
49556 {
49557 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49564 }
49565 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49566 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49567 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49568 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49569 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49570 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49571 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49572 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49573 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49574 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49575 {
49576 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49577 }
49578 {
49579 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49580 }
49581 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49582 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49583 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49584 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49585 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49586 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49587 {
49588 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49589 }
49590 {
49591 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49595 }
49596 {
49597 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49598 }
49599 {
49600 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49601 }
49602 {
49603 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49604 }
49605 {
49606 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49607 }
49608 {
49609 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49610 }
49611 {
49612 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49613 }
49614 {
49615 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49616 }
49617 {
49618 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49619 }
49620 {
49621 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49622 }
49623 {
49624 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49625 }
49626 {
49627 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49628 }
49629 {
49630 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49631 }
49632 {
49633 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49634 }
49635 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49636 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49637 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49638 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49639 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49640 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49641 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49642 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49643 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49644 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49645 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49646 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49647 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49648 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49649 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49650 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49651 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49652 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49653 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49654 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49655 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49656 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49657 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49658 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49659 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49660 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49661 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49662 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49663 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49664 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49665 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49666 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49667 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49668 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49669 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49670 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49671 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49672 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49673 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49674 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49675 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49676 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49677 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49678 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49679 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49680 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49681 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49682 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49683 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49684 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49685 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49686 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49687 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49688 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49689 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49690 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49691 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49692 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49693 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49694 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49695 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49696 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49697 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49698 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49699 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49700 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49701 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49702 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49703 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49704 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49705 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49706 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49707 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49708 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49709 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49710 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49711 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49712 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49713 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49714 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49715 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49716 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49717 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49718 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49719 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49720 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49721 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49722 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49723 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49724 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49725 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49726 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49727 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49728 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49729 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49730 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49731 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49732 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49733 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49734 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49735 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49736 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49737 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49738 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49739 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49740 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49741 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49742 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49743 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49744 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49745 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49746 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49747 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49748 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49749 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49750 {
49751 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49752 }
49753 {
49754 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49755 }
49756 {
49757 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49758 }
49759 {
49760 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49761 }
49762 {
49763 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49764 }
49765 {
49766 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49767 }
49768 {
49769 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49770 }
49771 {
49772 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49773 }
49774 {
49775 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49776 }
49777 {
49778 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49779 }
49780 {
49781 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49782 }
49783 {
49784 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49785 }
49786 {
49787 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49788 }
49789 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49790 {
49791 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49792 }
49793 {
49794 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49795 }
49796 {
49797 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49798 }
49799 {
49800 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49801 }
49802 {
49803 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49804 }
49805 {
49806 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49807 }
49808 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49809 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49810 {
49811 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49812 }
49813 {
49814 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49815 }
49816 {
49817 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49818 }
49819 {
49820 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49821 }
49822 {
49823 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49824 }
49825 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49826 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49827 {
49828 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49829 }
49830 {
49831 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49832 }
49833 {
49834 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49835 }
49836 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49837 {
49838 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49839 }
49840 {
49841 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49842 }
49843 {
49844 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49845 }
49846 {
49847 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49848 }
49849 {
49850 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49851 }
49852 {
49853 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49854 }
49855 {
49856 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49857 }
49858 {
49859 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49860 }
49861 {
49862 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49863 }
49864 {
49865 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49866 }
49867 {
49868 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49869 }
49870 {
49871 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49887 }
49888 {
49889 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49890 }
49891 {
49892 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49893 }
49894
49895 // Initialize threading, some globals and such
49896 __wxPyPreStart(d);
49897
49898
49899 // Although these are defined in __version__ they need to be here too so
49900 // that an assert can be done to ensure that the wxPython and the wxWindows
49901 // versions match.
49902 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49903 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49904 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49905
49906 }
49907
wxWidgets (Impactor)